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

00001 //
00002 // File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:54:48 2011
00003 
00004 // Do NOT change. Changes will be lost next time file is generated
00005 //
00006 
00007 #define R__DICTIONARY_FILENAME mathdImathmoredIsrcdIG__MathMore
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__MathMore.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 Math {
00038 
00039       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00040       typedef ::ROOT::Math::Polynomial Polynomial;
00041       #else
00042       class Polynomial  :  public ::ROOT::Math::ParamFunction< ::ROOT::Math::IParametricGradFunctionOneDim >,  public ::ROOT::Math::IGradientOneDim {
00043          public:
00044          //friend XX;
00045          typedef ::ROOT::Math::ParamFunction< ::ROOT::Math::IParametricGradFunctionOneDim> ParFunc;
00046          // To force the creation of a virtual table, throw just in case.
00047          virtual ~Polynomial() throw() {};
00048          unsigned int fOrder; //
00049          vector< double > fDerived_params; //
00050          vector< ::complex< double >  > fRoots; //
00051       };
00052       #endif
00053       } } 
00054       namespace ROOT {
00055          namespace Math {
00056 
00057       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00058       typedef ::ROOT::Math::ParamFunction< ::ROOT::Math::IParametricGradFunctionOneDim > ParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR;
00059       #else
00060       class ParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR  :  public ::ROOT::Math::IParametricGradFunctionOneDim {
00061          public:
00062          //friend XX;
00063          typedef ::ROOT::Math::IParametricGradFunctionOneDim BaseParFunc;
00064          typedef ::ROOT::Math::IBaseFunctionOneDim BaseFunc;
00065          // To force the creation of a virtual table, throw just in case.
00066          virtual ~ParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR() throw() {};
00067          unsigned int fNpar; //
00068          vector< double > fParams; //
00069       };
00070       #endif
00071       } } 
00072       namespace ROOT {
00073          namespace Math {
00074 
00075       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00076       typedef ::ROOT::Math::Derivator Derivator;
00077       #else
00078       class Derivator  {
00079          public:
00080          //friend XX;
00081          typedef void* (*GSLFuncPointer)() ;
00082          // To force the creation of a virtual table, throw just in case.
00083          virtual ~Derivator() throw() {};
00084          ::ROOT::Math::GSLDerivator* fDerivator; //
00085       };
00086       #endif
00087       } } 
00088       namespace ROOT {
00089          namespace Math {
00090 
00091       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00092       typedef ::ROOT::Math::Interpolator Interpolator;
00093       #else
00094       class Interpolator  {
00095          public:
00096          //friend XX;
00097          // To force the creation of a virtual table, throw just in case.
00098          virtual ~Interpolator() throw() {};
00099          ::ROOT::Math::GSLInterpolator* fInterp; //pointer to GSL interpolator class
00100       };
00101       #endif
00102       } } 
00103       namespace ROOT {
00104          namespace Math {
00105 
00106       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00107       typedef ::ROOT::Math::GSLRootFinder GSLRootFinder;
00108       #else
00109       class GSLRootFinder  :  public ::ROOT::Math::IRootFinderMethod {
00110          public:
00111          //friend XX;
00112          typedef void* (*GSLFuncPointer)() ;
00113          // To force the creation of a virtual table, throw just in case.
00114          virtual ~GSLRootFinder() throw() {};
00115          ::ROOT::Math::GSLFunctionWrapper* fFunction; //
00116          ::ROOT::Math::GSLRootFSolver* fS; //
00117          double fRoot; //
00118          double fXlow; //
00119          double fXup; //
00120          int fIter; //
00121          int fStatus; //
00122          bool fValidInterval; //
00123       };
00124       #endif
00125       } } 
00126       namespace ROOT {
00127          namespace Math {
00128 
00129       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00130       typedef ::ROOT::Math::GSLRootFinderDeriv GSLRootFinderDeriv;
00131       #else
00132       class GSLRootFinderDeriv  :  public ::ROOT::Math::IRootFinderMethod {
00133          public:
00134          //friend XX;
00135          typedef void* (*GSLFuncPointer)() ;
00136          typedef void* (*GSLFdFPointer)() ;
00137          // To force the creation of a virtual table, throw just in case.
00138          virtual ~GSLRootFinderDeriv() throw() {};
00139          ::ROOT::Math::GSLFunctionDerivWrapper* fFunction; //
00140          ::ROOT::Math::GSLRootFdFSolver* fS; //
00141          double fRoot; //
00142          double fPrevRoot; //
00143          int fIter; //
00144          int fStatus; //
00145          bool fValidPoint; //
00146       };
00147       #endif
00148       } } 
00149       namespace ROOT {
00150          namespace Math {
00151             namespace Roots {
00152 
00153       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00154       typedef ::ROOT::Math::Roots::Bisection Bisection;
00155       #else
00156       class Bisection  :  public ::ROOT::Math::GSLRootFinder {
00157          public:
00158          //friend XX;
00159          // To force the creation of a virtual table, throw just in case.
00160          virtual ~Bisection() throw() {};
00161       };
00162       #endif
00163       } } } 
00164       namespace ROOT {
00165          namespace Math {
00166             namespace Roots {
00167 
00168       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00169       typedef ::ROOT::Math::Roots::FalsePos FalsePos;
00170       #else
00171       class FalsePos  :  public ::ROOT::Math::GSLRootFinder {
00172          public:
00173          //friend XX;
00174          // To force the creation of a virtual table, throw just in case.
00175          virtual ~FalsePos() throw() {};
00176       };
00177       #endif
00178       } } } 
00179       namespace ROOT {
00180          namespace Math {
00181             namespace Roots {
00182 
00183       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00184       typedef ::ROOT::Math::Roots::Brent Brent;
00185       #else
00186       class Brent  :  public ::ROOT::Math::GSLRootFinder {
00187          public:
00188          //friend XX;
00189          // To force the creation of a virtual table, throw just in case.
00190          virtual ~Brent() throw() {};
00191       };
00192       #endif
00193       } } } 
00194       namespace ROOT {
00195          namespace Math {
00196             namespace Roots {
00197 
00198       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00199       typedef ::ROOT::Math::Roots::Newton Newton;
00200       #else
00201       class Newton  :  public ::ROOT::Math::GSLRootFinderDeriv {
00202          public:
00203          //friend XX;
00204          // To force the creation of a virtual table, throw just in case.
00205          virtual ~Newton() throw() {};
00206       };
00207       #endif
00208       } } } 
00209       namespace ROOT {
00210          namespace Math {
00211             namespace Roots {
00212 
00213       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00214       typedef ::ROOT::Math::Roots::Secant Secant;
00215       #else
00216       class Secant  :  public ::ROOT::Math::GSLRootFinderDeriv {
00217          public:
00218          //friend XX;
00219          // To force the creation of a virtual table, throw just in case.
00220          virtual ~Secant() throw() {};
00221       };
00222       #endif
00223       } } } 
00224       namespace ROOT {
00225          namespace Math {
00226             namespace Roots {
00227 
00228       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00229       typedef ::ROOT::Math::Roots::Steffenson Steffenson;
00230       #else
00231       class Steffenson  :  public ::ROOT::Math::GSLRootFinderDeriv {
00232          public:
00233          //friend XX;
00234          // To force the creation of a virtual table, throw just in case.
00235          virtual ~Steffenson() throw() {};
00236       };
00237       #endif
00238       } } } 
00239       namespace ROOT {
00240          namespace Math {
00241 
00242       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00243       typedef ::ROOT::Math::GSLIntegrator GSLIntegrator;
00244       #else
00245       class GSLIntegrator  :  public ::ROOT::Math::VirtualIntegratorOneDim {
00246          public:
00247          //friend XX;
00248          // To force the creation of a virtual table, throw just in case.
00249          virtual ~GSLIntegrator() throw() {};
00250          ::ROOT::Math::IntegrationOneDim::Type fType; //
00251          ::ROOT::Math::Integration::GKRule fRule; //
00252          double fAbsTol; //
00253          double fRelTol; //
00254          unsigned int fSize; //
00255          unsigned int fMaxIntervals; //
00256          double fResult; //
00257          double fError; //
00258          int fStatus; //
00259          int fNEval; //
00260          ::ROOT::Math::GSLFunctionWrapper* fFunction; //
00261          ::ROOT::Math::GSLIntegrationWorkspace* fWorkspace; //
00262       };
00263       #endif
00264       } } 
00265       namespace ROOT {
00266          namespace Math {
00267 
00268       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00269       typedef ::ROOT::Math::VegasParameters VegasParameters;
00270       #else
00271       class VegasParameters  {
00272          public:
00273          //friend XX;
00274          double alpha; //
00275          unsigned int iterations; //
00276          int stage; //
00277          int mode; //
00278          int verbose; //
00279       };
00280       #endif
00281       } } 
00282       namespace ROOT {
00283          namespace Math {
00284 
00285       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00286       typedef ::ROOT::Math::MiserParameters MiserParameters;
00287       #else
00288       class MiserParameters  {
00289          public:
00290          //friend XX;
00291          double estimate_frac; //
00292          unsigned int min_calls; //
00293          unsigned int min_calls_per_bisection; //
00294          double alpha; //
00295          double dither; //
00296       };
00297       #endif
00298       } } 
00299       namespace ROOT {
00300          namespace Math {
00301 
00302       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00303       typedef ::ROOT::Math::GSLMCIntegrator GSLMCIntegrator;
00304       #else
00305       class GSLMCIntegrator  :  public ::ROOT::Math::VirtualIntegratorMultiDim {
00306          public:
00307          //friend XX;
00308          typedef ::ROOT::Math::IntegrationMultiDim::Type Type;
00309          typedef void* (*GSLMonteFuncPointer)() ;
00310          // To force the creation of a virtual table, throw just in case.
00311          virtual ~GSLMCIntegrator() throw() {};
00312          ::ROOT::Math::IntegrationMultiDim::Type fType; //
00313          ::ROOT::Math::GSLRngWrapper* fRng; //
00314          unsigned int fDim; //
00315          unsigned int fCalls; //
00316          double fAbsTol; //
00317          double fRelTol; //
00318          double fResult; //
00319          double fError; //
00320          int fStatus; //
00321          ::ROOT::Math::GSLMCIntegrationWorkspace* fWorkspace; //
00322          ::ROOT::Math::GSLMonteFunctionWrapper* fFunction; //
00323       };
00324       #endif
00325       } } 
00326       namespace ROOT {
00327          namespace Math {
00328 
00329       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00330       typedef ::ROOT::Math::GSLMinimizer1D GSLMinimizer1D;
00331       #else
00332       class GSLMinimizer1D  :  public ::ROOT::Math::IMinimizer1D {
00333          public:
00334          //friend XX;
00335          // To force the creation of a virtual table, throw just in case.
00336          virtual ~GSLMinimizer1D() throw() {};
00337          double fXmin; //
00338          double fXlow; //
00339          double fXup; //
00340          double fMin; //
00341          double fLow; //
00342          double fUp; //
00343          int fIter; //
00344          int fStatus; //status of last minimization (==0 ok =1 failed)
00345          bool fIsSet; //
00346          ::ROOT::Math::GSL1DMinimizerWrapper* fMinimizer; //
00347          ::ROOT::Math::GSLFunctionWrapper* fFunction; //
00348       };
00349       #endif
00350       } } 
00351       namespace ROOT {
00352          namespace Math {
00353 
00354       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00355       typedef ::ROOT::Math::Chebyshev Chebyshev;
00356       #else
00357       class Chebyshev  {
00358          public:
00359          //friend XX;
00360          // To force the creation of a virtual table, throw just in case.
00361          virtual ~Chebyshev() throw() {};
00362          unsigned int fOrder; //
00363          ::ROOT::Math::GSLChebSeries* fSeries; //
00364          ::ROOT::Math::GSLFunctionWrapper* fFunction; //pointer to function
00365       };
00366       #endif
00367       } } 
00368       namespace ROOT {
00369          namespace Math {
00370 
00371       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00372       typedef ::ROOT::Math::GSLRandomEngine GSLRandomEngine;
00373       #else
00374       class GSLRandomEngine  {
00375          public:
00376          //friend XX;
00377          // To force the creation of a virtual table, throw just in case.
00378          virtual ~GSLRandomEngine() throw() {};
00379          ::ROOT::Math::GSLRngWrapper* fRng; //pointer to GSL generator wrapper (managed by the class)
00380          unsigned int fCurTime; //current time used to seed the generator
00381       };
00382       #endif
00383       } } 
00384       namespace ROOT {
00385          namespace Math {
00386 
00387       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00388       typedef ::ROOT::Math::GSLRngMT GSLRngMT;
00389       #else
00390       class GSLRngMT  :  public ::ROOT::Math::GSLRandomEngine {
00391          public:
00392          //friend XX;
00393       };
00394       #endif
00395       } } 
00396       namespace ROOT {
00397          namespace Math {
00398 
00399       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00400       typedef ::ROOT::Math::GSLRngRanLux GSLRngRanLux;
00401       #else
00402       class GSLRngRanLux  :  public ::ROOT::Math::GSLRandomEngine {
00403          public:
00404          //friend XX;
00405       };
00406       #endif
00407       } } 
00408       namespace ROOT {
00409          namespace Math {
00410 
00411       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00412       typedef ::ROOT::Math::GSLRngRanLuxS1 GSLRngRanLuxS1;
00413       #else
00414       class GSLRngRanLuxS1  :  public ::ROOT::Math::GSLRandomEngine {
00415          public:
00416          //friend XX;
00417       };
00418       #endif
00419       } } 
00420       namespace ROOT {
00421          namespace Math {
00422 
00423       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00424       typedef ::ROOT::Math::GSLRngRanLuxS2 GSLRngRanLuxS2;
00425       #else
00426       class GSLRngRanLuxS2  :  public ::ROOT::Math::GSLRandomEngine {
00427          public:
00428          //friend XX;
00429       };
00430       #endif
00431       } } 
00432       namespace ROOT {
00433          namespace Math {
00434 
00435       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00436       typedef ::ROOT::Math::GSLRngRanLuxD1 GSLRngRanLuxD1;
00437       #else
00438       class GSLRngRanLuxD1  :  public ::ROOT::Math::GSLRandomEngine {
00439          public:
00440          //friend XX;
00441       };
00442       #endif
00443       } } 
00444       namespace ROOT {
00445          namespace Math {
00446 
00447       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00448       typedef ::ROOT::Math::GSLRngRanLuxD2 GSLRngRanLuxD2;
00449       #else
00450       class GSLRngRanLuxD2  :  public ::ROOT::Math::GSLRandomEngine {
00451          public:
00452          //friend XX;
00453       };
00454       #endif
00455       } } 
00456       namespace ROOT {
00457          namespace Math {
00458 
00459       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00460       typedef ::ROOT::Math::GSLRngTaus GSLRngTaus;
00461       #else
00462       class GSLRngTaus  :  public ::ROOT::Math::GSLRandomEngine {
00463          public:
00464          //friend XX;
00465       };
00466       #endif
00467       } } 
00468       namespace ROOT {
00469          namespace Math {
00470 
00471       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00472       typedef ::ROOT::Math::GSLRngGFSR4 GSLRngGFSR4;
00473       #else
00474       class GSLRngGFSR4  :  public ::ROOT::Math::GSLRandomEngine {
00475          public:
00476          //friend XX;
00477       };
00478       #endif
00479       } } 
00480       namespace ROOT {
00481          namespace Math {
00482 
00483       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00484       typedef ::ROOT::Math::KelvinFunctions KelvinFunctions;
00485       #else
00486       class KelvinFunctions  {
00487          public:
00488          //friend XX;
00489          // To force the creation of a virtual table, throw just in case.
00490          virtual ~KelvinFunctions() throw() {};
00491       };
00492       #endif
00493       } } 
00494       namespace ROOT {
00495          namespace Math {
00496 
00497       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00498       typedef ::ROOT::Math::GSLMinimizer GSLMinimizer;
00499       #else
00500       class GSLMinimizer  :  public ::ROOT::Math::Minimizer {
00501          public:
00502          //friend XX;
00503          // To force the creation of a virtual table, throw just in case.
00504          virtual ~GSLMinimizer() throw() {};
00505          unsigned int fDim; //
00506          ::ROOT::Math::GSLMultiMinimizer* fGSLMultiMin; //
00507          :: ROOT::Math::IGradientFunctionMultiDim* fObjFunc; //
00508          double fMinVal; //
00509          double fLSTolerance; //Line Search Tolerance
00510          vector< double > fValues; //
00511          vector< double > fSteps; //
00512          vector< ::string > fNames; //
00513          vector< ::ROOT::Math::EMinimVariableType > fVarTypes; //vector specifyng the type of variables
00514          map< unsigned int, pair< double, double >  > fBounds; //map specifying the bound using as key the parameter index
00515       };
00516       #endif
00517       } } 
00518       namespace ROOT {
00519          namespace Math {
00520 
00521       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00522       typedef ::ROOT::Math::GSLSimAnFunc GSLSimAnFunc;
00523       #else
00524       class GSLSimAnFunc  {
00525          public:
00526          //friend XX;
00527          // To force the creation of a virtual table, throw just in case.
00528          virtual ~GSLSimAnFunc() throw() {};
00529          vector< double > fX; //
00530          vector< double > fScale; //
00531          :: ROOT::Math::IBaseFunctionMultiDim* fFunc; //
00532       };
00533       #endif
00534       } } 
00535       namespace ROOT {
00536          namespace Math {
00537 
00538       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00539       typedef ::ROOT::Math::GSLSimAnParams GSLSimAnParams;
00540       #else
00541       class GSLSimAnParams  {
00542          public:
00543          //friend XX;
00544          int n_tries; //number of points to try for each step
00545          int iters_fixed_T; //number of iterations at each temperature
00546          double step_size; //max step size used in random walk
00547          double k; //
00548          double t_initial; //
00549          double mu; //
00550          double t_min; //
00551       };
00552       #endif
00553       } } 
00554       namespace ROOT {
00555          namespace Math {
00556 
00557       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00558       typedef ::ROOT::Math::GSLSimAnnealing GSLSimAnnealing;
00559       #else
00560       class GSLSimAnnealing  {
00561          public:
00562          //friend XX;
00563          ::ROOT::Math::GSLSimAnParams fParams; //parameters for GSLSimAnnealig
00564       };
00565       #endif
00566       } } 
00567       namespace ROOT {
00568          namespace Math {
00569 
00570       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00571       typedef ::ROOT::Math::GSLSimAnMinimizer GSLSimAnMinimizer;
00572       #else
00573       class GSLSimAnMinimizer  :  public ::ROOT::Math::Minimizer {
00574          public:
00575          //friend XX;
00576          // To force the creation of a virtual table, throw just in case.
00577          virtual ~GSLSimAnMinimizer() throw() {};
00578          unsigned int fDim; //dimension of the function to be minimized 
00579          bool fOwnFunc; //flag to indicate if objective function is managed 
00580          ::ROOT::Math::GSLSimAnnealing fSolver; //
00581          :: ROOT::Math::IBaseFunctionMultiDim* fObjFunc; //
00582          double fMinVal; //minimum values 
00583          vector< double > fValues; //
00584          vector< double > fSteps; //
00585          vector< ::string > fNames; //
00586          vector< ::ROOT::Math::EMinimVariableType > fVarTypes; //vector specifyng the type of variables
00587          map< unsigned int, pair< double, double >  > fBounds; //map specifying the bound using as key the parameter index
00588       };
00589       #endif
00590       } } 
00591       namespace ROOT {
00592          namespace Math {
00593 
00594       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00595       typedef ::ROOT::Math::Vavilov Vavilov;
00596       #else
00597       class Vavilov  {
00598          public:
00599          //friend XX;
00600          // To force the creation of a virtual table, throw just in case.
00601          virtual ~Vavilov() throw() {};
00602       };
00603       #endif
00604       } } 
00605       namespace ROOT {
00606          namespace Math {
00607 
00608       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00609       typedef ::ROOT::Math::VavilovAccurate VavilovAccurate;
00610       #else
00611       class VavilovAccurate  :  public ::ROOT::Math::Vavilov {
00612          public:
00613          //friend XX;
00614          // To force the creation of a virtual table, throw just in case.
00615          virtual ~VavilovAccurate() throw() {};
00616          double fH[8]; //
00617          double fT0; //
00618          double fT1; //
00619          double fT; //
00620          double fOmega; //
00621          double fA_pdf[501]; //
00622          double fB_pdf[501]; //
00623          double fA_cdf[501]; //
00624          double fB_cdf[501]; //
00625          double fX0; //
00626          double fKappa; //
00627          double fBeta2; //
00628          double fEpsilonPM; //
00629          double fEpsilon; //
00630          bool fQuantileInit; //
00631          int fNQuant; //
00632          double fQuant[32]; //
00633          double fLambda[32]; //
00634       };
00635       #endif
00636       } } 
00637       namespace ROOT {
00638          namespace Math {
00639 
00640       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00641       typedef ::ROOT::Math::VavilovAccuratePdf VavilovAccuratePdf;
00642       #else
00643       class VavilovAccuratePdf  :  public ::ROOT::Math::IParametricFunctionOneDim {
00644          public:
00645          //friend XX;
00646          // To force the creation of a virtual table, throw just in case.
00647          virtual ~VavilovAccuratePdf() throw() {};
00648          double fP[5]; //
00649       };
00650       #endif
00651       } } 
00652       namespace ROOT {
00653          namespace Math {
00654 
00655       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00656       typedef ::ROOT::Math::VavilovAccurateCdf VavilovAccurateCdf;
00657       #else
00658       class VavilovAccurateCdf  :  public ::ROOT::Math::IParametricFunctionOneDim {
00659          public:
00660          //friend XX;
00661          // To force the creation of a virtual table, throw just in case.
00662          virtual ~VavilovAccurateCdf() throw() {};
00663          double fP[5]; //
00664       };
00665       #endif
00666       } } 
00667       namespace ROOT {
00668          namespace Math {
00669 
00670       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00671       typedef ::ROOT::Math::VavilovAccurateQuantile VavilovAccurateQuantile;
00672       #else
00673       class VavilovAccurateQuantile  :  public ::ROOT::Math::IParametricFunctionOneDim {
00674          public:
00675          //friend XX;
00676          // To force the creation of a virtual table, throw just in case.
00677          virtual ~VavilovAccurateQuantile() throw() {};
00678          double fP[5]; //
00679       };
00680       #endif
00681       } } 
00682       namespace ROOT {
00683          namespace Math {
00684 
00685       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00686       typedef ::ROOT::Math::VavilovFast VavilovFast;
00687       #else
00688       class VavilovFast  :  public ::ROOT::Math::Vavilov {
00689          public:
00690          //friend XX;
00691          // To force the creation of a virtual table, throw just in case.
00692          virtual ~VavilovFast() throw() {};
00693          double fKappa; //
00694          double fBeta2; //
00695          double fAC[14]; //
00696          double fHC[9]; //
00697          double fWCM[201]; //
00698          int fItype; //
00699          int fNpt; //
00700       };
00701       #endif
00702       } } 
00703       namespace ROOT {
00704          namespace Math {
00705 
00706       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00707       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngMT > RandomlEROOTcLcLMathcLcLGSLRngMTgR;
00708       #else
00709       class RandomlEROOTcLcLMathcLcLGSLRngMTgR  {
00710          public:
00711          //friend XX;
00712          ::ROOT::Math::GSLRngMT fEngine; //
00713       };
00714       #endif
00715       } } 
00716       namespace ROOT {
00717          namespace Math {
00718 
00719       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00720       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngTaus > RandomlEROOTcLcLMathcLcLGSLRngTausgR;
00721       #else
00722       class RandomlEROOTcLcLMathcLcLGSLRngTausgR  {
00723          public:
00724          //friend XX;
00725          ::ROOT::Math::GSLRngTaus fEngine; //
00726       };
00727       #endif
00728       } } 
00729       namespace ROOT {
00730          namespace Math {
00731 
00732       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00733       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngRanLux > RandomlEROOTcLcLMathcLcLGSLRngRanLuxgR;
00734       #else
00735       class RandomlEROOTcLcLMathcLcLGSLRngRanLuxgR  {
00736          public:
00737          //friend XX;
00738          ::ROOT::Math::GSLRngRanLux fEngine; //
00739       };
00740       #endif
00741       } } 
00742       namespace ROOT {
00743          namespace Math {
00744 
00745       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00746       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngRanLuxS1 > RandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR;
00747       #else
00748       class RandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR  {
00749          public:
00750          //friend XX;
00751          ::ROOT::Math::GSLRngRanLuxS1 fEngine; //
00752       };
00753       #endif
00754       } } 
00755       namespace ROOT {
00756          namespace Math {
00757 
00758       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00759       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngRanLuxS2 > RandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR;
00760       #else
00761       class RandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR  {
00762          public:
00763          //friend XX;
00764          ::ROOT::Math::GSLRngRanLuxS2 fEngine; //
00765       };
00766       #endif
00767       } } 
00768       namespace ROOT {
00769          namespace Math {
00770 
00771       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00772       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngRanLuxD1 > RandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR;
00773       #else
00774       class RandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR  {
00775          public:
00776          //friend XX;
00777          ::ROOT::Math::GSLRngRanLuxD1 fEngine; //
00778       };
00779       #endif
00780       } } 
00781       namespace ROOT {
00782          namespace Math {
00783 
00784       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00785       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngRanLuxD2 > RandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR;
00786       #else
00787       class RandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR  {
00788          public:
00789          //friend XX;
00790          ::ROOT::Math::GSLRngRanLuxD2 fEngine; //
00791       };
00792       #endif
00793       } } 
00794       namespace ROOT {
00795          namespace Math {
00796 
00797       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00798       typedef ::ROOT::Math::Random< ::ROOT::Math::GSLRngGFSR4 > RandomlEROOTcLcLMathcLcLGSLRngGFSR4gR;
00799       #else
00800       class RandomlEROOTcLcLMathcLcLGSLRngGFSR4gR  {
00801          public:
00802          //friend XX;
00803          ::ROOT::Math::GSLRngGFSR4 fEngine; //
00804       };
00805       #endif
00806       } } 
00807    } // of namespace Shadow
00808 } // of namespace ROOT
00809 // END OF SHADOWS
00810 
00811    namespace ROOT {
00812       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
00813       static void ROOT_Dictionary();
00814 
00815       // Function generating the singleton type initializer
00816       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
00817       {
00818          static ::ROOT::TGenericClassInfo 
00819             instance("ROOT", 0 /*version*/, "include/Math/VavilovFast.h", 42,
00820                      ::ROOT::DefineBehavior((void*)0,(void*)0),
00821                      &ROOT_Dictionary, 0);
00822          return &instance;
00823       }
00824       // Insure that the inline function is _not_ optimized away by the compiler
00825       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
00826       // Static variable to force the class initialization
00827       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
00828 
00829       // Dictionary for non-ClassDef classes
00830       static void ROOT_Dictionary() {
00831          GenerateInitInstance()->GetClass();
00832       }
00833 
00834    }
00835 
00836 namespace ROOT {
00837 namespace Math {
00838    namespace ROOT {
00839       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
00840       static void ROOTcLcLMath_Dictionary();
00841 
00842       // Function generating the singleton type initializer
00843       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
00844       {
00845          static ::ROOT::TGenericClassInfo 
00846             instance("ROOT::Math", 0 /*version*/, "include/Math/VavilovFast.h", 43,
00847                      ::ROOT::DefineBehavior((void*)0,(void*)0),
00848                      &ROOTcLcLMath_Dictionary, 0);
00849          return &instance;
00850       }
00851       // Insure that the inline function is _not_ optimized away by the compiler
00852       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
00853       // Static variable to force the class initialization
00854       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
00855 
00856       // Dictionary for non-ClassDef classes
00857       static void ROOTcLcLMath_Dictionary() {
00858          GenerateInitInstance()->GetClass();
00859       }
00860 
00861    }
00862 }
00863 }
00864 
00865 namespace ROOT {
00866 namespace MathMore {
00867    namespace ROOT {
00868       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
00869       static void ROOTcLcLMathMore_Dictionary();
00870 
00871       // Function generating the singleton type initializer
00872       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
00873       {
00874          static ::ROOT::TGenericClassInfo 
00875             instance("ROOT::MathMore", 0 /*version*/, "include/Math/QuantFuncMathMore.h", 148,
00876                      ::ROOT::DefineBehavior((void*)0,(void*)0),
00877                      &ROOTcLcLMathMore_Dictionary, 0);
00878          return &instance;
00879       }
00880       // Insure that the inline function is _not_ optimized away by the compiler
00881       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
00882       // Static variable to force the class initialization
00883       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
00884 
00885       // Dictionary for non-ClassDef classes
00886       static void ROOTcLcLMathMore_Dictionary() {
00887          GenerateInitInstance()->GetClass();
00888       }
00889 
00890    }
00891 }
00892 }
00893 
00894 namespace ROOT {
00895    void ROOTcLcLMathcLcLPolynomial_ShowMembers(void *obj, TMemberInspector &R__insp);
00896    static void ROOTcLcLMathcLcLPolynomial_Dictionary();
00897    static void *new_ROOTcLcLMathcLcLPolynomial(void *p = 0);
00898    static void *newArray_ROOTcLcLMathcLcLPolynomial(Long_t size, void *p);
00899    static void delete_ROOTcLcLMathcLcLPolynomial(void *p);
00900    static void deleteArray_ROOTcLcLMathcLcLPolynomial(void *p);
00901    static void destruct_ROOTcLcLMathcLcLPolynomial(void *p);
00902 
00903    // Function generating the singleton type initializer
00904    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Polynomial*)
00905    {
00906       // Make sure the shadow class has the right sizeof
00907       R__ASSERT(sizeof(::ROOT::Math::Polynomial) == sizeof(::ROOT::Shadow::ROOT::Math::Polynomial));
00908       ::ROOT::Math::Polynomial *ptr = 0;
00909       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Polynomial),0);
00910       static ::ROOT::TGenericClassInfo 
00911          instance("ROOT::Math::Polynomial", "include/Math/Polynomial.h", 65,
00912                   typeid(::ROOT::Math::Polynomial), DefineBehavior(ptr, ptr),
00913                   &ROOTcLcLMathcLcLPolynomial_ShowMembers, &ROOTcLcLMathcLcLPolynomial_Dictionary, isa_proxy, 4,
00914                   sizeof(::ROOT::Math::Polynomial) );
00915       instance.SetNew(&new_ROOTcLcLMathcLcLPolynomial);
00916       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLPolynomial);
00917       instance.SetDelete(&delete_ROOTcLcLMathcLcLPolynomial);
00918       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLPolynomial);
00919       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLPolynomial);
00920       return &instance;
00921    }
00922    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Polynomial*)
00923    {
00924       return GenerateInitInstanceLocal((::ROOT::Math::Polynomial*)0);
00925    }
00926    // Static variable to force the class initialization
00927    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Polynomial*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00928 
00929    // Dictionary for non-ClassDef classes
00930    static void ROOTcLcLMathcLcLPolynomial_Dictionary() {
00931       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Polynomial*)0x0)->GetClass();
00932    }
00933 
00934 } // end of namespace ROOT
00935 
00936 namespace ROOT {
00937    void ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00938    static void ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_Dictionary();
00939    static void delete_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void *p);
00940    static void deleteArray_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void *p);
00941    static void destruct_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void *p);
00942 
00943    // Function generating the singleton type initializer
00944    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)
00945    {
00946       // Make sure the shadow class has the right sizeof
00947       R__ASSERT(sizeof(::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>) == sizeof(::ROOT::Shadow::ROOT::Math::ParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR));
00948       ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> *ptr = 0;
00949       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>),0);
00950       static ::ROOT::TGenericClassInfo 
00951          instance("ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>", "include/Math/ParamFunction.h", 69,
00952                   typeid(::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>), DefineBehavior(ptr, ptr),
00953                   &ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_ShowMembers, &ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_Dictionary, isa_proxy, 4,
00954                   sizeof(::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>) );
00955       instance.SetDelete(&delete_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR);
00956       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR);
00957       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR);
00958       return &instance;
00959    }
00960    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)
00961    {
00962       return GenerateInitInstanceLocal((::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)0);
00963    }
00964    // Static variable to force the class initialization
00965    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00966 
00967    // Dictionary for non-ClassDef classes
00968    static void ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_Dictionary() {
00969       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)0x0)->GetClass();
00970    }
00971 
00972 } // end of namespace ROOT
00973 
00974 namespace ROOT {
00975    void ROOTcLcLMathcLcLDerivator_ShowMembers(void *obj, TMemberInspector &R__insp);
00976    static void ROOTcLcLMathcLcLDerivator_Dictionary();
00977    static void *new_ROOTcLcLMathcLcLDerivator(void *p = 0);
00978    static void *newArray_ROOTcLcLMathcLcLDerivator(Long_t size, void *p);
00979    static void delete_ROOTcLcLMathcLcLDerivator(void *p);
00980    static void deleteArray_ROOTcLcLMathcLcLDerivator(void *p);
00981    static void destruct_ROOTcLcLMathcLcLDerivator(void *p);
00982 
00983    // Function generating the singleton type initializer
00984    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Derivator*)
00985    {
00986       // Make sure the shadow class has the right sizeof
00987       R__ASSERT(sizeof(::ROOT::Math::Derivator) == sizeof(::ROOT::Shadow::ROOT::Math::Derivator));
00988       ::ROOT::Math::Derivator *ptr = 0;
00989       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Derivator),0);
00990       static ::ROOT::TGenericClassInfo 
00991          instance("ROOT::Math::Derivator", "include/Math/Derivator.h", 69,
00992                   typeid(::ROOT::Math::Derivator), DefineBehavior(ptr, ptr),
00993                   &ROOTcLcLMathcLcLDerivator_ShowMembers, &ROOTcLcLMathcLcLDerivator_Dictionary, isa_proxy, 4,
00994                   sizeof(::ROOT::Math::Derivator) );
00995       instance.SetNew(&new_ROOTcLcLMathcLcLDerivator);
00996       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLDerivator);
00997       instance.SetDelete(&delete_ROOTcLcLMathcLcLDerivator);
00998       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLDerivator);
00999       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLDerivator);
01000       return &instance;
01001    }
01002    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Derivator*)
01003    {
01004       return GenerateInitInstanceLocal((::ROOT::Math::Derivator*)0);
01005    }
01006    // Static variable to force the class initialization
01007    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Derivator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01008 
01009    // Dictionary for non-ClassDef classes
01010    static void ROOTcLcLMathcLcLDerivator_Dictionary() {
01011       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Derivator*)0x0)->GetClass();
01012    }
01013 
01014 } // end of namespace ROOT
01015 
01016 namespace ROOT {
01017    void ROOTcLcLMathcLcLInterpolator_ShowMembers(void *obj, TMemberInspector &R__insp);
01018    static void ROOTcLcLMathcLcLInterpolator_Dictionary();
01019    static void *new_ROOTcLcLMathcLcLInterpolator(void *p = 0);
01020    static void *newArray_ROOTcLcLMathcLcLInterpolator(Long_t size, void *p);
01021    static void delete_ROOTcLcLMathcLcLInterpolator(void *p);
01022    static void deleteArray_ROOTcLcLMathcLcLInterpolator(void *p);
01023    static void destruct_ROOTcLcLMathcLcLInterpolator(void *p);
01024 
01025    // Function generating the singleton type initializer
01026    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Interpolator*)
01027    {
01028       // Make sure the shadow class has the right sizeof
01029       R__ASSERT(sizeof(::ROOT::Math::Interpolator) == sizeof(::ROOT::Shadow::ROOT::Math::Interpolator));
01030       ::ROOT::Math::Interpolator *ptr = 0;
01031       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Interpolator),0);
01032       static ::ROOT::TGenericClassInfo 
01033          instance("ROOT::Math::Interpolator", "include/Math/Interpolator.h", 63,
01034                   typeid(::ROOT::Math::Interpolator), DefineBehavior(ptr, ptr),
01035                   &ROOTcLcLMathcLcLInterpolator_ShowMembers, &ROOTcLcLMathcLcLInterpolator_Dictionary, isa_proxy, 4,
01036                   sizeof(::ROOT::Math::Interpolator) );
01037       instance.SetNew(&new_ROOTcLcLMathcLcLInterpolator);
01038       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLInterpolator);
01039       instance.SetDelete(&delete_ROOTcLcLMathcLcLInterpolator);
01040       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLInterpolator);
01041       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLInterpolator);
01042       return &instance;
01043    }
01044    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Interpolator*)
01045    {
01046       return GenerateInitInstanceLocal((::ROOT::Math::Interpolator*)0);
01047    }
01048    // Static variable to force the class initialization
01049    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Interpolator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01050 
01051    // Dictionary for non-ClassDef classes
01052    static void ROOTcLcLMathcLcLInterpolator_Dictionary() {
01053       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Interpolator*)0x0)->GetClass();
01054    }
01055 
01056 } // end of namespace ROOT
01057 
01058 namespace ROOT {
01059    void ROOTcLcLMathcLcLGSLRootFinder_ShowMembers(void *obj, TMemberInspector &R__insp);
01060    static void ROOTcLcLMathcLcLGSLRootFinder_Dictionary();
01061    static void *new_ROOTcLcLMathcLcLGSLRootFinder(void *p = 0);
01062    static void *newArray_ROOTcLcLMathcLcLGSLRootFinder(Long_t size, void *p);
01063    static void delete_ROOTcLcLMathcLcLGSLRootFinder(void *p);
01064    static void deleteArray_ROOTcLcLMathcLcLGSLRootFinder(void *p);
01065    static void destruct_ROOTcLcLMathcLcLGSLRootFinder(void *p);
01066 
01067    // Function generating the singleton type initializer
01068    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRootFinder*)
01069    {
01070       // Make sure the shadow class has the right sizeof
01071       R__ASSERT(sizeof(::ROOT::Math::GSLRootFinder) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRootFinder));
01072       ::ROOT::Math::GSLRootFinder *ptr = 0;
01073       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRootFinder),0);
01074       static ::ROOT::TGenericClassInfo 
01075          instance("ROOT::Math::GSLRootFinder", "include/Math/GSLRootFinder.h", 79,
01076                   typeid(::ROOT::Math::GSLRootFinder), DefineBehavior(ptr, ptr),
01077                   &ROOTcLcLMathcLcLGSLRootFinder_ShowMembers, &ROOTcLcLMathcLcLGSLRootFinder_Dictionary, isa_proxy, 4,
01078                   sizeof(::ROOT::Math::GSLRootFinder) );
01079       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRootFinder);
01080       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRootFinder);
01081       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRootFinder);
01082       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRootFinder);
01083       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRootFinder);
01084       return &instance;
01085    }
01086    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRootFinder*)
01087    {
01088       return GenerateInitInstanceLocal((::ROOT::Math::GSLRootFinder*)0);
01089    }
01090    // Static variable to force the class initialization
01091    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRootFinder*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01092 
01093    // Dictionary for non-ClassDef classes
01094    static void ROOTcLcLMathcLcLGSLRootFinder_Dictionary() {
01095       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRootFinder*)0x0)->GetClass();
01096    }
01097 
01098 } // end of namespace ROOT
01099 
01100 namespace ROOT {
01101    void ROOTcLcLMathcLcLGSLRootFinderDeriv_ShowMembers(void *obj, TMemberInspector &R__insp);
01102    static void ROOTcLcLMathcLcLGSLRootFinderDeriv_Dictionary();
01103    static void *new_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p = 0);
01104    static void *newArray_ROOTcLcLMathcLcLGSLRootFinderDeriv(Long_t size, void *p);
01105    static void delete_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p);
01106    static void deleteArray_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p);
01107    static void destruct_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p);
01108 
01109    // Function generating the singleton type initializer
01110    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRootFinderDeriv*)
01111    {
01112       // Make sure the shadow class has the right sizeof
01113       R__ASSERT(sizeof(::ROOT::Math::GSLRootFinderDeriv) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRootFinderDeriv));
01114       ::ROOT::Math::GSLRootFinderDeriv *ptr = 0;
01115       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRootFinderDeriv),0);
01116       static ::ROOT::TGenericClassInfo 
01117          instance("ROOT::Math::GSLRootFinderDeriv", "include/Math/GSLRootFinderDeriv.h", 82,
01118                   typeid(::ROOT::Math::GSLRootFinderDeriv), DefineBehavior(ptr, ptr),
01119                   &ROOTcLcLMathcLcLGSLRootFinderDeriv_ShowMembers, &ROOTcLcLMathcLcLGSLRootFinderDeriv_Dictionary, isa_proxy, 4,
01120                   sizeof(::ROOT::Math::GSLRootFinderDeriv) );
01121       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRootFinderDeriv);
01122       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRootFinderDeriv);
01123       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRootFinderDeriv);
01124       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRootFinderDeriv);
01125       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRootFinderDeriv);
01126       return &instance;
01127    }
01128    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRootFinderDeriv*)
01129    {
01130       return GenerateInitInstanceLocal((::ROOT::Math::GSLRootFinderDeriv*)0);
01131    }
01132    // Static variable to force the class initialization
01133    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRootFinderDeriv*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01134 
01135    // Dictionary for non-ClassDef classes
01136    static void ROOTcLcLMathcLcLGSLRootFinderDeriv_Dictionary() {
01137       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRootFinderDeriv*)0x0)->GetClass();
01138    }
01139 
01140 } // end of namespace ROOT
01141 
01142 namespace ROOT {
01143 namespace Math {
01144 namespace Roots {
01145    namespace ROOT {
01146       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
01147       static void ROOTcLcLMathcLcLRoots_Dictionary();
01148 
01149       // Function generating the singleton type initializer
01150       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
01151       {
01152          static ::ROOT::TGenericClassInfo 
01153             instance("ROOT::Math::Roots", 0 /*version*/, "include/Math/RootFinderAlgorithms.h", 51,
01154                      ::ROOT::DefineBehavior((void*)0,(void*)0),
01155                      &ROOTcLcLMathcLcLRoots_Dictionary, 0);
01156          return &instance;
01157       }
01158       // Insure that the inline function is _not_ optimized away by the compiler
01159       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
01160       // Static variable to force the class initialization
01161       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
01162 
01163       // Dictionary for non-ClassDef classes
01164       static void ROOTcLcLMathcLcLRoots_Dictionary() {
01165          GenerateInitInstance()->GetClass();
01166       }
01167 
01168    }
01169 }
01170 }
01171 }
01172 
01173 namespace ROOT {
01174    void ROOTcLcLMathcLcLRootscLcLBisection_ShowMembers(void *obj, TMemberInspector &R__insp);
01175    static void ROOTcLcLMathcLcLRootscLcLBisection_Dictionary();
01176    static void *new_ROOTcLcLMathcLcLRootscLcLBisection(void *p = 0);
01177    static void *newArray_ROOTcLcLMathcLcLRootscLcLBisection(Long_t size, void *p);
01178    static void delete_ROOTcLcLMathcLcLRootscLcLBisection(void *p);
01179    static void deleteArray_ROOTcLcLMathcLcLRootscLcLBisection(void *p);
01180    static void destruct_ROOTcLcLMathcLcLRootscLcLBisection(void *p);
01181 
01182    // Function generating the singleton type initializer
01183    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Roots::Bisection*)
01184    {
01185       // Make sure the shadow class has the right sizeof
01186       R__ASSERT(sizeof(::ROOT::Math::Roots::Bisection) == sizeof(::ROOT::Shadow::ROOT::Math::Roots::Bisection));
01187       ::ROOT::Math::Roots::Bisection *ptr = 0;
01188       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Roots::Bisection),0);
01189       static ::ROOT::TGenericClassInfo 
01190          instance("ROOT::Math::Roots::Bisection", "include/Math/RootFinderAlgorithms.h", 61,
01191                   typeid(::ROOT::Math::Roots::Bisection), DefineBehavior(ptr, ptr),
01192                   &ROOTcLcLMathcLcLRootscLcLBisection_ShowMembers, &ROOTcLcLMathcLcLRootscLcLBisection_Dictionary, isa_proxy, 4,
01193                   sizeof(::ROOT::Math::Roots::Bisection) );
01194       instance.SetNew(&new_ROOTcLcLMathcLcLRootscLcLBisection);
01195       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRootscLcLBisection);
01196       instance.SetDelete(&delete_ROOTcLcLMathcLcLRootscLcLBisection);
01197       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRootscLcLBisection);
01198       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRootscLcLBisection);
01199       return &instance;
01200    }
01201    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Roots::Bisection*)
01202    {
01203       return GenerateInitInstanceLocal((::ROOT::Math::Roots::Bisection*)0);
01204    }
01205    // Static variable to force the class initialization
01206    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Bisection*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01207 
01208    // Dictionary for non-ClassDef classes
01209    static void ROOTcLcLMathcLcLRootscLcLBisection_Dictionary() {
01210       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Bisection*)0x0)->GetClass();
01211    }
01212 
01213 } // end of namespace ROOT
01214 
01215 namespace ROOT {
01216    void ROOTcLcLMathcLcLRootscLcLFalsePos_ShowMembers(void *obj, TMemberInspector &R__insp);
01217    static void ROOTcLcLMathcLcLRootscLcLFalsePos_Dictionary();
01218    static void *new_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p = 0);
01219    static void *newArray_ROOTcLcLMathcLcLRootscLcLFalsePos(Long_t size, void *p);
01220    static void delete_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p);
01221    static void deleteArray_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p);
01222    static void destruct_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p);
01223 
01224    // Function generating the singleton type initializer
01225    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Roots::FalsePos*)
01226    {
01227       // Make sure the shadow class has the right sizeof
01228       R__ASSERT(sizeof(::ROOT::Math::Roots::FalsePos) == sizeof(::ROOT::Shadow::ROOT::Math::Roots::FalsePos));
01229       ::ROOT::Math::Roots::FalsePos *ptr = 0;
01230       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Roots::FalsePos),0);
01231       static ::ROOT::TGenericClassInfo 
01232          instance("ROOT::Math::Roots::FalsePos", "include/Math/RootFinderAlgorithms.h", 83,
01233                   typeid(::ROOT::Math::Roots::FalsePos), DefineBehavior(ptr, ptr),
01234                   &ROOTcLcLMathcLcLRootscLcLFalsePos_ShowMembers, &ROOTcLcLMathcLcLRootscLcLFalsePos_Dictionary, isa_proxy, 4,
01235                   sizeof(::ROOT::Math::Roots::FalsePos) );
01236       instance.SetNew(&new_ROOTcLcLMathcLcLRootscLcLFalsePos);
01237       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRootscLcLFalsePos);
01238       instance.SetDelete(&delete_ROOTcLcLMathcLcLRootscLcLFalsePos);
01239       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRootscLcLFalsePos);
01240       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRootscLcLFalsePos);
01241       return &instance;
01242    }
01243    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Roots::FalsePos*)
01244    {
01245       return GenerateInitInstanceLocal((::ROOT::Math::Roots::FalsePos*)0);
01246    }
01247    // Static variable to force the class initialization
01248    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Roots::FalsePos*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01249 
01250    // Dictionary for non-ClassDef classes
01251    static void ROOTcLcLMathcLcLRootscLcLFalsePos_Dictionary() {
01252       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::FalsePos*)0x0)->GetClass();
01253    }
01254 
01255 } // end of namespace ROOT
01256 
01257 namespace ROOT {
01258    void ROOTcLcLMathcLcLRootscLcLBrent_ShowMembers(void *obj, TMemberInspector &R__insp);
01259    static void ROOTcLcLMathcLcLRootscLcLBrent_Dictionary();
01260    static void *new_ROOTcLcLMathcLcLRootscLcLBrent(void *p = 0);
01261    static void *newArray_ROOTcLcLMathcLcLRootscLcLBrent(Long_t size, void *p);
01262    static void delete_ROOTcLcLMathcLcLRootscLcLBrent(void *p);
01263    static void deleteArray_ROOTcLcLMathcLcLRootscLcLBrent(void *p);
01264    static void destruct_ROOTcLcLMathcLcLRootscLcLBrent(void *p);
01265 
01266    // Function generating the singleton type initializer
01267    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Roots::Brent*)
01268    {
01269       // Make sure the shadow class has the right sizeof
01270       R__ASSERT(sizeof(::ROOT::Math::Roots::Brent) == sizeof(::ROOT::Shadow::ROOT::Math::Roots::Brent));
01271       ::ROOT::Math::Roots::Brent *ptr = 0;
01272       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Roots::Brent),0);
01273       static ::ROOT::TGenericClassInfo 
01274          instance("ROOT::Math::Roots::Brent", "include/Math/RootFinderAlgorithms.h", 108,
01275                   typeid(::ROOT::Math::Roots::Brent), DefineBehavior(ptr, ptr),
01276                   &ROOTcLcLMathcLcLRootscLcLBrent_ShowMembers, &ROOTcLcLMathcLcLRootscLcLBrent_Dictionary, isa_proxy, 4,
01277                   sizeof(::ROOT::Math::Roots::Brent) );
01278       instance.SetNew(&new_ROOTcLcLMathcLcLRootscLcLBrent);
01279       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRootscLcLBrent);
01280       instance.SetDelete(&delete_ROOTcLcLMathcLcLRootscLcLBrent);
01281       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRootscLcLBrent);
01282       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRootscLcLBrent);
01283       return &instance;
01284    }
01285    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Roots::Brent*)
01286    {
01287       return GenerateInitInstanceLocal((::ROOT::Math::Roots::Brent*)0);
01288    }
01289    // Static variable to force the class initialization
01290    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Brent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01291 
01292    // Dictionary for non-ClassDef classes
01293    static void ROOTcLcLMathcLcLRootscLcLBrent_Dictionary() {
01294       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Brent*)0x0)->GetClass();
01295    }
01296 
01297 } // end of namespace ROOT
01298 
01299 namespace ROOT {
01300    void ROOTcLcLMathcLcLRootscLcLNewton_ShowMembers(void *obj, TMemberInspector &R__insp);
01301    static void ROOTcLcLMathcLcLRootscLcLNewton_Dictionary();
01302    static void *new_ROOTcLcLMathcLcLRootscLcLNewton(void *p = 0);
01303    static void *newArray_ROOTcLcLMathcLcLRootscLcLNewton(Long_t size, void *p);
01304    static void delete_ROOTcLcLMathcLcLRootscLcLNewton(void *p);
01305    static void deleteArray_ROOTcLcLMathcLcLRootscLcLNewton(void *p);
01306    static void destruct_ROOTcLcLMathcLcLRootscLcLNewton(void *p);
01307 
01308    // Function generating the singleton type initializer
01309    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Roots::Newton*)
01310    {
01311       // Make sure the shadow class has the right sizeof
01312       R__ASSERT(sizeof(::ROOT::Math::Roots::Newton) == sizeof(::ROOT::Shadow::ROOT::Math::Roots::Newton));
01313       ::ROOT::Math::Roots::Newton *ptr = 0;
01314       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Roots::Newton),0);
01315       static ::ROOT::TGenericClassInfo 
01316          instance("ROOT::Math::Roots::Newton", "include/Math/RootFinderAlgorithms.h", 136,
01317                   typeid(::ROOT::Math::Roots::Newton), DefineBehavior(ptr, ptr),
01318                   &ROOTcLcLMathcLcLRootscLcLNewton_ShowMembers, &ROOTcLcLMathcLcLRootscLcLNewton_Dictionary, isa_proxy, 4,
01319                   sizeof(::ROOT::Math::Roots::Newton) );
01320       instance.SetNew(&new_ROOTcLcLMathcLcLRootscLcLNewton);
01321       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRootscLcLNewton);
01322       instance.SetDelete(&delete_ROOTcLcLMathcLcLRootscLcLNewton);
01323       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRootscLcLNewton);
01324       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRootscLcLNewton);
01325       return &instance;
01326    }
01327    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Roots::Newton*)
01328    {
01329       return GenerateInitInstanceLocal((::ROOT::Math::Roots::Newton*)0);
01330    }
01331    // Static variable to force the class initialization
01332    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Newton*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01333 
01334    // Dictionary for non-ClassDef classes
01335    static void ROOTcLcLMathcLcLRootscLcLNewton_Dictionary() {
01336       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Newton*)0x0)->GetClass();
01337    }
01338 
01339 } // end of namespace ROOT
01340 
01341 namespace ROOT {
01342    void ROOTcLcLMathcLcLRootscLcLSecant_ShowMembers(void *obj, TMemberInspector &R__insp);
01343    static void ROOTcLcLMathcLcLRootscLcLSecant_Dictionary();
01344    static void *new_ROOTcLcLMathcLcLRootscLcLSecant(void *p = 0);
01345    static void *newArray_ROOTcLcLMathcLcLRootscLcLSecant(Long_t size, void *p);
01346    static void delete_ROOTcLcLMathcLcLRootscLcLSecant(void *p);
01347    static void deleteArray_ROOTcLcLMathcLcLRootscLcLSecant(void *p);
01348    static void destruct_ROOTcLcLMathcLcLRootscLcLSecant(void *p);
01349 
01350    // Function generating the singleton type initializer
01351    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Roots::Secant*)
01352    {
01353       // Make sure the shadow class has the right sizeof
01354       R__ASSERT(sizeof(::ROOT::Math::Roots::Secant) == sizeof(::ROOT::Shadow::ROOT::Math::Roots::Secant));
01355       ::ROOT::Math::Roots::Secant *ptr = 0;
01356       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Roots::Secant),0);
01357       static ::ROOT::TGenericClassInfo 
01358          instance("ROOT::Math::Roots::Secant", "include/Math/RootFinderAlgorithms.h", 159,
01359                   typeid(::ROOT::Math::Roots::Secant), DefineBehavior(ptr, ptr),
01360                   &ROOTcLcLMathcLcLRootscLcLSecant_ShowMembers, &ROOTcLcLMathcLcLRootscLcLSecant_Dictionary, isa_proxy, 4,
01361                   sizeof(::ROOT::Math::Roots::Secant) );
01362       instance.SetNew(&new_ROOTcLcLMathcLcLRootscLcLSecant);
01363       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRootscLcLSecant);
01364       instance.SetDelete(&delete_ROOTcLcLMathcLcLRootscLcLSecant);
01365       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRootscLcLSecant);
01366       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRootscLcLSecant);
01367       return &instance;
01368    }
01369    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Roots::Secant*)
01370    {
01371       return GenerateInitInstanceLocal((::ROOT::Math::Roots::Secant*)0);
01372    }
01373    // Static variable to force the class initialization
01374    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Secant*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01375 
01376    // Dictionary for non-ClassDef classes
01377    static void ROOTcLcLMathcLcLRootscLcLSecant_Dictionary() {
01378       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Secant*)0x0)->GetClass();
01379    }
01380 
01381 } // end of namespace ROOT
01382 
01383 namespace ROOT {
01384    void ROOTcLcLMathcLcLRootscLcLSteffenson_ShowMembers(void *obj, TMemberInspector &R__insp);
01385    static void ROOTcLcLMathcLcLRootscLcLSteffenson_Dictionary();
01386    static void *new_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p = 0);
01387    static void *newArray_ROOTcLcLMathcLcLRootscLcLSteffenson(Long_t size, void *p);
01388    static void delete_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p);
01389    static void deleteArray_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p);
01390    static void destruct_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p);
01391 
01392    // Function generating the singleton type initializer
01393    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Roots::Steffenson*)
01394    {
01395       // Make sure the shadow class has the right sizeof
01396       R__ASSERT(sizeof(::ROOT::Math::Roots::Steffenson) == sizeof(::ROOT::Shadow::ROOT::Math::Roots::Steffenson));
01397       ::ROOT::Math::Roots::Steffenson *ptr = 0;
01398       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Roots::Steffenson),0);
01399       static ::ROOT::TGenericClassInfo 
01400          instance("ROOT::Math::Roots::Steffenson", "include/Math/RootFinderAlgorithms.h", 182,
01401                   typeid(::ROOT::Math::Roots::Steffenson), DefineBehavior(ptr, ptr),
01402                   &ROOTcLcLMathcLcLRootscLcLSteffenson_ShowMembers, &ROOTcLcLMathcLcLRootscLcLSteffenson_Dictionary, isa_proxy, 4,
01403                   sizeof(::ROOT::Math::Roots::Steffenson) );
01404       instance.SetNew(&new_ROOTcLcLMathcLcLRootscLcLSteffenson);
01405       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRootscLcLSteffenson);
01406       instance.SetDelete(&delete_ROOTcLcLMathcLcLRootscLcLSteffenson);
01407       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRootscLcLSteffenson);
01408       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRootscLcLSteffenson);
01409       return &instance;
01410    }
01411    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Roots::Steffenson*)
01412    {
01413       return GenerateInitInstanceLocal((::ROOT::Math::Roots::Steffenson*)0);
01414    }
01415    // Static variable to force the class initialization
01416    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Steffenson*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01417 
01418    // Dictionary for non-ClassDef classes
01419    static void ROOTcLcLMathcLcLRootscLcLSteffenson_Dictionary() {
01420       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Steffenson*)0x0)->GetClass();
01421    }
01422 
01423 } // end of namespace ROOT
01424 
01425 namespace ROOT {
01426 namespace Math {
01427 namespace Integration {
01428    namespace ROOT {
01429       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
01430       static void ROOTcLcLMathcLcLIntegration_Dictionary();
01431 
01432       // Function generating the singleton type initializer
01433       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
01434       {
01435          static ::ROOT::TGenericClassInfo 
01436             instance("ROOT::Math::Integration", 0 /*version*/, "include/Math/IntegrationTypes.h", 44,
01437                      ::ROOT::DefineBehavior((void*)0,(void*)0),
01438                      &ROOTcLcLMathcLcLIntegration_Dictionary, 0);
01439          return &instance;
01440       }
01441       // Insure that the inline function is _not_ optimized away by the compiler
01442       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
01443       // Static variable to force the class initialization
01444       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
01445 
01446       // Dictionary for non-ClassDef classes
01447       static void ROOTcLcLMathcLcLIntegration_Dictionary() {
01448          GenerateInitInstance()->GetClass();
01449       }
01450 
01451    }
01452 }
01453 }
01454 }
01455 
01456 namespace ROOT {
01457    void ROOTcLcLMathcLcLGSLIntegrator_ShowMembers(void *obj, TMemberInspector &R__insp);
01458    static void ROOTcLcLMathcLcLGSLIntegrator_Dictionary();
01459    static void *new_ROOTcLcLMathcLcLGSLIntegrator(void *p = 0);
01460    static void *newArray_ROOTcLcLMathcLcLGSLIntegrator(Long_t size, void *p);
01461    static void delete_ROOTcLcLMathcLcLGSLIntegrator(void *p);
01462    static void deleteArray_ROOTcLcLMathcLcLGSLIntegrator(void *p);
01463    static void destruct_ROOTcLcLMathcLcLGSLIntegrator(void *p);
01464 
01465    // Function generating the singleton type initializer
01466    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLIntegrator*)
01467    {
01468       // Make sure the shadow class has the right sizeof
01469       R__ASSERT(sizeof(::ROOT::Math::GSLIntegrator) == sizeof(::ROOT::Shadow::ROOT::Math::GSLIntegrator));
01470       ::ROOT::Math::GSLIntegrator *ptr = 0;
01471       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLIntegrator),0);
01472       static ::ROOT::TGenericClassInfo 
01473          instance("ROOT::Math::GSLIntegrator", "include/Math/GSLIntegrator.h", 104,
01474                   typeid(::ROOT::Math::GSLIntegrator), DefineBehavior(ptr, ptr),
01475                   &ROOTcLcLMathcLcLGSLIntegrator_ShowMembers, &ROOTcLcLMathcLcLGSLIntegrator_Dictionary, isa_proxy, 4,
01476                   sizeof(::ROOT::Math::GSLIntegrator) );
01477       instance.SetNew(&new_ROOTcLcLMathcLcLGSLIntegrator);
01478       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLIntegrator);
01479       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLIntegrator);
01480       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLIntegrator);
01481       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLIntegrator);
01482       return &instance;
01483    }
01484    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLIntegrator*)
01485    {
01486       return GenerateInitInstanceLocal((::ROOT::Math::GSLIntegrator*)0);
01487    }
01488    // Static variable to force the class initialization
01489    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLIntegrator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01490 
01491    // Dictionary for non-ClassDef classes
01492    static void ROOTcLcLMathcLcLGSLIntegrator_Dictionary() {
01493       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLIntegrator*)0x0)->GetClass();
01494    }
01495 
01496 } // end of namespace ROOT
01497 
01498 namespace ROOT {
01499    void ROOTcLcLMathcLcLVegasParameters_ShowMembers(void *obj, TMemberInspector &R__insp);
01500    static void ROOTcLcLMathcLcLVegasParameters_Dictionary();
01501    static void *new_ROOTcLcLMathcLcLVegasParameters(void *p = 0);
01502    static void *newArray_ROOTcLcLMathcLcLVegasParameters(Long_t size, void *p);
01503    static void delete_ROOTcLcLMathcLcLVegasParameters(void *p);
01504    static void deleteArray_ROOTcLcLMathcLcLVegasParameters(void *p);
01505    static void destruct_ROOTcLcLMathcLcLVegasParameters(void *p);
01506 
01507    // Function generating the singleton type initializer
01508    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::VegasParameters*)
01509    {
01510       // Make sure the shadow class has the right sizeof
01511       R__ASSERT(sizeof(::ROOT::Math::VegasParameters) == sizeof(::ROOT::Shadow::ROOT::Math::VegasParameters));
01512       ::ROOT::Math::VegasParameters *ptr = 0;
01513       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::VegasParameters),0);
01514       static ::ROOT::TGenericClassInfo 
01515          instance("ROOT::Math::VegasParameters", "include/Math/MCParameters.h", 45,
01516                   typeid(::ROOT::Math::VegasParameters), DefineBehavior(ptr, ptr),
01517                   &ROOTcLcLMathcLcLVegasParameters_ShowMembers, &ROOTcLcLMathcLcLVegasParameters_Dictionary, isa_proxy, 4,
01518                   sizeof(::ROOT::Math::VegasParameters) );
01519       instance.SetNew(&new_ROOTcLcLMathcLcLVegasParameters);
01520       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLVegasParameters);
01521       instance.SetDelete(&delete_ROOTcLcLMathcLcLVegasParameters);
01522       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLVegasParameters);
01523       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLVegasParameters);
01524       return &instance;
01525    }
01526    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::VegasParameters*)
01527    {
01528       return GenerateInitInstanceLocal((::ROOT::Math::VegasParameters*)0);
01529    }
01530    // Static variable to force the class initialization
01531    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::VegasParameters*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01532 
01533    // Dictionary for non-ClassDef classes
01534    static void ROOTcLcLMathcLcLVegasParameters_Dictionary() {
01535       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VegasParameters*)0x0)->GetClass();
01536    }
01537 
01538 } // end of namespace ROOT
01539 
01540 namespace ROOT {
01541    void ROOTcLcLMathcLcLMiserParameters_ShowMembers(void *obj, TMemberInspector &R__insp);
01542    static void ROOTcLcLMathcLcLMiserParameters_Dictionary();
01543    static void *new_ROOTcLcLMathcLcLMiserParameters(void *p = 0);
01544    static void *newArray_ROOTcLcLMathcLcLMiserParameters(Long_t size, void *p);
01545    static void delete_ROOTcLcLMathcLcLMiserParameters(void *p);
01546    static void deleteArray_ROOTcLcLMathcLcLMiserParameters(void *p);
01547    static void destruct_ROOTcLcLMathcLcLMiserParameters(void *p);
01548 
01549    // Function generating the singleton type initializer
01550    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::MiserParameters*)
01551    {
01552       // Make sure the shadow class has the right sizeof
01553       R__ASSERT(sizeof(::ROOT::Math::MiserParameters) == sizeof(::ROOT::Shadow::ROOT::Math::MiserParameters));
01554       ::ROOT::Math::MiserParameters *ptr = 0;
01555       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::MiserParameters),0);
01556       static ::ROOT::TGenericClassInfo 
01557          instance("ROOT::Math::MiserParameters", "include/Math/MCParameters.h", 76,
01558                   typeid(::ROOT::Math::MiserParameters), DefineBehavior(ptr, ptr),
01559                   &ROOTcLcLMathcLcLMiserParameters_ShowMembers, &ROOTcLcLMathcLcLMiserParameters_Dictionary, isa_proxy, 4,
01560                   sizeof(::ROOT::Math::MiserParameters) );
01561       instance.SetNew(&new_ROOTcLcLMathcLcLMiserParameters);
01562       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLMiserParameters);
01563       instance.SetDelete(&delete_ROOTcLcLMathcLcLMiserParameters);
01564       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLMiserParameters);
01565       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLMiserParameters);
01566       return &instance;
01567    }
01568    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::MiserParameters*)
01569    {
01570       return GenerateInitInstanceLocal((::ROOT::Math::MiserParameters*)0);
01571    }
01572    // Static variable to force the class initialization
01573    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::MiserParameters*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01574 
01575    // Dictionary for non-ClassDef classes
01576    static void ROOTcLcLMathcLcLMiserParameters_Dictionary() {
01577       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::MiserParameters*)0x0)->GetClass();
01578    }
01579 
01580 } // end of namespace ROOT
01581 
01582 namespace ROOT {
01583    void ROOTcLcLMathcLcLGSLMCIntegrator_ShowMembers(void *obj, TMemberInspector &R__insp);
01584    static void ROOTcLcLMathcLcLGSLMCIntegrator_Dictionary();
01585    static void *new_ROOTcLcLMathcLcLGSLMCIntegrator(void *p = 0);
01586    static void *newArray_ROOTcLcLMathcLcLGSLMCIntegrator(Long_t size, void *p);
01587    static void delete_ROOTcLcLMathcLcLGSLMCIntegrator(void *p);
01588    static void deleteArray_ROOTcLcLMathcLcLGSLMCIntegrator(void *p);
01589    static void destruct_ROOTcLcLMathcLcLGSLMCIntegrator(void *p);
01590 
01591    // Function generating the singleton type initializer
01592    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLMCIntegrator*)
01593    {
01594       // Make sure the shadow class has the right sizeof
01595       R__ASSERT(sizeof(::ROOT::Math::GSLMCIntegrator) == sizeof(::ROOT::Shadow::ROOT::Math::GSLMCIntegrator));
01596       ::ROOT::Math::GSLMCIntegrator *ptr = 0;
01597       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLMCIntegrator),0);
01598       static ::ROOT::TGenericClassInfo 
01599          instance("ROOT::Math::GSLMCIntegrator", "include/Math/GSLMCIntegrator.h", 95,
01600                   typeid(::ROOT::Math::GSLMCIntegrator), DefineBehavior(ptr, ptr),
01601                   &ROOTcLcLMathcLcLGSLMCIntegrator_ShowMembers, &ROOTcLcLMathcLcLGSLMCIntegrator_Dictionary, isa_proxy, 4,
01602                   sizeof(::ROOT::Math::GSLMCIntegrator) );
01603       instance.SetNew(&new_ROOTcLcLMathcLcLGSLMCIntegrator);
01604       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLMCIntegrator);
01605       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLMCIntegrator);
01606       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLMCIntegrator);
01607       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLMCIntegrator);
01608       return &instance;
01609    }
01610    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLMCIntegrator*)
01611    {
01612       return GenerateInitInstanceLocal((::ROOT::Math::GSLMCIntegrator*)0);
01613    }
01614    // Static variable to force the class initialization
01615    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLMCIntegrator*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01616 
01617    // Dictionary for non-ClassDef classes
01618    static void ROOTcLcLMathcLcLGSLMCIntegrator_Dictionary() {
01619       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLMCIntegrator*)0x0)->GetClass();
01620    }
01621 
01622 } // end of namespace ROOT
01623 
01624 namespace ROOT {
01625 namespace Math {
01626 namespace Minim1D {
01627    namespace ROOT {
01628       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
01629       static void ROOTcLcLMathcLcLMinim1D_Dictionary();
01630 
01631       // Function generating the singleton type initializer
01632       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
01633       {
01634          static ::ROOT::TGenericClassInfo 
01635             instance("ROOT::Math::Minim1D", 0 /*version*/, "include/Math/GSLMinimizer1D.h", 41,
01636                      ::ROOT::DefineBehavior((void*)0,(void*)0),
01637                      &ROOTcLcLMathcLcLMinim1D_Dictionary, 0);
01638          return &instance;
01639       }
01640       // Insure that the inline function is _not_ optimized away by the compiler
01641       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
01642       // Static variable to force the class initialization
01643       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
01644 
01645       // Dictionary for non-ClassDef classes
01646       static void ROOTcLcLMathcLcLMinim1D_Dictionary() {
01647          GenerateInitInstance()->GetClass();
01648       }
01649 
01650    }
01651 }
01652 }
01653 }
01654 
01655 namespace ROOT {
01656    void ROOTcLcLMathcLcLGSLMinimizer1D_ShowMembers(void *obj, TMemberInspector &R__insp);
01657    static void ROOTcLcLMathcLcLGSLMinimizer1D_Dictionary();
01658    static void *new_ROOTcLcLMathcLcLGSLMinimizer1D(void *p = 0);
01659    static void *newArray_ROOTcLcLMathcLcLGSLMinimizer1D(Long_t size, void *p);
01660    static void delete_ROOTcLcLMathcLcLGSLMinimizer1D(void *p);
01661    static void deleteArray_ROOTcLcLMathcLcLGSLMinimizer1D(void *p);
01662    static void destruct_ROOTcLcLMathcLcLGSLMinimizer1D(void *p);
01663 
01664    // Function generating the singleton type initializer
01665    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLMinimizer1D*)
01666    {
01667       // Make sure the shadow class has the right sizeof
01668       R__ASSERT(sizeof(::ROOT::Math::GSLMinimizer1D) == sizeof(::ROOT::Shadow::ROOT::Math::GSLMinimizer1D));
01669       ::ROOT::Math::GSLMinimizer1D *ptr = 0;
01670       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLMinimizer1D),0);
01671       static ::ROOT::TGenericClassInfo 
01672          instance("ROOT::Math::GSLMinimizer1D", "include/Math/GSLMinimizer1D.h", 81,
01673                   typeid(::ROOT::Math::GSLMinimizer1D), DefineBehavior(ptr, ptr),
01674                   &ROOTcLcLMathcLcLGSLMinimizer1D_ShowMembers, &ROOTcLcLMathcLcLGSLMinimizer1D_Dictionary, isa_proxy, 4,
01675                   sizeof(::ROOT::Math::GSLMinimizer1D) );
01676       instance.SetNew(&new_ROOTcLcLMathcLcLGSLMinimizer1D);
01677       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLMinimizer1D);
01678       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLMinimizer1D);
01679       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLMinimizer1D);
01680       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLMinimizer1D);
01681       return &instance;
01682    }
01683    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLMinimizer1D*)
01684    {
01685       return GenerateInitInstanceLocal((::ROOT::Math::GSLMinimizer1D*)0);
01686    }
01687    // Static variable to force the class initialization
01688    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLMinimizer1D*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01689 
01690    // Dictionary for non-ClassDef classes
01691    static void ROOTcLcLMathcLcLGSLMinimizer1D_Dictionary() {
01692       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLMinimizer1D*)0x0)->GetClass();
01693    }
01694 
01695 } // end of namespace ROOT
01696 
01697 namespace ROOT {
01698    void ROOTcLcLMathcLcLChebyshev_ShowMembers(void *obj, TMemberInspector &R__insp);
01699    static void ROOTcLcLMathcLcLChebyshev_Dictionary();
01700    static void delete_ROOTcLcLMathcLcLChebyshev(void *p);
01701    static void deleteArray_ROOTcLcLMathcLcLChebyshev(void *p);
01702    static void destruct_ROOTcLcLMathcLcLChebyshev(void *p);
01703 
01704    // Function generating the singleton type initializer
01705    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Chebyshev*)
01706    {
01707       // Make sure the shadow class has the right sizeof
01708       R__ASSERT(sizeof(::ROOT::Math::Chebyshev) == sizeof(::ROOT::Shadow::ROOT::Math::Chebyshev));
01709       ::ROOT::Math::Chebyshev *ptr = 0;
01710       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Chebyshev),0);
01711       static ::ROOT::TGenericClassInfo 
01712          instance("ROOT::Math::Chebyshev", "include/Math/Chebyshev.h", 77,
01713                   typeid(::ROOT::Math::Chebyshev), DefineBehavior(ptr, ptr),
01714                   &ROOTcLcLMathcLcLChebyshev_ShowMembers, &ROOTcLcLMathcLcLChebyshev_Dictionary, isa_proxy, 4,
01715                   sizeof(::ROOT::Math::Chebyshev) );
01716       instance.SetDelete(&delete_ROOTcLcLMathcLcLChebyshev);
01717       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLChebyshev);
01718       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLChebyshev);
01719       return &instance;
01720    }
01721    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Chebyshev*)
01722    {
01723       return GenerateInitInstanceLocal((::ROOT::Math::Chebyshev*)0);
01724    }
01725    // Static variable to force the class initialization
01726    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Chebyshev*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01727 
01728    // Dictionary for non-ClassDef classes
01729    static void ROOTcLcLMathcLcLChebyshev_Dictionary() {
01730       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Chebyshev*)0x0)->GetClass();
01731    }
01732 
01733 } // end of namespace ROOT
01734 
01735 namespace ROOT {
01736    void ROOTcLcLMathcLcLGSLRandomEngine_ShowMembers(void *obj, TMemberInspector &R__insp);
01737    static void ROOTcLcLMathcLcLGSLRandomEngine_Dictionary();
01738    static void *new_ROOTcLcLMathcLcLGSLRandomEngine(void *p = 0);
01739    static void *newArray_ROOTcLcLMathcLcLGSLRandomEngine(Long_t size, void *p);
01740    static void delete_ROOTcLcLMathcLcLGSLRandomEngine(void *p);
01741    static void deleteArray_ROOTcLcLMathcLcLGSLRandomEngine(void *p);
01742    static void destruct_ROOTcLcLMathcLcLGSLRandomEngine(void *p);
01743 
01744    // Function generating the singleton type initializer
01745    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRandomEngine*)
01746    {
01747       // Make sure the shadow class has the right sizeof
01748       R__ASSERT(sizeof(::ROOT::Math::GSLRandomEngine) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRandomEngine));
01749       ::ROOT::Math::GSLRandomEngine *ptr = 0;
01750       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRandomEngine),0);
01751       static ::ROOT::TGenericClassInfo 
01752          instance("ROOT::Math::GSLRandomEngine", "include/Math/GSLRndmEngines.h", 63,
01753                   typeid(::ROOT::Math::GSLRandomEngine), DefineBehavior(ptr, ptr),
01754                   &ROOTcLcLMathcLcLGSLRandomEngine_ShowMembers, &ROOTcLcLMathcLcLGSLRandomEngine_Dictionary, isa_proxy, 4,
01755                   sizeof(::ROOT::Math::GSLRandomEngine) );
01756       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRandomEngine);
01757       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRandomEngine);
01758       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRandomEngine);
01759       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRandomEngine);
01760       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRandomEngine);
01761       return &instance;
01762    }
01763    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRandomEngine*)
01764    {
01765       return GenerateInitInstanceLocal((::ROOT::Math::GSLRandomEngine*)0);
01766    }
01767    // Static variable to force the class initialization
01768    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRandomEngine*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01769 
01770    // Dictionary for non-ClassDef classes
01771    static void ROOTcLcLMathcLcLGSLRandomEngine_Dictionary() {
01772       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRandomEngine*)0x0)->GetClass();
01773    }
01774 
01775 } // end of namespace ROOT
01776 
01777 namespace ROOT {
01778    void ROOTcLcLMathcLcLGSLRngMT_ShowMembers(void *obj, TMemberInspector &R__insp);
01779    static void ROOTcLcLMathcLcLGSLRngMT_Dictionary();
01780    static void *new_ROOTcLcLMathcLcLGSLRngMT(void *p = 0);
01781    static void *newArray_ROOTcLcLMathcLcLGSLRngMT(Long_t size, void *p);
01782    static void delete_ROOTcLcLMathcLcLGSLRngMT(void *p);
01783    static void deleteArray_ROOTcLcLMathcLcLGSLRngMT(void *p);
01784    static void destruct_ROOTcLcLMathcLcLGSLRngMT(void *p);
01785 
01786    // Function generating the singleton type initializer
01787    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngMT*)
01788    {
01789       // Make sure the shadow class has the right sizeof
01790       R__ASSERT(sizeof(::ROOT::Math::GSLRngMT) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngMT));
01791       ::ROOT::Math::GSLRngMT *ptr = 0;
01792       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngMT),0);
01793       static ::ROOT::TGenericClassInfo 
01794          instance("ROOT::Math::GSLRngMT", "include/Math/GSLRndmEngines.h", 270,
01795                   typeid(::ROOT::Math::GSLRngMT), DefineBehavior(ptr, ptr),
01796                   &ROOTcLcLMathcLcLGSLRngMT_ShowMembers, &ROOTcLcLMathcLcLGSLRngMT_Dictionary, isa_proxy, 4,
01797                   sizeof(::ROOT::Math::GSLRngMT) );
01798       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngMT);
01799       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngMT);
01800       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngMT);
01801       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngMT);
01802       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngMT);
01803       return &instance;
01804    }
01805    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngMT*)
01806    {
01807       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngMT*)0);
01808    }
01809    // Static variable to force the class initialization
01810    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngMT*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01811 
01812    // Dictionary for non-ClassDef classes
01813    static void ROOTcLcLMathcLcLGSLRngMT_Dictionary() {
01814       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngMT*)0x0)->GetClass();
01815    }
01816 
01817 } // end of namespace ROOT
01818 
01819 namespace ROOT {
01820    void ROOTcLcLMathcLcLGSLRngRanLux_ShowMembers(void *obj, TMemberInspector &R__insp);
01821    static void ROOTcLcLMathcLcLGSLRngRanLux_Dictionary();
01822    static void *new_ROOTcLcLMathcLcLGSLRngRanLux(void *p = 0);
01823    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLux(Long_t size, void *p);
01824    static void delete_ROOTcLcLMathcLcLGSLRngRanLux(void *p);
01825    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLux(void *p);
01826    static void destruct_ROOTcLcLMathcLcLGSLRngRanLux(void *p);
01827 
01828    // Function generating the singleton type initializer
01829    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngRanLux*)
01830    {
01831       // Make sure the shadow class has the right sizeof
01832       R__ASSERT(sizeof(::ROOT::Math::GSLRngRanLux) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngRanLux));
01833       ::ROOT::Math::GSLRngRanLux *ptr = 0;
01834       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngRanLux),0);
01835       static ::ROOT::TGenericClassInfo 
01836          instance("ROOT::Math::GSLRngRanLux", "include/Math/GSLRndmEngines.h", 283,
01837                   typeid(::ROOT::Math::GSLRngRanLux), DefineBehavior(ptr, ptr),
01838                   &ROOTcLcLMathcLcLGSLRngRanLux_ShowMembers, &ROOTcLcLMathcLcLGSLRngRanLux_Dictionary, isa_proxy, 4,
01839                   sizeof(::ROOT::Math::GSLRngRanLux) );
01840       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngRanLux);
01841       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngRanLux);
01842       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngRanLux);
01843       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngRanLux);
01844       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngRanLux);
01845       return &instance;
01846    }
01847    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngRanLux*)
01848    {
01849       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngRanLux*)0);
01850    }
01851    // Static variable to force the class initialization
01852    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLux*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01853 
01854    // Dictionary for non-ClassDef classes
01855    static void ROOTcLcLMathcLcLGSLRngRanLux_Dictionary() {
01856       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLux*)0x0)->GetClass();
01857    }
01858 
01859 } // end of namespace ROOT
01860 
01861 namespace ROOT {
01862    void ROOTcLcLMathcLcLGSLRngRanLuxS1_ShowMembers(void *obj, TMemberInspector &R__insp);
01863    static void ROOTcLcLMathcLcLGSLRngRanLuxS1_Dictionary();
01864    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p = 0);
01865    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxS1(Long_t size, void *p);
01866    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p);
01867    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p);
01868    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p);
01869 
01870    // Function generating the singleton type initializer
01871    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngRanLuxS1*)
01872    {
01873       // Make sure the shadow class has the right sizeof
01874       R__ASSERT(sizeof(::ROOT::Math::GSLRngRanLuxS1) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngRanLuxS1));
01875       ::ROOT::Math::GSLRngRanLuxS1 *ptr = 0;
01876       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngRanLuxS1),0);
01877       static ::ROOT::TGenericClassInfo 
01878          instance("ROOT::Math::GSLRngRanLuxS1", "include/Math/GSLRndmEngines.h", 296,
01879                   typeid(::ROOT::Math::GSLRngRanLuxS1), DefineBehavior(ptr, ptr),
01880                   &ROOTcLcLMathcLcLGSLRngRanLuxS1_ShowMembers, &ROOTcLcLMathcLcLGSLRngRanLuxS1_Dictionary, isa_proxy, 4,
01881                   sizeof(::ROOT::Math::GSLRngRanLuxS1) );
01882       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngRanLuxS1);
01883       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngRanLuxS1);
01884       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngRanLuxS1);
01885       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxS1);
01886       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngRanLuxS1);
01887       return &instance;
01888    }
01889    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngRanLuxS1*)
01890    {
01891       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngRanLuxS1*)0);
01892    }
01893    // Static variable to force the class initialization
01894    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxS1*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01895 
01896    // Dictionary for non-ClassDef classes
01897    static void ROOTcLcLMathcLcLGSLRngRanLuxS1_Dictionary() {
01898       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxS1*)0x0)->GetClass();
01899    }
01900 
01901 } // end of namespace ROOT
01902 
01903 namespace ROOT {
01904    void ROOTcLcLMathcLcLGSLRngRanLuxS2_ShowMembers(void *obj, TMemberInspector &R__insp);
01905    static void ROOTcLcLMathcLcLGSLRngRanLuxS2_Dictionary();
01906    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p = 0);
01907    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxS2(Long_t size, void *p);
01908    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p);
01909    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p);
01910    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p);
01911 
01912    // Function generating the singleton type initializer
01913    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngRanLuxS2*)
01914    {
01915       // Make sure the shadow class has the right sizeof
01916       R__ASSERT(sizeof(::ROOT::Math::GSLRngRanLuxS2) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngRanLuxS2));
01917       ::ROOT::Math::GSLRngRanLuxS2 *ptr = 0;
01918       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngRanLuxS2),0);
01919       static ::ROOT::TGenericClassInfo 
01920          instance("ROOT::Math::GSLRngRanLuxS2", "include/Math/GSLRndmEngines.h", 310,
01921                   typeid(::ROOT::Math::GSLRngRanLuxS2), DefineBehavior(ptr, ptr),
01922                   &ROOTcLcLMathcLcLGSLRngRanLuxS2_ShowMembers, &ROOTcLcLMathcLcLGSLRngRanLuxS2_Dictionary, isa_proxy, 4,
01923                   sizeof(::ROOT::Math::GSLRngRanLuxS2) );
01924       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngRanLuxS2);
01925       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngRanLuxS2);
01926       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngRanLuxS2);
01927       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxS2);
01928       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngRanLuxS2);
01929       return &instance;
01930    }
01931    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngRanLuxS2*)
01932    {
01933       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngRanLuxS2*)0);
01934    }
01935    // Static variable to force the class initialization
01936    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxS2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01937 
01938    // Dictionary for non-ClassDef classes
01939    static void ROOTcLcLMathcLcLGSLRngRanLuxS2_Dictionary() {
01940       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxS2*)0x0)->GetClass();
01941    }
01942 
01943 } // end of namespace ROOT
01944 
01945 namespace ROOT {
01946    void ROOTcLcLMathcLcLGSLRngRanLuxD1_ShowMembers(void *obj, TMemberInspector &R__insp);
01947    static void ROOTcLcLMathcLcLGSLRngRanLuxD1_Dictionary();
01948    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p = 0);
01949    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxD1(Long_t size, void *p);
01950    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p);
01951    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p);
01952    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p);
01953 
01954    // Function generating the singleton type initializer
01955    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngRanLuxD1*)
01956    {
01957       // Make sure the shadow class has the right sizeof
01958       R__ASSERT(sizeof(::ROOT::Math::GSLRngRanLuxD1) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngRanLuxD1));
01959       ::ROOT::Math::GSLRngRanLuxD1 *ptr = 0;
01960       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngRanLuxD1),0);
01961       static ::ROOT::TGenericClassInfo 
01962          instance("ROOT::Math::GSLRngRanLuxD1", "include/Math/GSLRndmEngines.h", 324,
01963                   typeid(::ROOT::Math::GSLRngRanLuxD1), DefineBehavior(ptr, ptr),
01964                   &ROOTcLcLMathcLcLGSLRngRanLuxD1_ShowMembers, &ROOTcLcLMathcLcLGSLRngRanLuxD1_Dictionary, isa_proxy, 4,
01965                   sizeof(::ROOT::Math::GSLRngRanLuxD1) );
01966       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngRanLuxD1);
01967       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngRanLuxD1);
01968       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngRanLuxD1);
01969       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxD1);
01970       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngRanLuxD1);
01971       return &instance;
01972    }
01973    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngRanLuxD1*)
01974    {
01975       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngRanLuxD1*)0);
01976    }
01977    // Static variable to force the class initialization
01978    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxD1*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01979 
01980    // Dictionary for non-ClassDef classes
01981    static void ROOTcLcLMathcLcLGSLRngRanLuxD1_Dictionary() {
01982       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxD1*)0x0)->GetClass();
01983    }
01984 
01985 } // end of namespace ROOT
01986 
01987 namespace ROOT {
01988    void ROOTcLcLMathcLcLGSLRngRanLuxD2_ShowMembers(void *obj, TMemberInspector &R__insp);
01989    static void ROOTcLcLMathcLcLGSLRngRanLuxD2_Dictionary();
01990    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p = 0);
01991    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxD2(Long_t size, void *p);
01992    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p);
01993    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p);
01994    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p);
01995 
01996    // Function generating the singleton type initializer
01997    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngRanLuxD2*)
01998    {
01999       // Make sure the shadow class has the right sizeof
02000       R__ASSERT(sizeof(::ROOT::Math::GSLRngRanLuxD2) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngRanLuxD2));
02001       ::ROOT::Math::GSLRngRanLuxD2 *ptr = 0;
02002       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngRanLuxD2),0);
02003       static ::ROOT::TGenericClassInfo 
02004          instance("ROOT::Math::GSLRngRanLuxD2", "include/Math/GSLRndmEngines.h", 337,
02005                   typeid(::ROOT::Math::GSLRngRanLuxD2), DefineBehavior(ptr, ptr),
02006                   &ROOTcLcLMathcLcLGSLRngRanLuxD2_ShowMembers, &ROOTcLcLMathcLcLGSLRngRanLuxD2_Dictionary, isa_proxy, 4,
02007                   sizeof(::ROOT::Math::GSLRngRanLuxD2) );
02008       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngRanLuxD2);
02009       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngRanLuxD2);
02010       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngRanLuxD2);
02011       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxD2);
02012       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngRanLuxD2);
02013       return &instance;
02014    }
02015    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngRanLuxD2*)
02016    {
02017       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngRanLuxD2*)0);
02018    }
02019    // Static variable to force the class initialization
02020    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxD2*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02021 
02022    // Dictionary for non-ClassDef classes
02023    static void ROOTcLcLMathcLcLGSLRngRanLuxD2_Dictionary() {
02024       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxD2*)0x0)->GetClass();
02025    }
02026 
02027 } // end of namespace ROOT
02028 
02029 namespace ROOT {
02030    void ROOTcLcLMathcLcLGSLRngTaus_ShowMembers(void *obj, TMemberInspector &R__insp);
02031    static void ROOTcLcLMathcLcLGSLRngTaus_Dictionary();
02032    static void *new_ROOTcLcLMathcLcLGSLRngTaus(void *p = 0);
02033    static void *newArray_ROOTcLcLMathcLcLGSLRngTaus(Long_t size, void *p);
02034    static void delete_ROOTcLcLMathcLcLGSLRngTaus(void *p);
02035    static void deleteArray_ROOTcLcLMathcLcLGSLRngTaus(void *p);
02036    static void destruct_ROOTcLcLMathcLcLGSLRngTaus(void *p);
02037 
02038    // Function generating the singleton type initializer
02039    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngTaus*)
02040    {
02041       // Make sure the shadow class has the right sizeof
02042       R__ASSERT(sizeof(::ROOT::Math::GSLRngTaus) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngTaus));
02043       ::ROOT::Math::GSLRngTaus *ptr = 0;
02044       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngTaus),0);
02045       static ::ROOT::TGenericClassInfo 
02046          instance("ROOT::Math::GSLRngTaus", "include/Math/GSLRndmEngines.h", 351,
02047                   typeid(::ROOT::Math::GSLRngTaus), DefineBehavior(ptr, ptr),
02048                   &ROOTcLcLMathcLcLGSLRngTaus_ShowMembers, &ROOTcLcLMathcLcLGSLRngTaus_Dictionary, isa_proxy, 4,
02049                   sizeof(::ROOT::Math::GSLRngTaus) );
02050       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngTaus);
02051       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngTaus);
02052       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngTaus);
02053       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngTaus);
02054       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngTaus);
02055       return &instance;
02056    }
02057    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngTaus*)
02058    {
02059       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngTaus*)0);
02060    }
02061    // Static variable to force the class initialization
02062    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngTaus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02063 
02064    // Dictionary for non-ClassDef classes
02065    static void ROOTcLcLMathcLcLGSLRngTaus_Dictionary() {
02066       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngTaus*)0x0)->GetClass();
02067    }
02068 
02069 } // end of namespace ROOT
02070 
02071 namespace ROOT {
02072    void ROOTcLcLMathcLcLGSLRngGFSR4_ShowMembers(void *obj, TMemberInspector &R__insp);
02073    static void ROOTcLcLMathcLcLGSLRngGFSR4_Dictionary();
02074    static void *new_ROOTcLcLMathcLcLGSLRngGFSR4(void *p = 0);
02075    static void *newArray_ROOTcLcLMathcLcLGSLRngGFSR4(Long_t size, void *p);
02076    static void delete_ROOTcLcLMathcLcLGSLRngGFSR4(void *p);
02077    static void deleteArray_ROOTcLcLMathcLcLGSLRngGFSR4(void *p);
02078    static void destruct_ROOTcLcLMathcLcLGSLRngGFSR4(void *p);
02079 
02080    // Function generating the singleton type initializer
02081    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLRngGFSR4*)
02082    {
02083       // Make sure the shadow class has the right sizeof
02084       R__ASSERT(sizeof(::ROOT::Math::GSLRngGFSR4) == sizeof(::ROOT::Shadow::ROOT::Math::GSLRngGFSR4));
02085       ::ROOT::Math::GSLRngGFSR4 *ptr = 0;
02086       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLRngGFSR4),0);
02087       static ::ROOT::TGenericClassInfo 
02088          instance("ROOT::Math::GSLRngGFSR4", "include/Math/GSLRndmEngines.h", 363,
02089                   typeid(::ROOT::Math::GSLRngGFSR4), DefineBehavior(ptr, ptr),
02090                   &ROOTcLcLMathcLcLGSLRngGFSR4_ShowMembers, &ROOTcLcLMathcLcLGSLRngGFSR4_Dictionary, isa_proxy, 4,
02091                   sizeof(::ROOT::Math::GSLRngGFSR4) );
02092       instance.SetNew(&new_ROOTcLcLMathcLcLGSLRngGFSR4);
02093       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLRngGFSR4);
02094       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLRngGFSR4);
02095       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLRngGFSR4);
02096       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLRngGFSR4);
02097       return &instance;
02098    }
02099    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLRngGFSR4*)
02100    {
02101       return GenerateInitInstanceLocal((::ROOT::Math::GSLRngGFSR4*)0);
02102    }
02103    // Static variable to force the class initialization
02104    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngGFSR4*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02105 
02106    // Dictionary for non-ClassDef classes
02107    static void ROOTcLcLMathcLcLGSLRngGFSR4_Dictionary() {
02108       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngGFSR4*)0x0)->GetClass();
02109    }
02110 
02111 } // end of namespace ROOT
02112 
02113 namespace ROOT {
02114    void ROOTcLcLMathcLcLKelvinFunctions_ShowMembers(void *obj, TMemberInspector &R__insp);
02115    static void ROOTcLcLMathcLcLKelvinFunctions_Dictionary();
02116    static void *new_ROOTcLcLMathcLcLKelvinFunctions(void *p = 0);
02117    static void *newArray_ROOTcLcLMathcLcLKelvinFunctions(Long_t size, void *p);
02118    static void delete_ROOTcLcLMathcLcLKelvinFunctions(void *p);
02119    static void deleteArray_ROOTcLcLMathcLcLKelvinFunctions(void *p);
02120    static void destruct_ROOTcLcLMathcLcLKelvinFunctions(void *p);
02121 
02122    // Function generating the singleton type initializer
02123    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::KelvinFunctions*)
02124    {
02125       // Make sure the shadow class has the right sizeof
02126       R__ASSERT(sizeof(::ROOT::Math::KelvinFunctions) == sizeof(::ROOT::Shadow::ROOT::Math::KelvinFunctions));
02127       ::ROOT::Math::KelvinFunctions *ptr = 0;
02128       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::KelvinFunctions),0);
02129       static ::ROOT::TGenericClassInfo 
02130          instance("ROOT::Math::KelvinFunctions", "include/Math/KelvinFunctions.h", 39,
02131                   typeid(::ROOT::Math::KelvinFunctions), DefineBehavior(ptr, ptr),
02132                   &ROOTcLcLMathcLcLKelvinFunctions_ShowMembers, &ROOTcLcLMathcLcLKelvinFunctions_Dictionary, isa_proxy, 4,
02133                   sizeof(::ROOT::Math::KelvinFunctions) );
02134       instance.SetNew(&new_ROOTcLcLMathcLcLKelvinFunctions);
02135       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLKelvinFunctions);
02136       instance.SetDelete(&delete_ROOTcLcLMathcLcLKelvinFunctions);
02137       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLKelvinFunctions);
02138       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLKelvinFunctions);
02139       return &instance;
02140    }
02141    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::KelvinFunctions*)
02142    {
02143       return GenerateInitInstanceLocal((::ROOT::Math::KelvinFunctions*)0);
02144    }
02145    // Static variable to force the class initialization
02146    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::KelvinFunctions*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02147 
02148    // Dictionary for non-ClassDef classes
02149    static void ROOTcLcLMathcLcLKelvinFunctions_Dictionary() {
02150       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::KelvinFunctions*)0x0)->GetClass();
02151    }
02152 
02153 } // end of namespace ROOT
02154 
02155 namespace ROOT {
02156    void ROOTcLcLMathcLcLGSLMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
02157    static void ROOTcLcLMathcLcLGSLMinimizer_Dictionary();
02158    static void *new_ROOTcLcLMathcLcLGSLMinimizer(void *p = 0);
02159    static void *newArray_ROOTcLcLMathcLcLGSLMinimizer(Long_t size, void *p);
02160    static void delete_ROOTcLcLMathcLcLGSLMinimizer(void *p);
02161    static void deleteArray_ROOTcLcLMathcLcLGSLMinimizer(void *p);
02162    static void destruct_ROOTcLcLMathcLcLGSLMinimizer(void *p);
02163 
02164    // Function generating the singleton type initializer
02165    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLMinimizer*)
02166    {
02167       // Make sure the shadow class has the right sizeof
02168       R__ASSERT(sizeof(::ROOT::Math::GSLMinimizer) == sizeof(::ROOT::Shadow::ROOT::Math::GSLMinimizer));
02169       ::ROOT::Math::GSLMinimizer *ptr = 0;
02170       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLMinimizer),0);
02171       static ::ROOT::TGenericClassInfo 
02172          instance("ROOT::Math::GSLMinimizer", "include/Math/GSLMinimizer.h", 94,
02173                   typeid(::ROOT::Math::GSLMinimizer), DefineBehavior(ptr, ptr),
02174                   &ROOTcLcLMathcLcLGSLMinimizer_ShowMembers, &ROOTcLcLMathcLcLGSLMinimizer_Dictionary, isa_proxy, 4,
02175                   sizeof(::ROOT::Math::GSLMinimizer) );
02176       instance.SetNew(&new_ROOTcLcLMathcLcLGSLMinimizer);
02177       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLMinimizer);
02178       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLMinimizer);
02179       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLMinimizer);
02180       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLMinimizer);
02181       return &instance;
02182    }
02183    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLMinimizer*)
02184    {
02185       return GenerateInitInstanceLocal((::ROOT::Math::GSLMinimizer*)0);
02186    }
02187    // Static variable to force the class initialization
02188    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02189 
02190    // Dictionary for non-ClassDef classes
02191    static void ROOTcLcLMathcLcLGSLMinimizer_Dictionary() {
02192       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLMinimizer*)0x0)->GetClass();
02193    }
02194 
02195 } // end of namespace ROOT
02196 
02197 namespace ROOT {
02198    void ROOTcLcLMathcLcLLSResidualFunc_ShowMembers(void *obj, TMemberInspector &R__insp);
02199    static void ROOTcLcLMathcLcLLSResidualFunc_Dictionary();
02200    static void *new_ROOTcLcLMathcLcLLSResidualFunc(void *p = 0);
02201    static void *newArray_ROOTcLcLMathcLcLLSResidualFunc(Long_t size, void *p);
02202    static void delete_ROOTcLcLMathcLcLLSResidualFunc(void *p);
02203    static void deleteArray_ROOTcLcLMathcLcLLSResidualFunc(void *p);
02204    static void destruct_ROOTcLcLMathcLcLLSResidualFunc(void *p);
02205 
02206    // Function generating the singleton type initializer
02207    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::LSResidualFunc*)
02208    {
02209       ::ROOT::Math::LSResidualFunc *ptr = 0;
02210       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::LSResidualFunc),0);
02211       static ::ROOT::TGenericClassInfo 
02212          instance("ROOT::Math::LSResidualFunc", "include/Math/GSLNLSMinimizer.h", 77,
02213                   typeid(::ROOT::Math::LSResidualFunc), DefineBehavior(ptr, ptr),
02214                   0, &ROOTcLcLMathcLcLLSResidualFunc_Dictionary, isa_proxy, 1,
02215                   sizeof(::ROOT::Math::LSResidualFunc) );
02216       instance.SetNew(&new_ROOTcLcLMathcLcLLSResidualFunc);
02217       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLLSResidualFunc);
02218       instance.SetDelete(&delete_ROOTcLcLMathcLcLLSResidualFunc);
02219       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLLSResidualFunc);
02220       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLLSResidualFunc);
02221       return &instance;
02222    }
02223    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::LSResidualFunc*)
02224    {
02225       return GenerateInitInstanceLocal((::ROOT::Math::LSResidualFunc*)0);
02226    }
02227    // Static variable to force the class initialization
02228    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::LSResidualFunc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02229 
02230    // Dictionary for non-ClassDef classes
02231    static void ROOTcLcLMathcLcLLSResidualFunc_Dictionary() {
02232       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::LSResidualFunc*)0x0)->GetClass();
02233    }
02234 
02235 } // end of namespace ROOT
02236 
02237 namespace ROOT {
02238    void ROOTcLcLMathcLcLGSLNLSMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
02239    static void ROOTcLcLMathcLcLGSLNLSMinimizer_Dictionary();
02240    static void *new_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p = 0);
02241    static void *newArray_ROOTcLcLMathcLcLGSLNLSMinimizer(Long_t size, void *p);
02242    static void delete_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p);
02243    static void deleteArray_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p);
02244    static void destruct_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p);
02245 
02246    // Function generating the singleton type initializer
02247    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLNLSMinimizer*)
02248    {
02249       ::ROOT::Math::GSLNLSMinimizer *ptr = 0;
02250       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLNLSMinimizer),0);
02251       static ::ROOT::TGenericClassInfo 
02252          instance("ROOT::Math::GSLNLSMinimizer", "include/Math/GSLNLSMinimizer.h", 162,
02253                   typeid(::ROOT::Math::GSLNLSMinimizer), DefineBehavior(ptr, ptr),
02254                   0, &ROOTcLcLMathcLcLGSLNLSMinimizer_Dictionary, isa_proxy, 1,
02255                   sizeof(::ROOT::Math::GSLNLSMinimizer) );
02256       instance.SetNew(&new_ROOTcLcLMathcLcLGSLNLSMinimizer);
02257       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLNLSMinimizer);
02258       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLNLSMinimizer);
02259       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLNLSMinimizer);
02260       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLNLSMinimizer);
02261       return &instance;
02262    }
02263    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLNLSMinimizer*)
02264    {
02265       return GenerateInitInstanceLocal((::ROOT::Math::GSLNLSMinimizer*)0);
02266    }
02267    // Static variable to force the class initialization
02268    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLNLSMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02269 
02270    // Dictionary for non-ClassDef classes
02271    static void ROOTcLcLMathcLcLGSLNLSMinimizer_Dictionary() {
02272       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLNLSMinimizer*)0x0)->GetClass();
02273    }
02274 
02275 } // end of namespace ROOT
02276 
02277 namespace ROOT {
02278    void ROOTcLcLMathcLcLGSLSimAnFunc_ShowMembers(void *obj, TMemberInspector &R__insp);
02279    static void ROOTcLcLMathcLcLGSLSimAnFunc_Dictionary();
02280    static void delete_ROOTcLcLMathcLcLGSLSimAnFunc(void *p);
02281    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnFunc(void *p);
02282    static void destruct_ROOTcLcLMathcLcLGSLSimAnFunc(void *p);
02283 
02284    // Function generating the singleton type initializer
02285    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLSimAnFunc*)
02286    {
02287       // Make sure the shadow class has the right sizeof
02288       R__ASSERT(sizeof(::ROOT::Math::GSLSimAnFunc) == sizeof(::ROOT::Shadow::ROOT::Math::GSLSimAnFunc));
02289       ::ROOT::Math::GSLSimAnFunc *ptr = 0;
02290       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLSimAnFunc),0);
02291       static ::ROOT::TGenericClassInfo 
02292          instance("ROOT::Math::GSLSimAnFunc", "include/Math/GSLSimAnnealing.h", 50,
02293                   typeid(::ROOT::Math::GSLSimAnFunc), DefineBehavior(ptr, ptr),
02294                   &ROOTcLcLMathcLcLGSLSimAnFunc_ShowMembers, &ROOTcLcLMathcLcLGSLSimAnFunc_Dictionary, isa_proxy, 4,
02295                   sizeof(::ROOT::Math::GSLSimAnFunc) );
02296       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLSimAnFunc);
02297       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLSimAnFunc);
02298       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLSimAnFunc);
02299       return &instance;
02300    }
02301    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLSimAnFunc*)
02302    {
02303       return GenerateInitInstanceLocal((::ROOT::Math::GSLSimAnFunc*)0);
02304    }
02305    // Static variable to force the class initialization
02306    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnFunc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02307 
02308    // Dictionary for non-ClassDef classes
02309    static void ROOTcLcLMathcLcLGSLSimAnFunc_Dictionary() {
02310       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnFunc*)0x0)->GetClass();
02311    }
02312 
02313 } // end of namespace ROOT
02314 
02315 namespace ROOT {
02316    void ROOTcLcLMathcLcLGSLSimAnParams_ShowMembers(void *obj, TMemberInspector &R__insp);
02317    static void ROOTcLcLMathcLcLGSLSimAnParams_Dictionary();
02318    static void *new_ROOTcLcLMathcLcLGSLSimAnParams(void *p = 0);
02319    static void *newArray_ROOTcLcLMathcLcLGSLSimAnParams(Long_t size, void *p);
02320    static void delete_ROOTcLcLMathcLcLGSLSimAnParams(void *p);
02321    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnParams(void *p);
02322    static void destruct_ROOTcLcLMathcLcLGSLSimAnParams(void *p);
02323 
02324    // Function generating the singleton type initializer
02325    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLSimAnParams*)
02326    {
02327       // Make sure the shadow class has the right sizeof
02328       R__ASSERT(sizeof(::ROOT::Math::GSLSimAnParams) == sizeof(::ROOT::Shadow::ROOT::Math::GSLSimAnParams));
02329       ::ROOT::Math::GSLSimAnParams *ptr = 0;
02330       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLSimAnParams),0);
02331       static ::ROOT::TGenericClassInfo 
02332          instance("ROOT::Math::GSLSimAnParams", "include/Math/GSLSimAnnealing.h", 161,
02333                   typeid(::ROOT::Math::GSLSimAnParams), DefineBehavior(ptr, ptr),
02334                   &ROOTcLcLMathcLcLGSLSimAnParams_ShowMembers, &ROOTcLcLMathcLcLGSLSimAnParams_Dictionary, isa_proxy, 4,
02335                   sizeof(::ROOT::Math::GSLSimAnParams) );
02336       instance.SetNew(&new_ROOTcLcLMathcLcLGSLSimAnParams);
02337       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLSimAnParams);
02338       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLSimAnParams);
02339       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLSimAnParams);
02340       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLSimAnParams);
02341       return &instance;
02342    }
02343    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLSimAnParams*)
02344    {
02345       return GenerateInitInstanceLocal((::ROOT::Math::GSLSimAnParams*)0);
02346    }
02347    // Static variable to force the class initialization
02348    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnParams*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02349 
02350    // Dictionary for non-ClassDef classes
02351    static void ROOTcLcLMathcLcLGSLSimAnParams_Dictionary() {
02352       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnParams*)0x0)->GetClass();
02353    }
02354 
02355 } // end of namespace ROOT
02356 
02357 namespace ROOT {
02358    void ROOTcLcLMathcLcLGSLSimAnnealing_ShowMembers(void *obj, TMemberInspector &R__insp);
02359    static void ROOTcLcLMathcLcLGSLSimAnnealing_Dictionary();
02360    static void *new_ROOTcLcLMathcLcLGSLSimAnnealing(void *p = 0);
02361    static void *newArray_ROOTcLcLMathcLcLGSLSimAnnealing(Long_t size, void *p);
02362    static void delete_ROOTcLcLMathcLcLGSLSimAnnealing(void *p);
02363    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnnealing(void *p);
02364    static void destruct_ROOTcLcLMathcLcLGSLSimAnnealing(void *p);
02365 
02366    // Function generating the singleton type initializer
02367    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLSimAnnealing*)
02368    {
02369       // Make sure the shadow class has the right sizeof
02370       R__ASSERT(sizeof(::ROOT::Math::GSLSimAnnealing) == sizeof(::ROOT::Shadow::ROOT::Math::GSLSimAnnealing));
02371       ::ROOT::Math::GSLSimAnnealing *ptr = 0;
02372       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLSimAnnealing),0);
02373       static ::ROOT::TGenericClassInfo 
02374          instance("ROOT::Math::GSLSimAnnealing", "include/Math/GSLSimAnnealing.h", 193,
02375                   typeid(::ROOT::Math::GSLSimAnnealing), DefineBehavior(ptr, ptr),
02376                   &ROOTcLcLMathcLcLGSLSimAnnealing_ShowMembers, &ROOTcLcLMathcLcLGSLSimAnnealing_Dictionary, isa_proxy, 4,
02377                   sizeof(::ROOT::Math::GSLSimAnnealing) );
02378       instance.SetNew(&new_ROOTcLcLMathcLcLGSLSimAnnealing);
02379       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLSimAnnealing);
02380       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLSimAnnealing);
02381       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLSimAnnealing);
02382       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLSimAnnealing);
02383       return &instance;
02384    }
02385    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLSimAnnealing*)
02386    {
02387       return GenerateInitInstanceLocal((::ROOT::Math::GSLSimAnnealing*)0);
02388    }
02389    // Static variable to force the class initialization
02390    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnnealing*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02391 
02392    // Dictionary for non-ClassDef classes
02393    static void ROOTcLcLMathcLcLGSLSimAnnealing_Dictionary() {
02394       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnnealing*)0x0)->GetClass();
02395    }
02396 
02397 } // end of namespace ROOT
02398 
02399 namespace ROOT {
02400    void ROOTcLcLMathcLcLGSLSimAnMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
02401    static void ROOTcLcLMathcLcLGSLSimAnMinimizer_Dictionary();
02402    static void *new_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p = 0);
02403    static void *newArray_ROOTcLcLMathcLcLGSLSimAnMinimizer(Long_t size, void *p);
02404    static void delete_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p);
02405    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p);
02406    static void destruct_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p);
02407 
02408    // Function generating the singleton type initializer
02409    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::GSLSimAnMinimizer*)
02410    {
02411       // Make sure the shadow class has the right sizeof
02412       R__ASSERT(sizeof(::ROOT::Math::GSLSimAnMinimizer) == sizeof(::ROOT::Shadow::ROOT::Math::GSLSimAnMinimizer));
02413       ::ROOT::Math::GSLSimAnMinimizer *ptr = 0;
02414       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::GSLSimAnMinimizer),0);
02415       static ::ROOT::TGenericClassInfo 
02416          instance("ROOT::Math::GSLSimAnMinimizer", "include/Math/GSLSimAnMinimizer.h", 78,
02417                   typeid(::ROOT::Math::GSLSimAnMinimizer), DefineBehavior(ptr, ptr),
02418                   &ROOTcLcLMathcLcLGSLSimAnMinimizer_ShowMembers, &ROOTcLcLMathcLcLGSLSimAnMinimizer_Dictionary, isa_proxy, 4,
02419                   sizeof(::ROOT::Math::GSLSimAnMinimizer) );
02420       instance.SetNew(&new_ROOTcLcLMathcLcLGSLSimAnMinimizer);
02421       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLGSLSimAnMinimizer);
02422       instance.SetDelete(&delete_ROOTcLcLMathcLcLGSLSimAnMinimizer);
02423       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLGSLSimAnMinimizer);
02424       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLGSLSimAnMinimizer);
02425       return &instance;
02426    }
02427    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::GSLSimAnMinimizer*)
02428    {
02429       return GenerateInitInstanceLocal((::ROOT::Math::GSLSimAnMinimizer*)0);
02430    }
02431    // Static variable to force the class initialization
02432    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02433 
02434    // Dictionary for non-ClassDef classes
02435    static void ROOTcLcLMathcLcLGSLSimAnMinimizer_Dictionary() {
02436       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnMinimizer*)0x0)->GetClass();
02437    }
02438 
02439 } // end of namespace ROOT
02440 
02441 namespace ROOT {
02442    void ROOTcLcLMathcLcLVavilov_ShowMembers(void *obj, TMemberInspector &R__insp);
02443    static void ROOTcLcLMathcLcLVavilov_Dictionary();
02444    static void delete_ROOTcLcLMathcLcLVavilov(void *p);
02445    static void deleteArray_ROOTcLcLMathcLcLVavilov(void *p);
02446    static void destruct_ROOTcLcLMathcLcLVavilov(void *p);
02447 
02448    // Function generating the singleton type initializer
02449    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Vavilov*)
02450    {
02451       // Make sure the shadow class has the right sizeof
02452       R__ASSERT(sizeof(::ROOT::Math::Vavilov) == sizeof(::ROOT::Shadow::ROOT::Math::Vavilov));
02453       ::ROOT::Math::Vavilov *ptr = 0;
02454       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Vavilov),0);
02455       static ::ROOT::TGenericClassInfo 
02456          instance("ROOT::Math::Vavilov", "include/Math/Vavilov.h", 121,
02457                   typeid(::ROOT::Math::Vavilov), DefineBehavior(ptr, ptr),
02458                   &ROOTcLcLMathcLcLVavilov_ShowMembers, &ROOTcLcLMathcLcLVavilov_Dictionary, isa_proxy, 4,
02459                   sizeof(::ROOT::Math::Vavilov) );
02460       instance.SetDelete(&delete_ROOTcLcLMathcLcLVavilov);
02461       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLVavilov);
02462       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLVavilov);
02463       return &instance;
02464    }
02465    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Vavilov*)
02466    {
02467       return GenerateInitInstanceLocal((::ROOT::Math::Vavilov*)0);
02468    }
02469    // Static variable to force the class initialization
02470    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Vavilov*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02471 
02472    // Dictionary for non-ClassDef classes
02473    static void ROOTcLcLMathcLcLVavilov_Dictionary() {
02474       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Vavilov*)0x0)->GetClass();
02475    }
02476 
02477 } // end of namespace ROOT
02478 
02479 namespace ROOT {
02480    void ROOTcLcLMathcLcLVavilovAccurate_ShowMembers(void *obj, TMemberInspector &R__insp);
02481    static void ROOTcLcLMathcLcLVavilovAccurate_Dictionary();
02482    static void *new_ROOTcLcLMathcLcLVavilovAccurate(void *p = 0);
02483    static void *newArray_ROOTcLcLMathcLcLVavilovAccurate(Long_t size, void *p);
02484    static void delete_ROOTcLcLMathcLcLVavilovAccurate(void *p);
02485    static void deleteArray_ROOTcLcLMathcLcLVavilovAccurate(void *p);
02486    static void destruct_ROOTcLcLMathcLcLVavilovAccurate(void *p);
02487 
02488    // Function generating the singleton type initializer
02489    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::VavilovAccurate*)
02490    {
02491       // Make sure the shadow class has the right sizeof
02492       R__ASSERT(sizeof(::ROOT::Math::VavilovAccurate) == sizeof(::ROOT::Shadow::ROOT::Math::VavilovAccurate));
02493       ::ROOT::Math::VavilovAccurate *ptr = 0;
02494       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::VavilovAccurate),0);
02495       static ::ROOT::TGenericClassInfo 
02496          instance("ROOT::Math::VavilovAccurate", "include/Math/VavilovAccurate.h", 131,
02497                   typeid(::ROOT::Math::VavilovAccurate), DefineBehavior(ptr, ptr),
02498                   &ROOTcLcLMathcLcLVavilovAccurate_ShowMembers, &ROOTcLcLMathcLcLVavilovAccurate_Dictionary, isa_proxy, 4,
02499                   sizeof(::ROOT::Math::VavilovAccurate) );
02500       instance.SetNew(&new_ROOTcLcLMathcLcLVavilovAccurate);
02501       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLVavilovAccurate);
02502       instance.SetDelete(&delete_ROOTcLcLMathcLcLVavilovAccurate);
02503       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLVavilovAccurate);
02504       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLVavilovAccurate);
02505       return &instance;
02506    }
02507    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::VavilovAccurate*)
02508    {
02509       return GenerateInitInstanceLocal((::ROOT::Math::VavilovAccurate*)0);
02510    }
02511    // Static variable to force the class initialization
02512    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurate*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02513 
02514    // Dictionary for non-ClassDef classes
02515    static void ROOTcLcLMathcLcLVavilovAccurate_Dictionary() {
02516       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurate*)0x0)->GetClass();
02517    }
02518 
02519 } // end of namespace ROOT
02520 
02521 namespace ROOT {
02522    void ROOTcLcLMathcLcLVavilovAccuratePdf_ShowMembers(void *obj, TMemberInspector &R__insp);
02523    static void ROOTcLcLMathcLcLVavilovAccuratePdf_Dictionary();
02524    static void *new_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p = 0);
02525    static void *newArray_ROOTcLcLMathcLcLVavilovAccuratePdf(Long_t size, void *p);
02526    static void delete_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p);
02527    static void deleteArray_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p);
02528    static void destruct_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p);
02529 
02530    // Function generating the singleton type initializer
02531    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::VavilovAccuratePdf*)
02532    {
02533       // Make sure the shadow class has the right sizeof
02534       R__ASSERT(sizeof(::ROOT::Math::VavilovAccuratePdf) == sizeof(::ROOT::Shadow::ROOT::Math::VavilovAccuratePdf));
02535       ::ROOT::Math::VavilovAccuratePdf *ptr = 0;
02536       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::VavilovAccuratePdf),0);
02537       static ::ROOT::TGenericClassInfo 
02538          instance("ROOT::Math::VavilovAccuratePdf", "include/Math/VavilovAccuratePdf.h", 70,
02539                   typeid(::ROOT::Math::VavilovAccuratePdf), DefineBehavior(ptr, ptr),
02540                   &ROOTcLcLMathcLcLVavilovAccuratePdf_ShowMembers, &ROOTcLcLMathcLcLVavilovAccuratePdf_Dictionary, isa_proxy, 4,
02541                   sizeof(::ROOT::Math::VavilovAccuratePdf) );
02542       instance.SetNew(&new_ROOTcLcLMathcLcLVavilovAccuratePdf);
02543       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLVavilovAccuratePdf);
02544       instance.SetDelete(&delete_ROOTcLcLMathcLcLVavilovAccuratePdf);
02545       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLVavilovAccuratePdf);
02546       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLVavilovAccuratePdf);
02547       return &instance;
02548    }
02549    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::VavilovAccuratePdf*)
02550    {
02551       return GenerateInitInstanceLocal((::ROOT::Math::VavilovAccuratePdf*)0);
02552    }
02553    // Static variable to force the class initialization
02554    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccuratePdf*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02555 
02556    // Dictionary for non-ClassDef classes
02557    static void ROOTcLcLMathcLcLVavilovAccuratePdf_Dictionary() {
02558       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccuratePdf*)0x0)->GetClass();
02559    }
02560 
02561 } // end of namespace ROOT
02562 
02563 namespace ROOT {
02564    void ROOTcLcLMathcLcLVavilovAccurateCdf_ShowMembers(void *obj, TMemberInspector &R__insp);
02565    static void ROOTcLcLMathcLcLVavilovAccurateCdf_Dictionary();
02566    static void *new_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p = 0);
02567    static void *newArray_ROOTcLcLMathcLcLVavilovAccurateCdf(Long_t size, void *p);
02568    static void delete_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p);
02569    static void deleteArray_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p);
02570    static void destruct_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p);
02571 
02572    // Function generating the singleton type initializer
02573    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::VavilovAccurateCdf*)
02574    {
02575       // Make sure the shadow class has the right sizeof
02576       R__ASSERT(sizeof(::ROOT::Math::VavilovAccurateCdf) == sizeof(::ROOT::Shadow::ROOT::Math::VavilovAccurateCdf));
02577       ::ROOT::Math::VavilovAccurateCdf *ptr = 0;
02578       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::VavilovAccurateCdf),0);
02579       static ::ROOT::TGenericClassInfo 
02580          instance("ROOT::Math::VavilovAccurateCdf", "include/Math/VavilovAccurateCdf.h", 73,
02581                   typeid(::ROOT::Math::VavilovAccurateCdf), DefineBehavior(ptr, ptr),
02582                   &ROOTcLcLMathcLcLVavilovAccurateCdf_ShowMembers, &ROOTcLcLMathcLcLVavilovAccurateCdf_Dictionary, isa_proxy, 4,
02583                   sizeof(::ROOT::Math::VavilovAccurateCdf) );
02584       instance.SetNew(&new_ROOTcLcLMathcLcLVavilovAccurateCdf);
02585       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLVavilovAccurateCdf);
02586       instance.SetDelete(&delete_ROOTcLcLMathcLcLVavilovAccurateCdf);
02587       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLVavilovAccurateCdf);
02588       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLVavilovAccurateCdf);
02589       return &instance;
02590    }
02591    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::VavilovAccurateCdf*)
02592    {
02593       return GenerateInitInstanceLocal((::ROOT::Math::VavilovAccurateCdf*)0);
02594    }
02595    // Static variable to force the class initialization
02596    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurateCdf*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02597 
02598    // Dictionary for non-ClassDef classes
02599    static void ROOTcLcLMathcLcLVavilovAccurateCdf_Dictionary() {
02600       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurateCdf*)0x0)->GetClass();
02601    }
02602 
02603 } // end of namespace ROOT
02604 
02605 namespace ROOT {
02606    void ROOTcLcLMathcLcLVavilovAccurateQuantile_ShowMembers(void *obj, TMemberInspector &R__insp);
02607    static void ROOTcLcLMathcLcLVavilovAccurateQuantile_Dictionary();
02608    static void *new_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p = 0);
02609    static void *newArray_ROOTcLcLMathcLcLVavilovAccurateQuantile(Long_t size, void *p);
02610    static void delete_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p);
02611    static void deleteArray_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p);
02612    static void destruct_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p);
02613 
02614    // Function generating the singleton type initializer
02615    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::VavilovAccurateQuantile*)
02616    {
02617       // Make sure the shadow class has the right sizeof
02618       R__ASSERT(sizeof(::ROOT::Math::VavilovAccurateQuantile) == sizeof(::ROOT::Shadow::ROOT::Math::VavilovAccurateQuantile));
02619       ::ROOT::Math::VavilovAccurateQuantile *ptr = 0;
02620       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::VavilovAccurateQuantile),0);
02621       static ::ROOT::TGenericClassInfo 
02622          instance("ROOT::Math::VavilovAccurateQuantile", "include/Math/VavilovAccurateQuantile.h", 73,
02623                   typeid(::ROOT::Math::VavilovAccurateQuantile), DefineBehavior(ptr, ptr),
02624                   &ROOTcLcLMathcLcLVavilovAccurateQuantile_ShowMembers, &ROOTcLcLMathcLcLVavilovAccurateQuantile_Dictionary, isa_proxy, 4,
02625                   sizeof(::ROOT::Math::VavilovAccurateQuantile) );
02626       instance.SetNew(&new_ROOTcLcLMathcLcLVavilovAccurateQuantile);
02627       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLVavilovAccurateQuantile);
02628       instance.SetDelete(&delete_ROOTcLcLMathcLcLVavilovAccurateQuantile);
02629       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLVavilovAccurateQuantile);
02630       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLVavilovAccurateQuantile);
02631       return &instance;
02632    }
02633    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::VavilovAccurateQuantile*)
02634    {
02635       return GenerateInitInstanceLocal((::ROOT::Math::VavilovAccurateQuantile*)0);
02636    }
02637    // Static variable to force the class initialization
02638    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurateQuantile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02639 
02640    // Dictionary for non-ClassDef classes
02641    static void ROOTcLcLMathcLcLVavilovAccurateQuantile_Dictionary() {
02642       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurateQuantile*)0x0)->GetClass();
02643    }
02644 
02645 } // end of namespace ROOT
02646 
02647 namespace ROOT {
02648    void ROOTcLcLMathcLcLVavilovFast_ShowMembers(void *obj, TMemberInspector &R__insp);
02649    static void ROOTcLcLMathcLcLVavilovFast_Dictionary();
02650    static void *new_ROOTcLcLMathcLcLVavilovFast(void *p = 0);
02651    static void *newArray_ROOTcLcLMathcLcLVavilovFast(Long_t size, void *p);
02652    static void delete_ROOTcLcLMathcLcLVavilovFast(void *p);
02653    static void deleteArray_ROOTcLcLMathcLcLVavilovFast(void *p);
02654    static void destruct_ROOTcLcLMathcLcLVavilovFast(void *p);
02655 
02656    // Function generating the singleton type initializer
02657    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::VavilovFast*)
02658    {
02659       // Make sure the shadow class has the right sizeof
02660       R__ASSERT(sizeof(::ROOT::Math::VavilovFast) == sizeof(::ROOT::Shadow::ROOT::Math::VavilovFast));
02661       ::ROOT::Math::VavilovFast *ptr = 0;
02662       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::VavilovFast),0);
02663       static ::ROOT::TGenericClassInfo 
02664          instance("ROOT::Math::VavilovFast", "include/Math/VavilovFast.h", 116,
02665                   typeid(::ROOT::Math::VavilovFast), DefineBehavior(ptr, ptr),
02666                   &ROOTcLcLMathcLcLVavilovFast_ShowMembers, &ROOTcLcLMathcLcLVavilovFast_Dictionary, isa_proxy, 4,
02667                   sizeof(::ROOT::Math::VavilovFast) );
02668       instance.SetNew(&new_ROOTcLcLMathcLcLVavilovFast);
02669       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLVavilovFast);
02670       instance.SetDelete(&delete_ROOTcLcLMathcLcLVavilovFast);
02671       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLVavilovFast);
02672       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLVavilovFast);
02673       return &instance;
02674    }
02675    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::VavilovFast*)
02676    {
02677       return GenerateInitInstanceLocal((::ROOT::Math::VavilovFast*)0);
02678    }
02679    // Static variable to force the class initialization
02680    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::VavilovFast*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02681 
02682    // Dictionary for non-ClassDef classes
02683    static void ROOTcLcLMathcLcLVavilovFast_Dictionary() {
02684       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovFast*)0x0)->GetClass();
02685    }
02686 
02687 } // end of namespace ROOT
02688 
02689 namespace ROOT {
02690    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR_ShowMembers(void *obj, TMemberInspector &R__insp);
02691    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR_Dictionary();
02692    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p = 0);
02693    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(Long_t size, void *p);
02694    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p);
02695    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p);
02696    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p);
02697 
02698    // Function generating the singleton type initializer
02699    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)
02700    {
02701       // Make sure the shadow class has the right sizeof
02702       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngMT>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngMTgR));
02703       ::ROOT::Math::Random<ROOT::Math::GSLRngMT> *ptr = 0;
02704       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngMT>),0);
02705       static ::ROOT::TGenericClassInfo 
02706          instance("ROOT::Math::Random<ROOT::Math::GSLRngMT>", "include/Math/Random.h", 58,
02707                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngMT>), DefineBehavior(ptr, ptr),
02708                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR_Dictionary, isa_proxy, 4,
02709                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngMT>) );
02710       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR);
02711       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR);
02712       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR);
02713       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR);
02714       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR);
02715       return &instance;
02716    }
02717    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)
02718    {
02719       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)0);
02720    }
02721    // Static variable to force the class initialization
02722    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02723 
02724    // Dictionary for non-ClassDef classes
02725    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR_Dictionary() {
02726       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)0x0)->GetClass();
02727    }
02728 
02729 } // end of namespace ROOT
02730 
02731 namespace ROOT {
02732    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR_ShowMembers(void *obj, TMemberInspector &R__insp);
02733    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR_Dictionary();
02734    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p = 0);
02735    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(Long_t size, void *p);
02736    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p);
02737    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p);
02738    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p);
02739 
02740    // Function generating the singleton type initializer
02741    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)
02742    {
02743       // Make sure the shadow class has the right sizeof
02744       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngTaus>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngTausgR));
02745       ::ROOT::Math::Random<ROOT::Math::GSLRngTaus> *ptr = 0;
02746       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngTaus>),0);
02747       static ::ROOT::TGenericClassInfo 
02748          instance("ROOT::Math::Random<ROOT::Math::GSLRngTaus>", "include/Math/Random.h", 58,
02749                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngTaus>), DefineBehavior(ptr, ptr),
02750                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR_Dictionary, isa_proxy, 4,
02751                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngTaus>) );
02752       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR);
02753       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR);
02754       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR);
02755       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR);
02756       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR);
02757       return &instance;
02758    }
02759    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)
02760    {
02761       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)0);
02762    }
02763    // Static variable to force the class initialization
02764    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02765 
02766    // Dictionary for non-ClassDef classes
02767    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR_Dictionary() {
02768       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)0x0)->GetClass();
02769    }
02770 
02771 } // end of namespace ROOT
02772 
02773 namespace ROOT {
02774    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR_ShowMembers(void *obj, TMemberInspector &R__insp);
02775    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR_Dictionary();
02776    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p = 0);
02777    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(Long_t size, void *p);
02778    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p);
02779    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p);
02780    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p);
02781 
02782    // Function generating the singleton type initializer
02783    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)
02784    {
02785       // Make sure the shadow class has the right sizeof
02786       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxgR));
02787       ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux> *ptr = 0;
02788       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>),0);
02789       static ::ROOT::TGenericClassInfo 
02790          instance("ROOT::Math::Random<ROOT::Math::GSLRngRanLux>", "include/Math/Random.h", 58,
02791                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>), DefineBehavior(ptr, ptr),
02792                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR_Dictionary, isa_proxy, 4,
02793                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>) );
02794       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR);
02795       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR);
02796       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR);
02797       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR);
02798       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR);
02799       return &instance;
02800    }
02801    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)
02802    {
02803       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)0);
02804    }
02805    // Static variable to force the class initialization
02806    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02807 
02808    // Dictionary for non-ClassDef classes
02809    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR_Dictionary() {
02810       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)0x0)->GetClass();
02811    }
02812 
02813 } // end of namespace ROOT
02814 
02815 namespace ROOT {
02816    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR_ShowMembers(void *obj, TMemberInspector &R__insp);
02817    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR_Dictionary();
02818    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p = 0);
02819    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(Long_t size, void *p);
02820    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p);
02821    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p);
02822    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p);
02823 
02824    // Function generating the singleton type initializer
02825    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)
02826    {
02827       // Make sure the shadow class has the right sizeof
02828       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR));
02829       ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> *ptr = 0;
02830       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>),0);
02831       static ::ROOT::TGenericClassInfo 
02832          instance("ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>", "include/Math/Random.h", 58,
02833                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>), DefineBehavior(ptr, ptr),
02834                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR_Dictionary, isa_proxy, 4,
02835                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>) );
02836       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR);
02837       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR);
02838       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR);
02839       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR);
02840       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR);
02841       return &instance;
02842    }
02843    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)
02844    {
02845       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)0);
02846    }
02847    // Static variable to force the class initialization
02848    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02849 
02850    // Dictionary for non-ClassDef classes
02851    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR_Dictionary() {
02852       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)0x0)->GetClass();
02853    }
02854 
02855 } // end of namespace ROOT
02856 
02857 namespace ROOT {
02858    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR_ShowMembers(void *obj, TMemberInspector &R__insp);
02859    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR_Dictionary();
02860    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p = 0);
02861    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(Long_t size, void *p);
02862    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p);
02863    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p);
02864    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p);
02865 
02866    // Function generating the singleton type initializer
02867    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)
02868    {
02869       // Make sure the shadow class has the right sizeof
02870       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR));
02871       ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> *ptr = 0;
02872       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>),0);
02873       static ::ROOT::TGenericClassInfo 
02874          instance("ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>", "include/Math/Random.h", 58,
02875                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>), DefineBehavior(ptr, ptr),
02876                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR_Dictionary, isa_proxy, 4,
02877                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>) );
02878       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR);
02879       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR);
02880       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR);
02881       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR);
02882       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR);
02883       return &instance;
02884    }
02885    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)
02886    {
02887       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)0);
02888    }
02889    // Static variable to force the class initialization
02890    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02891 
02892    // Dictionary for non-ClassDef classes
02893    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR_Dictionary() {
02894       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)0x0)->GetClass();
02895    }
02896 
02897 } // end of namespace ROOT
02898 
02899 namespace ROOT {
02900    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR_ShowMembers(void *obj, TMemberInspector &R__insp);
02901    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR_Dictionary();
02902    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p = 0);
02903    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(Long_t size, void *p);
02904    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p);
02905    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p);
02906    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p);
02907 
02908    // Function generating the singleton type initializer
02909    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)
02910    {
02911       // Make sure the shadow class has the right sizeof
02912       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR));
02913       ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> *ptr = 0;
02914       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>),0);
02915       static ::ROOT::TGenericClassInfo 
02916          instance("ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>", "include/Math/Random.h", 58,
02917                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>), DefineBehavior(ptr, ptr),
02918                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR_Dictionary, isa_proxy, 4,
02919                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>) );
02920       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR);
02921       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR);
02922       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR);
02923       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR);
02924       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR);
02925       return &instance;
02926    }
02927    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)
02928    {
02929       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)0);
02930    }
02931    // Static variable to force the class initialization
02932    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02933 
02934    // Dictionary for non-ClassDef classes
02935    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR_Dictionary() {
02936       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)0x0)->GetClass();
02937    }
02938 
02939 } // end of namespace ROOT
02940 
02941 namespace ROOT {
02942    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR_ShowMembers(void *obj, TMemberInspector &R__insp);
02943    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR_Dictionary();
02944    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p = 0);
02945    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(Long_t size, void *p);
02946    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p);
02947    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p);
02948    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p);
02949 
02950    // Function generating the singleton type initializer
02951    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)
02952    {
02953       // Make sure the shadow class has the right sizeof
02954       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR));
02955       ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> *ptr = 0;
02956       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>),0);
02957       static ::ROOT::TGenericClassInfo 
02958          instance("ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>", "include/Math/Random.h", 58,
02959                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>), DefineBehavior(ptr, ptr),
02960                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR_Dictionary, isa_proxy, 4,
02961                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>) );
02962       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR);
02963       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR);
02964       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR);
02965       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR);
02966       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR);
02967       return &instance;
02968    }
02969    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)
02970    {
02971       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)0);
02972    }
02973    // Static variable to force the class initialization
02974    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02975 
02976    // Dictionary for non-ClassDef classes
02977    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR_Dictionary() {
02978       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)0x0)->GetClass();
02979    }
02980 
02981 } // end of namespace ROOT
02982 
02983 namespace ROOT {
02984    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR_ShowMembers(void *obj, TMemberInspector &R__insp);
02985    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR_Dictionary();
02986    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p = 0);
02987    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(Long_t size, void *p);
02988    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p);
02989    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p);
02990    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p);
02991 
02992    // Function generating the singleton type initializer
02993    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)
02994    {
02995       // Make sure the shadow class has the right sizeof
02996       R__ASSERT(sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>) == sizeof(::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngGFSR4gR));
02997       ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> *ptr = 0;
02998       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>),0);
02999       static ::ROOT::TGenericClassInfo 
03000          instance("ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>", "include/Math/Random.h", 58,
03001                   typeid(::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>), DefineBehavior(ptr, ptr),
03002                   &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR_ShowMembers, &ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR_Dictionary, isa_proxy, 4,
03003                   sizeof(::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>) );
03004       instance.SetNew(&new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR);
03005       instance.SetNewArray(&newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR);
03006       instance.SetDelete(&delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR);
03007       instance.SetDeleteArray(&deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR);
03008       instance.SetDestructor(&destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR);
03009       return &instance;
03010    }
03011    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)
03012    {
03013       return GenerateInitInstanceLocal((::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)0);
03014    }
03015    // Static variable to force the class initialization
03016    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
03017 
03018    // Dictionary for non-ClassDef classes
03019    static void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR_Dictionary() {
03020       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)0x0)->GetClass();
03021    }
03022 
03023 } // end of namespace ROOT
03024 
03025 //______________________________________________________________________________
03026 namespace ROOT {
03027    void ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_ShowMembers(void *obj, TMemberInspector &R__insp)
03028    {
03029       // Inspect the data members of an object of class ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>.
03030       typedef ::ROOT::Shadow::ROOT::Math::ParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR ShadowClass;
03031       ShadowClass *sobj = (ShadowClass*)obj;
03032       if (sobj) { } // Dummy usage just in case there is no datamember.
03033 
03034       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)0x0)->GetClass();
03035       if (R__cl || R__insp.IsA()) { }
03036       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpar", &sobj->fNpar);
03037       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParams", (void*)&sobj->fParams);
03038       R__insp.InspectMember("vector<double>", (void*)&sobj->fParams, "fParams.", false);
03039       R__insp.GenericShowMembers("ROOT::Math::IParametricGradFunctionOneDim", ( ::ROOT::Math::IParametricGradFunctionOneDim * )( (::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*) obj ), false);
03040    }
03041 
03042 }
03043 
03044 namespace ROOT {
03045    // Wrapper around operator delete
03046    static void delete_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void *p) {
03047       delete ((::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)p);
03048    }
03049    static void deleteArray_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void *p) {
03050       delete [] ((::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)p);
03051    }
03052    static void destruct_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void *p) {
03053       typedef ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> current_t;
03054       ((current_t*)p)->~current_t();
03055    }
03056 } // end of namespace ROOT for class ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>
03057 
03058 //______________________________________________________________________________
03059 namespace ROOT {
03060    void ROOTcLcLMathcLcLPolynomial_ShowMembers(void *obj, TMemberInspector &R__insp)
03061    {
03062       // Inspect the data members of an object of class ROOT::Math::Polynomial.
03063       typedef ::ROOT::Shadow::ROOT::Math::Polynomial ShadowClass;
03064       ShadowClass *sobj = (ShadowClass*)obj;
03065       if (sobj) { } // Dummy usage just in case there is no datamember.
03066 
03067       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Polynomial*)0x0)->GetClass();
03068       if (R__cl || R__insp.IsA()) { }
03069       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrder", &sobj->fOrder);
03070       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDerived_params", (void*)&sobj->fDerived_params);
03071       R__insp.InspectMember("vector<double>", (void*)&sobj->fDerived_params, "fDerived_params.", false);
03072       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRoots", (void*)&sobj->fRoots);
03073       R__insp.InspectMember("vector<std::complex<double> >", (void*)&sobj->fRoots, "fRoots.", false);
03074       R__insp.GenericShowMembers("ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>", ( ::ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> * )( (::ROOT::Math::Polynomial*) obj ), false);
03075       R__insp.GenericShowMembers("ROOT::Math::IGradientOneDim", ( ::ROOT::Math::IGradientOneDim * )( (::ROOT::Math::Polynomial*) obj ), false);
03076    }
03077 
03078 }
03079 
03080 namespace ROOT {
03081    // Wrappers around operator new
03082    static void *new_ROOTcLcLMathcLcLPolynomial(void *p) {
03083       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Polynomial : new ::ROOT::Math::Polynomial;
03084    }
03085    static void *newArray_ROOTcLcLMathcLcLPolynomial(Long_t nElements, void *p) {
03086       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Polynomial[nElements] : new ::ROOT::Math::Polynomial[nElements];
03087    }
03088    // Wrapper around operator delete
03089    static void delete_ROOTcLcLMathcLcLPolynomial(void *p) {
03090       delete ((::ROOT::Math::Polynomial*)p);
03091    }
03092    static void deleteArray_ROOTcLcLMathcLcLPolynomial(void *p) {
03093       delete [] ((::ROOT::Math::Polynomial*)p);
03094    }
03095    static void destruct_ROOTcLcLMathcLcLPolynomial(void *p) {
03096       typedef ::ROOT::Math::Polynomial current_t;
03097       ((current_t*)p)->~current_t();
03098    }
03099 } // end of namespace ROOT for class ::ROOT::Math::Polynomial
03100 
03101 //______________________________________________________________________________
03102 namespace ROOT {
03103    void ROOTcLcLMathcLcLChebyshev_ShowMembers(void *obj, TMemberInspector &R__insp)
03104    {
03105       // Inspect the data members of an object of class ROOT::Math::Chebyshev.
03106       typedef ::ROOT::Shadow::ROOT::Math::Chebyshev ShadowClass;
03107       ShadowClass *sobj = (ShadowClass*)obj;
03108       if (sobj) { } // Dummy usage just in case there is no datamember.
03109 
03110       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Chebyshev*)0x0)->GetClass();
03111       if (R__cl || R__insp.IsA()) { }
03112       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrder", &sobj->fOrder);
03113       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSeries", &sobj->fSeries);
03114       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &sobj->fFunction);
03115    }
03116 
03117 }
03118 
03119 namespace ROOT {
03120    // Wrapper around operator delete
03121    static void delete_ROOTcLcLMathcLcLChebyshev(void *p) {
03122       delete ((::ROOT::Math::Chebyshev*)p);
03123    }
03124    static void deleteArray_ROOTcLcLMathcLcLChebyshev(void *p) {
03125       delete [] ((::ROOT::Math::Chebyshev*)p);
03126    }
03127    static void destruct_ROOTcLcLMathcLcLChebyshev(void *p) {
03128       typedef ::ROOT::Math::Chebyshev current_t;
03129       ((current_t*)p)->~current_t();
03130    }
03131 } // end of namespace ROOT for class ::ROOT::Math::Chebyshev
03132 
03133 //______________________________________________________________________________
03134 namespace ROOT {
03135    void ROOTcLcLMathcLcLDerivator_ShowMembers(void *obj, TMemberInspector &R__insp)
03136    {
03137       // Inspect the data members of an object of class ROOT::Math::Derivator.
03138       typedef ::ROOT::Shadow::ROOT::Math::Derivator ShadowClass;
03139       ShadowClass *sobj = (ShadowClass*)obj;
03140       if (sobj) { } // Dummy usage just in case there is no datamember.
03141 
03142       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Derivator*)0x0)->GetClass();
03143       if (R__cl || R__insp.IsA()) { }
03144       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDerivator", &sobj->fDerivator);
03145    }
03146 
03147 }
03148 
03149 namespace ROOT {
03150    // Wrappers around operator new
03151    static void *new_ROOTcLcLMathcLcLDerivator(void *p) {
03152       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Derivator : new ::ROOT::Math::Derivator;
03153    }
03154    static void *newArray_ROOTcLcLMathcLcLDerivator(Long_t nElements, void *p) {
03155       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Derivator[nElements] : new ::ROOT::Math::Derivator[nElements];
03156    }
03157    // Wrapper around operator delete
03158    static void delete_ROOTcLcLMathcLcLDerivator(void *p) {
03159       delete ((::ROOT::Math::Derivator*)p);
03160    }
03161    static void deleteArray_ROOTcLcLMathcLcLDerivator(void *p) {
03162       delete [] ((::ROOT::Math::Derivator*)p);
03163    }
03164    static void destruct_ROOTcLcLMathcLcLDerivator(void *p) {
03165       typedef ::ROOT::Math::Derivator current_t;
03166       ((current_t*)p)->~current_t();
03167    }
03168 } // end of namespace ROOT for class ::ROOT::Math::Derivator
03169 
03170 //______________________________________________________________________________
03171 namespace ROOT {
03172    void ROOTcLcLMathcLcLVavilov_ShowMembers(void *obj, TMemberInspector &R__insp)
03173    {
03174       // Inspect the data members of an object of class ROOT::Math::Vavilov.
03175       typedef ::ROOT::Shadow::ROOT::Math::Vavilov ShadowClass;
03176       ShadowClass *sobj = (ShadowClass*)obj;
03177       if (sobj) { } // Dummy usage just in case there is no datamember.
03178 
03179       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Vavilov*)0x0)->GetClass();
03180       if (R__cl || R__insp.IsA()) { }
03181    }
03182 
03183 }
03184 
03185 namespace ROOT {
03186    // Wrapper around operator delete
03187    static void delete_ROOTcLcLMathcLcLVavilov(void *p) {
03188       delete ((::ROOT::Math::Vavilov*)p);
03189    }
03190    static void deleteArray_ROOTcLcLMathcLcLVavilov(void *p) {
03191       delete [] ((::ROOT::Math::Vavilov*)p);
03192    }
03193    static void destruct_ROOTcLcLMathcLcLVavilov(void *p) {
03194       typedef ::ROOT::Math::Vavilov current_t;
03195       ((current_t*)p)->~current_t();
03196    }
03197 } // end of namespace ROOT for class ::ROOT::Math::Vavilov
03198 
03199 //______________________________________________________________________________
03200 namespace ROOT {
03201    void ROOTcLcLMathcLcLVavilovAccurate_ShowMembers(void *obj, TMemberInspector &R__insp)
03202    {
03203       // Inspect the data members of an object of class ROOT::Math::VavilovAccurate.
03204       typedef ::ROOT::Shadow::ROOT::Math::VavilovAccurate ShadowClass;
03205       ShadowClass *sobj = (ShadowClass*)obj;
03206       if (sobj) { } // Dummy usage just in case there is no datamember.
03207 
03208       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurate*)0x0)->GetClass();
03209       if (R__cl || R__insp.IsA()) { }
03210       R__insp.Inspect(R__cl, R__insp.GetParent(), "fH[8]", sobj->fH);
03211       R__insp.Inspect(R__cl, R__insp.GetParent(), "fT0", &sobj->fT0);
03212       R__insp.Inspect(R__cl, R__insp.GetParent(), "fT1", &sobj->fT1);
03213       R__insp.Inspect(R__cl, R__insp.GetParent(), "fT", &sobj->fT);
03214       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOmega", &sobj->fOmega);
03215       R__insp.Inspect(R__cl, R__insp.GetParent(), "fA_pdf[501]", sobj->fA_pdf);
03216       R__insp.Inspect(R__cl, R__insp.GetParent(), "fB_pdf[501]", sobj->fB_pdf);
03217       R__insp.Inspect(R__cl, R__insp.GetParent(), "fA_cdf[501]", sobj->fA_cdf);
03218       R__insp.Inspect(R__cl, R__insp.GetParent(), "fB_cdf[501]", sobj->fB_cdf);
03219       R__insp.Inspect(R__cl, R__insp.GetParent(), "fX0", &sobj->fX0);
03220       R__insp.Inspect(R__cl, R__insp.GetParent(), "fKappa", &sobj->fKappa);
03221       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeta2", &sobj->fBeta2);
03222       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpsilonPM", &sobj->fEpsilonPM);
03223       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpsilon", &sobj->fEpsilon);
03224       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuantileInit", &sobj->fQuantileInit);
03225       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNQuant", &sobj->fNQuant);
03226       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuant[32]", sobj->fQuant);
03227       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLambda[32]", sobj->fLambda);
03228       R__insp.GenericShowMembers("ROOT::Math::Vavilov", ( ::ROOT::Math::Vavilov * )( (::ROOT::Math::VavilovAccurate*) obj ), false);
03229    }
03230 
03231 }
03232 
03233 namespace ROOT {
03234    // Wrappers around operator new
03235    static void *new_ROOTcLcLMathcLcLVavilovAccurate(void *p) {
03236       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccurate : new ::ROOT::Math::VavilovAccurate;
03237    }
03238    static void *newArray_ROOTcLcLMathcLcLVavilovAccurate(Long_t nElements, void *p) {
03239       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccurate[nElements] : new ::ROOT::Math::VavilovAccurate[nElements];
03240    }
03241    // Wrapper around operator delete
03242    static void delete_ROOTcLcLMathcLcLVavilovAccurate(void *p) {
03243       delete ((::ROOT::Math::VavilovAccurate*)p);
03244    }
03245    static void deleteArray_ROOTcLcLMathcLcLVavilovAccurate(void *p) {
03246       delete [] ((::ROOT::Math::VavilovAccurate*)p);
03247    }
03248    static void destruct_ROOTcLcLMathcLcLVavilovAccurate(void *p) {
03249       typedef ::ROOT::Math::VavilovAccurate current_t;
03250       ((current_t*)p)->~current_t();
03251    }
03252 } // end of namespace ROOT for class ::ROOT::Math::VavilovAccurate
03253 
03254 //______________________________________________________________________________
03255 namespace ROOT {
03256    void ROOTcLcLMathcLcLVavilovFast_ShowMembers(void *obj, TMemberInspector &R__insp)
03257    {
03258       // Inspect the data members of an object of class ROOT::Math::VavilovFast.
03259       typedef ::ROOT::Shadow::ROOT::Math::VavilovFast ShadowClass;
03260       ShadowClass *sobj = (ShadowClass*)obj;
03261       if (sobj) { } // Dummy usage just in case there is no datamember.
03262 
03263       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovFast*)0x0)->GetClass();
03264       if (R__cl || R__insp.IsA()) { }
03265       R__insp.Inspect(R__cl, R__insp.GetParent(), "fKappa", &sobj->fKappa);
03266       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBeta2", &sobj->fBeta2);
03267       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAC[14]", sobj->fAC);
03268       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHC[9]", sobj->fHC);
03269       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWCM[201]", sobj->fWCM);
03270       R__insp.Inspect(R__cl, R__insp.GetParent(), "fItype", &sobj->fItype);
03271       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpt", &sobj->fNpt);
03272       R__insp.GenericShowMembers("ROOT::Math::Vavilov", ( ::ROOT::Math::Vavilov * )( (::ROOT::Math::VavilovFast*) obj ), false);
03273    }
03274 
03275 }
03276 
03277 namespace ROOT {
03278    // Wrappers around operator new
03279    static void *new_ROOTcLcLMathcLcLVavilovFast(void *p) {
03280       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovFast : new ::ROOT::Math::VavilovFast;
03281    }
03282    static void *newArray_ROOTcLcLMathcLcLVavilovFast(Long_t nElements, void *p) {
03283       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovFast[nElements] : new ::ROOT::Math::VavilovFast[nElements];
03284    }
03285    // Wrapper around operator delete
03286    static void delete_ROOTcLcLMathcLcLVavilovFast(void *p) {
03287       delete ((::ROOT::Math::VavilovFast*)p);
03288    }
03289    static void deleteArray_ROOTcLcLMathcLcLVavilovFast(void *p) {
03290       delete [] ((::ROOT::Math::VavilovFast*)p);
03291    }
03292    static void destruct_ROOTcLcLMathcLcLVavilovFast(void *p) {
03293       typedef ::ROOT::Math::VavilovFast current_t;
03294       ((current_t*)p)->~current_t();
03295    }
03296 } // end of namespace ROOT for class ::ROOT::Math::VavilovFast
03297 
03298 //______________________________________________________________________________
03299 namespace ROOT {
03300    void ROOTcLcLMathcLcLVavilovAccuratePdf_ShowMembers(void *obj, TMemberInspector &R__insp)
03301    {
03302       // Inspect the data members of an object of class ROOT::Math::VavilovAccuratePdf.
03303       typedef ::ROOT::Shadow::ROOT::Math::VavilovAccuratePdf ShadowClass;
03304       ShadowClass *sobj = (ShadowClass*)obj;
03305       if (sobj) { } // Dummy usage just in case there is no datamember.
03306 
03307       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccuratePdf*)0x0)->GetClass();
03308       if (R__cl || R__insp.IsA()) { }
03309       R__insp.Inspect(R__cl, R__insp.GetParent(), "fP[5]", sobj->fP);
03310       R__insp.GenericShowMembers("ROOT::Math::IParametricFunctionOneDim", ( ::ROOT::Math::IParametricFunctionOneDim * )( (::ROOT::Math::VavilovAccuratePdf*) obj ), false);
03311    }
03312 
03313 }
03314 
03315 namespace ROOT {
03316    // Wrappers around operator new
03317    static void *new_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p) {
03318       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccuratePdf : new ::ROOT::Math::VavilovAccuratePdf;
03319    }
03320    static void *newArray_ROOTcLcLMathcLcLVavilovAccuratePdf(Long_t nElements, void *p) {
03321       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccuratePdf[nElements] : new ::ROOT::Math::VavilovAccuratePdf[nElements];
03322    }
03323    // Wrapper around operator delete
03324    static void delete_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p) {
03325       delete ((::ROOT::Math::VavilovAccuratePdf*)p);
03326    }
03327    static void deleteArray_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p) {
03328       delete [] ((::ROOT::Math::VavilovAccuratePdf*)p);
03329    }
03330    static void destruct_ROOTcLcLMathcLcLVavilovAccuratePdf(void *p) {
03331       typedef ::ROOT::Math::VavilovAccuratePdf current_t;
03332       ((current_t*)p)->~current_t();
03333    }
03334 } // end of namespace ROOT for class ::ROOT::Math::VavilovAccuratePdf
03335 
03336 //______________________________________________________________________________
03337 namespace ROOT {
03338    void ROOTcLcLMathcLcLVavilovAccurateCdf_ShowMembers(void *obj, TMemberInspector &R__insp)
03339    {
03340       // Inspect the data members of an object of class ROOT::Math::VavilovAccurateCdf.
03341       typedef ::ROOT::Shadow::ROOT::Math::VavilovAccurateCdf ShadowClass;
03342       ShadowClass *sobj = (ShadowClass*)obj;
03343       if (sobj) { } // Dummy usage just in case there is no datamember.
03344 
03345       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurateCdf*)0x0)->GetClass();
03346       if (R__cl || R__insp.IsA()) { }
03347       R__insp.Inspect(R__cl, R__insp.GetParent(), "fP[5]", sobj->fP);
03348       R__insp.GenericShowMembers("ROOT::Math::IParametricFunctionOneDim", ( ::ROOT::Math::IParametricFunctionOneDim * )( (::ROOT::Math::VavilovAccurateCdf*) obj ), false);
03349    }
03350 
03351 }
03352 
03353 namespace ROOT {
03354    // Wrappers around operator new
03355    static void *new_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p) {
03356       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccurateCdf : new ::ROOT::Math::VavilovAccurateCdf;
03357    }
03358    static void *newArray_ROOTcLcLMathcLcLVavilovAccurateCdf(Long_t nElements, void *p) {
03359       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccurateCdf[nElements] : new ::ROOT::Math::VavilovAccurateCdf[nElements];
03360    }
03361    // Wrapper around operator delete
03362    static void delete_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p) {
03363       delete ((::ROOT::Math::VavilovAccurateCdf*)p);
03364    }
03365    static void deleteArray_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p) {
03366       delete [] ((::ROOT::Math::VavilovAccurateCdf*)p);
03367    }
03368    static void destruct_ROOTcLcLMathcLcLVavilovAccurateCdf(void *p) {
03369       typedef ::ROOT::Math::VavilovAccurateCdf current_t;
03370       ((current_t*)p)->~current_t();
03371    }
03372 } // end of namespace ROOT for class ::ROOT::Math::VavilovAccurateCdf
03373 
03374 //______________________________________________________________________________
03375 namespace ROOT {
03376    void ROOTcLcLMathcLcLVavilovAccurateQuantile_ShowMembers(void *obj, TMemberInspector &R__insp)
03377    {
03378       // Inspect the data members of an object of class ROOT::Math::VavilovAccurateQuantile.
03379       typedef ::ROOT::Shadow::ROOT::Math::VavilovAccurateQuantile ShadowClass;
03380       ShadowClass *sobj = (ShadowClass*)obj;
03381       if (sobj) { } // Dummy usage just in case there is no datamember.
03382 
03383       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VavilovAccurateQuantile*)0x0)->GetClass();
03384       if (R__cl || R__insp.IsA()) { }
03385       R__insp.Inspect(R__cl, R__insp.GetParent(), "fP[5]", sobj->fP);
03386       R__insp.GenericShowMembers("ROOT::Math::IParametricFunctionOneDim", ( ::ROOT::Math::IParametricFunctionOneDim * )( (::ROOT::Math::VavilovAccurateQuantile*) obj ), false);
03387    }
03388 
03389 }
03390 
03391 namespace ROOT {
03392    // Wrappers around operator new
03393    static void *new_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p) {
03394       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccurateQuantile : new ::ROOT::Math::VavilovAccurateQuantile;
03395    }
03396    static void *newArray_ROOTcLcLMathcLcLVavilovAccurateQuantile(Long_t nElements, void *p) {
03397       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VavilovAccurateQuantile[nElements] : new ::ROOT::Math::VavilovAccurateQuantile[nElements];
03398    }
03399    // Wrapper around operator delete
03400    static void delete_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p) {
03401       delete ((::ROOT::Math::VavilovAccurateQuantile*)p);
03402    }
03403    static void deleteArray_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p) {
03404       delete [] ((::ROOT::Math::VavilovAccurateQuantile*)p);
03405    }
03406    static void destruct_ROOTcLcLMathcLcLVavilovAccurateQuantile(void *p) {
03407       typedef ::ROOT::Math::VavilovAccurateQuantile current_t;
03408       ((current_t*)p)->~current_t();
03409    }
03410 } // end of namespace ROOT for class ::ROOT::Math::VavilovAccurateQuantile
03411 
03412 //______________________________________________________________________________
03413 namespace ROOT {
03414    void ROOTcLcLMathcLcLGSLIntegrator_ShowMembers(void *obj, TMemberInspector &R__insp)
03415    {
03416       // Inspect the data members of an object of class ROOT::Math::GSLIntegrator.
03417       typedef ::ROOT::Shadow::ROOT::Math::GSLIntegrator ShadowClass;
03418       ShadowClass *sobj = (ShadowClass*)obj;
03419       if (sobj) { } // Dummy usage just in case there is no datamember.
03420 
03421       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLIntegrator*)0x0)->GetClass();
03422       if (R__cl || R__insp.IsA()) { }
03423       R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &sobj->fType);
03424       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRule", &sobj->fRule);
03425       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAbsTol", &sobj->fAbsTol);
03426       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRelTol", &sobj->fRelTol);
03427       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &sobj->fSize);
03428       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxIntervals", &sobj->fMaxIntervals);
03429       R__insp.Inspect(R__cl, R__insp.GetParent(), "fResult", &sobj->fResult);
03430       R__insp.Inspect(R__cl, R__insp.GetParent(), "fError", &sobj->fError);
03431       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &sobj->fStatus);
03432       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEval", &sobj->fNEval);
03433       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &sobj->fFunction);
03434       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkspace", &sobj->fWorkspace);
03435       R__insp.GenericShowMembers("ROOT::Math::VirtualIntegratorOneDim", ( ::ROOT::Math::VirtualIntegratorOneDim * )( (::ROOT::Math::GSLIntegrator*) obj ), false);
03436    }
03437 
03438 }
03439 
03440 namespace ROOT {
03441    // Wrappers around operator new
03442    static void *new_ROOTcLcLMathcLcLGSLIntegrator(void *p) {
03443       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLIntegrator : new ::ROOT::Math::GSLIntegrator;
03444    }
03445    static void *newArray_ROOTcLcLMathcLcLGSLIntegrator(Long_t nElements, void *p) {
03446       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLIntegrator[nElements] : new ::ROOT::Math::GSLIntegrator[nElements];
03447    }
03448    // Wrapper around operator delete
03449    static void delete_ROOTcLcLMathcLcLGSLIntegrator(void *p) {
03450       delete ((::ROOT::Math::GSLIntegrator*)p);
03451    }
03452    static void deleteArray_ROOTcLcLMathcLcLGSLIntegrator(void *p) {
03453       delete [] ((::ROOT::Math::GSLIntegrator*)p);
03454    }
03455    static void destruct_ROOTcLcLMathcLcLGSLIntegrator(void *p) {
03456       typedef ::ROOT::Math::GSLIntegrator current_t;
03457       ((current_t*)p)->~current_t();
03458    }
03459 } // end of namespace ROOT for class ::ROOT::Math::GSLIntegrator
03460 
03461 //______________________________________________________________________________
03462 namespace ROOT {
03463    void ROOTcLcLMathcLcLGSLMinimizer1D_ShowMembers(void *obj, TMemberInspector &R__insp)
03464    {
03465       // Inspect the data members of an object of class ROOT::Math::GSLMinimizer1D.
03466       typedef ::ROOT::Shadow::ROOT::Math::GSLMinimizer1D ShadowClass;
03467       ShadowClass *sobj = (ShadowClass*)obj;
03468       if (sobj) { } // Dummy usage just in case there is no datamember.
03469 
03470       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLMinimizer1D*)0x0)->GetClass();
03471       if (R__cl || R__insp.IsA()) { }
03472       R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &sobj->fXmin);
03473       R__insp.Inspect(R__cl, R__insp.GetParent(), "fXlow", &sobj->fXlow);
03474       R__insp.Inspect(R__cl, R__insp.GetParent(), "fXup", &sobj->fXup);
03475       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &sobj->fMin);
03476       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLow", &sobj->fLow);
03477       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUp", &sobj->fUp);
03478       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", &sobj->fIter);
03479       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &sobj->fStatus);
03480       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsSet", &sobj->fIsSet);
03481       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinimizer", &sobj->fMinimizer);
03482       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &sobj->fFunction);
03483       R__insp.GenericShowMembers("ROOT::Math::IMinimizer1D", ( ::ROOT::Math::IMinimizer1D * )( (::ROOT::Math::GSLMinimizer1D*) obj ), false);
03484    }
03485 
03486 }
03487 
03488 namespace ROOT {
03489    // Wrappers around operator new
03490    static void *new_ROOTcLcLMathcLcLGSLMinimizer1D(void *p) {
03491       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLMinimizer1D : new ::ROOT::Math::GSLMinimizer1D;
03492    }
03493    static void *newArray_ROOTcLcLMathcLcLGSLMinimizer1D(Long_t nElements, void *p) {
03494       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLMinimizer1D[nElements] : new ::ROOT::Math::GSLMinimizer1D[nElements];
03495    }
03496    // Wrapper around operator delete
03497    static void delete_ROOTcLcLMathcLcLGSLMinimizer1D(void *p) {
03498       delete ((::ROOT::Math::GSLMinimizer1D*)p);
03499    }
03500    static void deleteArray_ROOTcLcLMathcLcLGSLMinimizer1D(void *p) {
03501       delete [] ((::ROOT::Math::GSLMinimizer1D*)p);
03502    }
03503    static void destruct_ROOTcLcLMathcLcLGSLMinimizer1D(void *p) {
03504       typedef ::ROOT::Math::GSLMinimizer1D current_t;
03505       ((current_t*)p)->~current_t();
03506    }
03507 } // end of namespace ROOT for class ::ROOT::Math::GSLMinimizer1D
03508 
03509 //______________________________________________________________________________
03510 namespace ROOT {
03511    void ROOTcLcLMathcLcLInterpolator_ShowMembers(void *obj, TMemberInspector &R__insp)
03512    {
03513       // Inspect the data members of an object of class ROOT::Math::Interpolator.
03514       typedef ::ROOT::Shadow::ROOT::Math::Interpolator ShadowClass;
03515       ShadowClass *sobj = (ShadowClass*)obj;
03516       if (sobj) { } // Dummy usage just in case there is no datamember.
03517 
03518       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Interpolator*)0x0)->GetClass();
03519       if (R__cl || R__insp.IsA()) { }
03520       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterp", &sobj->fInterp);
03521    }
03522 
03523 }
03524 
03525 namespace ROOT {
03526    // Wrappers around operator new
03527    static void *new_ROOTcLcLMathcLcLInterpolator(void *p) {
03528       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Interpolator : new ::ROOT::Math::Interpolator;
03529    }
03530    static void *newArray_ROOTcLcLMathcLcLInterpolator(Long_t nElements, void *p) {
03531       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Interpolator[nElements] : new ::ROOT::Math::Interpolator[nElements];
03532    }
03533    // Wrapper around operator delete
03534    static void delete_ROOTcLcLMathcLcLInterpolator(void *p) {
03535       delete ((::ROOT::Math::Interpolator*)p);
03536    }
03537    static void deleteArray_ROOTcLcLMathcLcLInterpolator(void *p) {
03538       delete [] ((::ROOT::Math::Interpolator*)p);
03539    }
03540    static void destruct_ROOTcLcLMathcLcLInterpolator(void *p) {
03541       typedef ::ROOT::Math::Interpolator current_t;
03542       ((current_t*)p)->~current_t();
03543    }
03544 } // end of namespace ROOT for class ::ROOT::Math::Interpolator
03545 
03546 //______________________________________________________________________________
03547 namespace ROOT {
03548    void ROOTcLcLMathcLcLGSLRandomEngine_ShowMembers(void *obj, TMemberInspector &R__insp)
03549    {
03550       // Inspect the data members of an object of class ROOT::Math::GSLRandomEngine.
03551       typedef ::ROOT::Shadow::ROOT::Math::GSLRandomEngine ShadowClass;
03552       ShadowClass *sobj = (ShadowClass*)obj;
03553       if (sobj) { } // Dummy usage just in case there is no datamember.
03554 
03555       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRandomEngine*)0x0)->GetClass();
03556       if (R__cl || R__insp.IsA()) { }
03557       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRng", &sobj->fRng);
03558       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurTime", &sobj->fCurTime);
03559    }
03560 
03561 }
03562 
03563 namespace ROOT {
03564    // Wrappers around operator new
03565    static void *new_ROOTcLcLMathcLcLGSLRandomEngine(void *p) {
03566       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRandomEngine : new ::ROOT::Math::GSLRandomEngine;
03567    }
03568    static void *newArray_ROOTcLcLMathcLcLGSLRandomEngine(Long_t nElements, void *p) {
03569       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRandomEngine[nElements] : new ::ROOT::Math::GSLRandomEngine[nElements];
03570    }
03571    // Wrapper around operator delete
03572    static void delete_ROOTcLcLMathcLcLGSLRandomEngine(void *p) {
03573       delete ((::ROOT::Math::GSLRandomEngine*)p);
03574    }
03575    static void deleteArray_ROOTcLcLMathcLcLGSLRandomEngine(void *p) {
03576       delete [] ((::ROOT::Math::GSLRandomEngine*)p);
03577    }
03578    static void destruct_ROOTcLcLMathcLcLGSLRandomEngine(void *p) {
03579       typedef ::ROOT::Math::GSLRandomEngine current_t;
03580       ((current_t*)p)->~current_t();
03581    }
03582 } // end of namespace ROOT for class ::ROOT::Math::GSLRandomEngine
03583 
03584 //______________________________________________________________________________
03585 namespace ROOT {
03586    void ROOTcLcLMathcLcLGSLRngMT_ShowMembers(void *obj, TMemberInspector &R__insp)
03587    {
03588       // Inspect the data members of an object of class ROOT::Math::GSLRngMT.
03589       typedef ::ROOT::Shadow::ROOT::Math::GSLRngMT ShadowClass;
03590       ShadowClass *sobj = (ShadowClass*)obj;
03591       if (sobj) { } // Dummy usage just in case there is no datamember.
03592 
03593       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngMT*)0x0)->GetClass();
03594       if (R__cl || R__insp.IsA()) { }
03595       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngMT*) obj ), false);
03596    }
03597 
03598 }
03599 
03600 namespace ROOT {
03601    // Wrappers around operator new
03602    static void *new_ROOTcLcLMathcLcLGSLRngMT(void *p) {
03603       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngMT : new ::ROOT::Math::GSLRngMT;
03604    }
03605    static void *newArray_ROOTcLcLMathcLcLGSLRngMT(Long_t nElements, void *p) {
03606       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngMT[nElements] : new ::ROOT::Math::GSLRngMT[nElements];
03607    }
03608    // Wrapper around operator delete
03609    static void delete_ROOTcLcLMathcLcLGSLRngMT(void *p) {
03610       delete ((::ROOT::Math::GSLRngMT*)p);
03611    }
03612    static void deleteArray_ROOTcLcLMathcLcLGSLRngMT(void *p) {
03613       delete [] ((::ROOT::Math::GSLRngMT*)p);
03614    }
03615    static void destruct_ROOTcLcLMathcLcLGSLRngMT(void *p) {
03616       typedef ::ROOT::Math::GSLRngMT current_t;
03617       ((current_t*)p)->~current_t();
03618    }
03619 } // end of namespace ROOT for class ::ROOT::Math::GSLRngMT
03620 
03621 //______________________________________________________________________________
03622 namespace ROOT {
03623    void ROOTcLcLMathcLcLGSLRngTaus_ShowMembers(void *obj, TMemberInspector &R__insp)
03624    {
03625       // Inspect the data members of an object of class ROOT::Math::GSLRngTaus.
03626       typedef ::ROOT::Shadow::ROOT::Math::GSLRngTaus ShadowClass;
03627       ShadowClass *sobj = (ShadowClass*)obj;
03628       if (sobj) { } // Dummy usage just in case there is no datamember.
03629 
03630       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngTaus*)0x0)->GetClass();
03631       if (R__cl || R__insp.IsA()) { }
03632       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngTaus*) obj ), false);
03633    }
03634 
03635 }
03636 
03637 namespace ROOT {
03638    // Wrappers around operator new
03639    static void *new_ROOTcLcLMathcLcLGSLRngTaus(void *p) {
03640       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngTaus : new ::ROOT::Math::GSLRngTaus;
03641    }
03642    static void *newArray_ROOTcLcLMathcLcLGSLRngTaus(Long_t nElements, void *p) {
03643       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngTaus[nElements] : new ::ROOT::Math::GSLRngTaus[nElements];
03644    }
03645    // Wrapper around operator delete
03646    static void delete_ROOTcLcLMathcLcLGSLRngTaus(void *p) {
03647       delete ((::ROOT::Math::GSLRngTaus*)p);
03648    }
03649    static void deleteArray_ROOTcLcLMathcLcLGSLRngTaus(void *p) {
03650       delete [] ((::ROOT::Math::GSLRngTaus*)p);
03651    }
03652    static void destruct_ROOTcLcLMathcLcLGSLRngTaus(void *p) {
03653       typedef ::ROOT::Math::GSLRngTaus current_t;
03654       ((current_t*)p)->~current_t();
03655    }
03656 } // end of namespace ROOT for class ::ROOT::Math::GSLRngTaus
03657 
03658 //______________________________________________________________________________
03659 namespace ROOT {
03660    void ROOTcLcLMathcLcLGSLRngRanLux_ShowMembers(void *obj, TMemberInspector &R__insp)
03661    {
03662       // Inspect the data members of an object of class ROOT::Math::GSLRngRanLux.
03663       typedef ::ROOT::Shadow::ROOT::Math::GSLRngRanLux ShadowClass;
03664       ShadowClass *sobj = (ShadowClass*)obj;
03665       if (sobj) { } // Dummy usage just in case there is no datamember.
03666 
03667       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLux*)0x0)->GetClass();
03668       if (R__cl || R__insp.IsA()) { }
03669       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngRanLux*) obj ), false);
03670    }
03671 
03672 }
03673 
03674 namespace ROOT {
03675    // Wrappers around operator new
03676    static void *new_ROOTcLcLMathcLcLGSLRngRanLux(void *p) {
03677       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLux : new ::ROOT::Math::GSLRngRanLux;
03678    }
03679    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLux(Long_t nElements, void *p) {
03680       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLux[nElements] : new ::ROOT::Math::GSLRngRanLux[nElements];
03681    }
03682    // Wrapper around operator delete
03683    static void delete_ROOTcLcLMathcLcLGSLRngRanLux(void *p) {
03684       delete ((::ROOT::Math::GSLRngRanLux*)p);
03685    }
03686    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLux(void *p) {
03687       delete [] ((::ROOT::Math::GSLRngRanLux*)p);
03688    }
03689    static void destruct_ROOTcLcLMathcLcLGSLRngRanLux(void *p) {
03690       typedef ::ROOT::Math::GSLRngRanLux current_t;
03691       ((current_t*)p)->~current_t();
03692    }
03693 } // end of namespace ROOT for class ::ROOT::Math::GSLRngRanLux
03694 
03695 //______________________________________________________________________________
03696 namespace ROOT {
03697    void ROOTcLcLMathcLcLGSLRngRanLuxS1_ShowMembers(void *obj, TMemberInspector &R__insp)
03698    {
03699       // Inspect the data members of an object of class ROOT::Math::GSLRngRanLuxS1.
03700       typedef ::ROOT::Shadow::ROOT::Math::GSLRngRanLuxS1 ShadowClass;
03701       ShadowClass *sobj = (ShadowClass*)obj;
03702       if (sobj) { } // Dummy usage just in case there is no datamember.
03703 
03704       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxS1*)0x0)->GetClass();
03705       if (R__cl || R__insp.IsA()) { }
03706       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngRanLuxS1*) obj ), false);
03707    }
03708 
03709 }
03710 
03711 namespace ROOT {
03712    // Wrappers around operator new
03713    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p) {
03714       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxS1 : new ::ROOT::Math::GSLRngRanLuxS1;
03715    }
03716    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxS1(Long_t nElements, void *p) {
03717       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxS1[nElements] : new ::ROOT::Math::GSLRngRanLuxS1[nElements];
03718    }
03719    // Wrapper around operator delete
03720    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p) {
03721       delete ((::ROOT::Math::GSLRngRanLuxS1*)p);
03722    }
03723    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p) {
03724       delete [] ((::ROOT::Math::GSLRngRanLuxS1*)p);
03725    }
03726    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxS1(void *p) {
03727       typedef ::ROOT::Math::GSLRngRanLuxS1 current_t;
03728       ((current_t*)p)->~current_t();
03729    }
03730 } // end of namespace ROOT for class ::ROOT::Math::GSLRngRanLuxS1
03731 
03732 //______________________________________________________________________________
03733 namespace ROOT {
03734    void ROOTcLcLMathcLcLGSLRngRanLuxS2_ShowMembers(void *obj, TMemberInspector &R__insp)
03735    {
03736       // Inspect the data members of an object of class ROOT::Math::GSLRngRanLuxS2.
03737       typedef ::ROOT::Shadow::ROOT::Math::GSLRngRanLuxS2 ShadowClass;
03738       ShadowClass *sobj = (ShadowClass*)obj;
03739       if (sobj) { } // Dummy usage just in case there is no datamember.
03740 
03741       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxS2*)0x0)->GetClass();
03742       if (R__cl || R__insp.IsA()) { }
03743       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngRanLuxS2*) obj ), false);
03744    }
03745 
03746 }
03747 
03748 namespace ROOT {
03749    // Wrappers around operator new
03750    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p) {
03751       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxS2 : new ::ROOT::Math::GSLRngRanLuxS2;
03752    }
03753    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxS2(Long_t nElements, void *p) {
03754       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxS2[nElements] : new ::ROOT::Math::GSLRngRanLuxS2[nElements];
03755    }
03756    // Wrapper around operator delete
03757    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p) {
03758       delete ((::ROOT::Math::GSLRngRanLuxS2*)p);
03759    }
03760    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p) {
03761       delete [] ((::ROOT::Math::GSLRngRanLuxS2*)p);
03762    }
03763    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxS2(void *p) {
03764       typedef ::ROOT::Math::GSLRngRanLuxS2 current_t;
03765       ((current_t*)p)->~current_t();
03766    }
03767 } // end of namespace ROOT for class ::ROOT::Math::GSLRngRanLuxS2
03768 
03769 //______________________________________________________________________________
03770 namespace ROOT {
03771    void ROOTcLcLMathcLcLGSLRngRanLuxD1_ShowMembers(void *obj, TMemberInspector &R__insp)
03772    {
03773       // Inspect the data members of an object of class ROOT::Math::GSLRngRanLuxD1.
03774       typedef ::ROOT::Shadow::ROOT::Math::GSLRngRanLuxD1 ShadowClass;
03775       ShadowClass *sobj = (ShadowClass*)obj;
03776       if (sobj) { } // Dummy usage just in case there is no datamember.
03777 
03778       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxD1*)0x0)->GetClass();
03779       if (R__cl || R__insp.IsA()) { }
03780       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngRanLuxD1*) obj ), false);
03781    }
03782 
03783 }
03784 
03785 namespace ROOT {
03786    // Wrappers around operator new
03787    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p) {
03788       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxD1 : new ::ROOT::Math::GSLRngRanLuxD1;
03789    }
03790    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxD1(Long_t nElements, void *p) {
03791       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxD1[nElements] : new ::ROOT::Math::GSLRngRanLuxD1[nElements];
03792    }
03793    // Wrapper around operator delete
03794    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p) {
03795       delete ((::ROOT::Math::GSLRngRanLuxD1*)p);
03796    }
03797    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p) {
03798       delete [] ((::ROOT::Math::GSLRngRanLuxD1*)p);
03799    }
03800    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxD1(void *p) {
03801       typedef ::ROOT::Math::GSLRngRanLuxD1 current_t;
03802       ((current_t*)p)->~current_t();
03803    }
03804 } // end of namespace ROOT for class ::ROOT::Math::GSLRngRanLuxD1
03805 
03806 //______________________________________________________________________________
03807 namespace ROOT {
03808    void ROOTcLcLMathcLcLGSLRngRanLuxD2_ShowMembers(void *obj, TMemberInspector &R__insp)
03809    {
03810       // Inspect the data members of an object of class ROOT::Math::GSLRngRanLuxD2.
03811       typedef ::ROOT::Shadow::ROOT::Math::GSLRngRanLuxD2 ShadowClass;
03812       ShadowClass *sobj = (ShadowClass*)obj;
03813       if (sobj) { } // Dummy usage just in case there is no datamember.
03814 
03815       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngRanLuxD2*)0x0)->GetClass();
03816       if (R__cl || R__insp.IsA()) { }
03817       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngRanLuxD2*) obj ), false);
03818    }
03819 
03820 }
03821 
03822 namespace ROOT {
03823    // Wrappers around operator new
03824    static void *new_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p) {
03825       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxD2 : new ::ROOT::Math::GSLRngRanLuxD2;
03826    }
03827    static void *newArray_ROOTcLcLMathcLcLGSLRngRanLuxD2(Long_t nElements, void *p) {
03828       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngRanLuxD2[nElements] : new ::ROOT::Math::GSLRngRanLuxD2[nElements];
03829    }
03830    // Wrapper around operator delete
03831    static void delete_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p) {
03832       delete ((::ROOT::Math::GSLRngRanLuxD2*)p);
03833    }
03834    static void deleteArray_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p) {
03835       delete [] ((::ROOT::Math::GSLRngRanLuxD2*)p);
03836    }
03837    static void destruct_ROOTcLcLMathcLcLGSLRngRanLuxD2(void *p) {
03838       typedef ::ROOT::Math::GSLRngRanLuxD2 current_t;
03839       ((current_t*)p)->~current_t();
03840    }
03841 } // end of namespace ROOT for class ::ROOT::Math::GSLRngRanLuxD2
03842 
03843 //______________________________________________________________________________
03844 namespace ROOT {
03845    void ROOTcLcLMathcLcLGSLRngGFSR4_ShowMembers(void *obj, TMemberInspector &R__insp)
03846    {
03847       // Inspect the data members of an object of class ROOT::Math::GSLRngGFSR4.
03848       typedef ::ROOT::Shadow::ROOT::Math::GSLRngGFSR4 ShadowClass;
03849       ShadowClass *sobj = (ShadowClass*)obj;
03850       if (sobj) { } // Dummy usage just in case there is no datamember.
03851 
03852       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRngGFSR4*)0x0)->GetClass();
03853       if (R__cl || R__insp.IsA()) { }
03854       R__insp.GenericShowMembers("ROOT::Math::GSLRandomEngine", ( ::ROOT::Math::GSLRandomEngine * )( (::ROOT::Math::GSLRngGFSR4*) obj ), false);
03855    }
03856 
03857 }
03858 
03859 namespace ROOT {
03860    // Wrappers around operator new
03861    static void *new_ROOTcLcLMathcLcLGSLRngGFSR4(void *p) {
03862       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngGFSR4 : new ::ROOT::Math::GSLRngGFSR4;
03863    }
03864    static void *newArray_ROOTcLcLMathcLcLGSLRngGFSR4(Long_t nElements, void *p) {
03865       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRngGFSR4[nElements] : new ::ROOT::Math::GSLRngGFSR4[nElements];
03866    }
03867    // Wrapper around operator delete
03868    static void delete_ROOTcLcLMathcLcLGSLRngGFSR4(void *p) {
03869       delete ((::ROOT::Math::GSLRngGFSR4*)p);
03870    }
03871    static void deleteArray_ROOTcLcLMathcLcLGSLRngGFSR4(void *p) {
03872       delete [] ((::ROOT::Math::GSLRngGFSR4*)p);
03873    }
03874    static void destruct_ROOTcLcLMathcLcLGSLRngGFSR4(void *p) {
03875       typedef ::ROOT::Math::GSLRngGFSR4 current_t;
03876       ((current_t*)p)->~current_t();
03877    }
03878 } // end of namespace ROOT for class ::ROOT::Math::GSLRngGFSR4
03879 
03880 //______________________________________________________________________________
03881 namespace ROOT {
03882    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR_ShowMembers(void *obj, TMemberInspector &R__insp)
03883    {
03884       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngMT>.
03885       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngMTgR ShadowClass;
03886       ShadowClass *sobj = (ShadowClass*)obj;
03887       if (sobj) { } // Dummy usage just in case there is no datamember.
03888 
03889       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)0x0)->GetClass();
03890       if (R__cl || R__insp.IsA()) { }
03891       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
03892       R__insp.InspectMember("ROOT::Math::GSLRngMT", (void*)&sobj->fEngine, "fEngine.", false);
03893    }
03894 
03895 }
03896 
03897 namespace ROOT {
03898    // Wrappers around operator new
03899    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p) {
03900       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngMT> : new ::ROOT::Math::Random<ROOT::Math::GSLRngMT>;
03901    }
03902    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(Long_t nElements, void *p) {
03903       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngMT>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngMT>[nElements];
03904    }
03905    // Wrapper around operator delete
03906    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p) {
03907       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)p);
03908    }
03909    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p) {
03910       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngMT>*)p);
03911    }
03912    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void *p) {
03913       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngMT> current_t;
03914       ((current_t*)p)->~current_t();
03915    }
03916 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngMT>
03917 
03918 //______________________________________________________________________________
03919 namespace ROOT {
03920    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR_ShowMembers(void *obj, TMemberInspector &R__insp)
03921    {
03922       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngTaus>.
03923       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngTausgR ShadowClass;
03924       ShadowClass *sobj = (ShadowClass*)obj;
03925       if (sobj) { } // Dummy usage just in case there is no datamember.
03926 
03927       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)0x0)->GetClass();
03928       if (R__cl || R__insp.IsA()) { }
03929       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
03930       R__insp.InspectMember("ROOT::Math::GSLRngTaus", (void*)&sobj->fEngine, "fEngine.", false);
03931    }
03932 
03933 }
03934 
03935 namespace ROOT {
03936    // Wrappers around operator new
03937    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p) {
03938       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngTaus> : new ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>;
03939    }
03940    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(Long_t nElements, void *p) {
03941       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>[nElements];
03942    }
03943    // Wrapper around operator delete
03944    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p) {
03945       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)p);
03946    }
03947    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p) {
03948       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)p);
03949    }
03950    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void *p) {
03951       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngTaus> current_t;
03952       ((current_t*)p)->~current_t();
03953    }
03954 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngTaus>
03955 
03956 //______________________________________________________________________________
03957 namespace ROOT {
03958    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR_ShowMembers(void *obj, TMemberInspector &R__insp)
03959    {
03960       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngRanLux>.
03961       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxgR ShadowClass;
03962       ShadowClass *sobj = (ShadowClass*)obj;
03963       if (sobj) { } // Dummy usage just in case there is no datamember.
03964 
03965       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)0x0)->GetClass();
03966       if (R__cl || R__insp.IsA()) { }
03967       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
03968       R__insp.InspectMember("ROOT::Math::GSLRngRanLux", (void*)&sobj->fEngine, "fEngine.", false);
03969    }
03970 
03971 }
03972 
03973 namespace ROOT {
03974    // Wrappers around operator new
03975    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p) {
03976       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux> : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>;
03977    }
03978    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(Long_t nElements, void *p) {
03979       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>[nElements];
03980    }
03981    // Wrapper around operator delete
03982    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p) {
03983       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)p);
03984    }
03985    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p) {
03986       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)p);
03987    }
03988    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void *p) {
03989       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux> current_t;
03990       ((current_t*)p)->~current_t();
03991    }
03992 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngRanLux>
03993 
03994 //______________________________________________________________________________
03995 namespace ROOT {
03996    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR_ShowMembers(void *obj, TMemberInspector &R__insp)
03997    {
03998       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>.
03999       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR ShadowClass;
04000       ShadowClass *sobj = (ShadowClass*)obj;
04001       if (sobj) { } // Dummy usage just in case there is no datamember.
04002 
04003       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)0x0)->GetClass();
04004       if (R__cl || R__insp.IsA()) { }
04005       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
04006       R__insp.InspectMember("ROOT::Math::GSLRngRanLuxS1", (void*)&sobj->fEngine, "fEngine.", false);
04007    }
04008 
04009 }
04010 
04011 namespace ROOT {
04012    // Wrappers around operator new
04013    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p) {
04014       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>;
04015    }
04016    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(Long_t nElements, void *p) {
04017       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>[nElements];
04018    }
04019    // Wrapper around operator delete
04020    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p) {
04021       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)p);
04022    }
04023    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p) {
04024       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)p);
04025    }
04026    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void *p) {
04027       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> current_t;
04028       ((current_t*)p)->~current_t();
04029    }
04030 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>
04031 
04032 //______________________________________________________________________________
04033 namespace ROOT {
04034    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR_ShowMembers(void *obj, TMemberInspector &R__insp)
04035    {
04036       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>.
04037       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR ShadowClass;
04038       ShadowClass *sobj = (ShadowClass*)obj;
04039       if (sobj) { } // Dummy usage just in case there is no datamember.
04040 
04041       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)0x0)->GetClass();
04042       if (R__cl || R__insp.IsA()) { }
04043       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
04044       R__insp.InspectMember("ROOT::Math::GSLRngRanLuxS2", (void*)&sobj->fEngine, "fEngine.", false);
04045    }
04046 
04047 }
04048 
04049 namespace ROOT {
04050    // Wrappers around operator new
04051    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p) {
04052       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>;
04053    }
04054    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(Long_t nElements, void *p) {
04055       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>[nElements];
04056    }
04057    // Wrapper around operator delete
04058    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p) {
04059       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)p);
04060    }
04061    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p) {
04062       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)p);
04063    }
04064    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void *p) {
04065       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> current_t;
04066       ((current_t*)p)->~current_t();
04067    }
04068 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>
04069 
04070 //______________________________________________________________________________
04071 namespace ROOT {
04072    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR_ShowMembers(void *obj, TMemberInspector &R__insp)
04073    {
04074       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>.
04075       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR ShadowClass;
04076       ShadowClass *sobj = (ShadowClass*)obj;
04077       if (sobj) { } // Dummy usage just in case there is no datamember.
04078 
04079       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)0x0)->GetClass();
04080       if (R__cl || R__insp.IsA()) { }
04081       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
04082       R__insp.InspectMember("ROOT::Math::GSLRngRanLuxD1", (void*)&sobj->fEngine, "fEngine.", false);
04083    }
04084 
04085 }
04086 
04087 namespace ROOT {
04088    // Wrappers around operator new
04089    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p) {
04090       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>;
04091    }
04092    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(Long_t nElements, void *p) {
04093       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>[nElements];
04094    }
04095    // Wrapper around operator delete
04096    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p) {
04097       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)p);
04098    }
04099    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p) {
04100       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)p);
04101    }
04102    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void *p) {
04103       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> current_t;
04104       ((current_t*)p)->~current_t();
04105    }
04106 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>
04107 
04108 //______________________________________________________________________________
04109 namespace ROOT {
04110    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR_ShowMembers(void *obj, TMemberInspector &R__insp)
04111    {
04112       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>.
04113       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR ShadowClass;
04114       ShadowClass *sobj = (ShadowClass*)obj;
04115       if (sobj) { } // Dummy usage just in case there is no datamember.
04116 
04117       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)0x0)->GetClass();
04118       if (R__cl || R__insp.IsA()) { }
04119       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
04120       R__insp.InspectMember("ROOT::Math::GSLRngRanLuxD2", (void*)&sobj->fEngine, "fEngine.", false);
04121    }
04122 
04123 }
04124 
04125 namespace ROOT {
04126    // Wrappers around operator new
04127    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p) {
04128       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>;
04129    }
04130    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(Long_t nElements, void *p) {
04131       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>[nElements];
04132    }
04133    // Wrapper around operator delete
04134    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p) {
04135       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)p);
04136    }
04137    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p) {
04138       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)p);
04139    }
04140    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void *p) {
04141       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> current_t;
04142       ((current_t*)p)->~current_t();
04143    }
04144 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>
04145 
04146 //______________________________________________________________________________
04147 namespace ROOT {
04148    void ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR_ShowMembers(void *obj, TMemberInspector &R__insp)
04149    {
04150       // Inspect the data members of an object of class ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>.
04151       typedef ::ROOT::Shadow::ROOT::Math::RandomlEROOTcLcLMathcLcLGSLRngGFSR4gR ShadowClass;
04152       ShadowClass *sobj = (ShadowClass*)obj;
04153       if (sobj) { } // Dummy usage just in case there is no datamember.
04154 
04155       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)0x0)->GetClass();
04156       if (R__cl || R__insp.IsA()) { }
04157       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEngine", (void*)&sobj->fEngine);
04158       R__insp.InspectMember("ROOT::Math::GSLRngGFSR4", (void*)&sobj->fEngine, "fEngine.", false);
04159    }
04160 
04161 }
04162 
04163 namespace ROOT {
04164    // Wrappers around operator new
04165    static void *new_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p) {
04166       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> : new ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>;
04167    }
04168    static void *newArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(Long_t nElements, void *p) {
04169       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>[nElements] : new ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>[nElements];
04170    }
04171    // Wrapper around operator delete
04172    static void delete_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p) {
04173       delete ((::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)p);
04174    }
04175    static void deleteArray_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p) {
04176       delete [] ((::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)p);
04177    }
04178    static void destruct_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void *p) {
04179       typedef ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> current_t;
04180       ((current_t*)p)->~current_t();
04181    }
04182 } // end of namespace ROOT for class ::ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>
04183 
04184 //______________________________________________________________________________
04185 namespace ROOT {
04186    void ROOTcLcLMathcLcLKelvinFunctions_ShowMembers(void *obj, TMemberInspector &R__insp)
04187    {
04188       // Inspect the data members of an object of class ROOT::Math::KelvinFunctions.
04189       typedef ::ROOT::Shadow::ROOT::Math::KelvinFunctions ShadowClass;
04190       ShadowClass *sobj = (ShadowClass*)obj;
04191       if (sobj) { } // Dummy usage just in case there is no datamember.
04192 
04193       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::KelvinFunctions*)0x0)->GetClass();
04194       if (R__cl || R__insp.IsA()) { }
04195    }
04196 
04197 }
04198 
04199 namespace ROOT {
04200    // Wrappers around operator new
04201    static void *new_ROOTcLcLMathcLcLKelvinFunctions(void *p) {
04202       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::KelvinFunctions : new ::ROOT::Math::KelvinFunctions;
04203    }
04204    static void *newArray_ROOTcLcLMathcLcLKelvinFunctions(Long_t nElements, void *p) {
04205       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::KelvinFunctions[nElements] : new ::ROOT::Math::KelvinFunctions[nElements];
04206    }
04207    // Wrapper around operator delete
04208    static void delete_ROOTcLcLMathcLcLKelvinFunctions(void *p) {
04209       delete ((::ROOT::Math::KelvinFunctions*)p);
04210    }
04211    static void deleteArray_ROOTcLcLMathcLcLKelvinFunctions(void *p) {
04212       delete [] ((::ROOT::Math::KelvinFunctions*)p);
04213    }
04214    static void destruct_ROOTcLcLMathcLcLKelvinFunctions(void *p) {
04215       typedef ::ROOT::Math::KelvinFunctions current_t;
04216       ((current_t*)p)->~current_t();
04217    }
04218 } // end of namespace ROOT for class ::ROOT::Math::KelvinFunctions
04219 
04220 //______________________________________________________________________________
04221 namespace ROOT {
04222    void ROOTcLcLMathcLcLGSLMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp)
04223    {
04224       // Inspect the data members of an object of class ROOT::Math::GSLMinimizer.
04225       typedef ::ROOT::Shadow::ROOT::Math::GSLMinimizer ShadowClass;
04226       ShadowClass *sobj = (ShadowClass*)obj;
04227       if (sobj) { } // Dummy usage just in case there is no datamember.
04228 
04229       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLMinimizer*)0x0)->GetClass();
04230       if (R__cl || R__insp.IsA()) { }
04231       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &sobj->fDim);
04232       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGSLMultiMin", &sobj->fGSLMultiMin);
04233       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjFunc", &sobj->fObjFunc);
04234       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinVal", &sobj->fMinVal);
04235       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLSTolerance", &sobj->fLSTolerance);
04236       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValues", (void*)&sobj->fValues);
04237       R__insp.InspectMember("vector<double>", (void*)&sobj->fValues, "fValues.", false);
04238       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSteps", (void*)&sobj->fSteps);
04239       R__insp.InspectMember("vector<double>", (void*)&sobj->fSteps, "fSteps.", false);
04240       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNames", (void*)&sobj->fNames);
04241       R__insp.InspectMember("vector<std::string>", (void*)&sobj->fNames, "fNames.", false);
04242       R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarTypes", (void*)&sobj->fVarTypes);
04243       R__insp.InspectMember("vector<ROOT::Math::EMinimVariableType>", (void*)&sobj->fVarTypes, "fVarTypes.", false);
04244       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBounds", (void*)&sobj->fBounds);
04245       R__insp.InspectMember("map<unsigned int,std::pair<double,double> >", (void*)&sobj->fBounds, "fBounds.", false);
04246       R__insp.GenericShowMembers("ROOT::Math::Minimizer", ( ::ROOT::Math::Minimizer * )( (::ROOT::Math::GSLMinimizer*) obj ), false);
04247    }
04248 
04249 }
04250 
04251 namespace ROOT {
04252    // Wrappers around operator new
04253    static void *new_ROOTcLcLMathcLcLGSLMinimizer(void *p) {
04254       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLMinimizer : new ::ROOT::Math::GSLMinimizer;
04255    }
04256    static void *newArray_ROOTcLcLMathcLcLGSLMinimizer(Long_t nElements, void *p) {
04257       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLMinimizer[nElements] : new ::ROOT::Math::GSLMinimizer[nElements];
04258    }
04259    // Wrapper around operator delete
04260    static void delete_ROOTcLcLMathcLcLGSLMinimizer(void *p) {
04261       delete ((::ROOT::Math::GSLMinimizer*)p);
04262    }
04263    static void deleteArray_ROOTcLcLMathcLcLGSLMinimizer(void *p) {
04264       delete [] ((::ROOT::Math::GSLMinimizer*)p);
04265    }
04266    static void destruct_ROOTcLcLMathcLcLGSLMinimizer(void *p) {
04267       typedef ::ROOT::Math::GSLMinimizer current_t;
04268       ((current_t*)p)->~current_t();
04269    }
04270 } // end of namespace ROOT for class ::ROOT::Math::GSLMinimizer
04271 
04272 //______________________________________________________________________________
04273 namespace ROOT {
04274    void ROOTcLcLMathcLcLGSLSimAnMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp)
04275    {
04276       // Inspect the data members of an object of class ROOT::Math::GSLSimAnMinimizer.
04277       typedef ::ROOT::Shadow::ROOT::Math::GSLSimAnMinimizer ShadowClass;
04278       ShadowClass *sobj = (ShadowClass*)obj;
04279       if (sobj) { } // Dummy usage just in case there is no datamember.
04280 
04281       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnMinimizer*)0x0)->GetClass();
04282       if (R__cl || R__insp.IsA()) { }
04283       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &sobj->fDim);
04284       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnFunc", &sobj->fOwnFunc);
04285       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSolver", (void*)&sobj->fSolver);
04286       R__insp.InspectMember("ROOT::Math::GSLSimAnnealing", (void*)&sobj->fSolver, "fSolver.", false);
04287       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjFunc", &sobj->fObjFunc);
04288       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinVal", &sobj->fMinVal);
04289       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValues", (void*)&sobj->fValues);
04290       R__insp.InspectMember("vector<double>", (void*)&sobj->fValues, "fValues.", false);
04291       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSteps", (void*)&sobj->fSteps);
04292       R__insp.InspectMember("vector<double>", (void*)&sobj->fSteps, "fSteps.", false);
04293       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNames", (void*)&sobj->fNames);
04294       R__insp.InspectMember("vector<std::string>", (void*)&sobj->fNames, "fNames.", false);
04295       R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarTypes", (void*)&sobj->fVarTypes);
04296       R__insp.InspectMember("vector<ROOT::Math::EMinimVariableType>", (void*)&sobj->fVarTypes, "fVarTypes.", false);
04297       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBounds", (void*)&sobj->fBounds);
04298       R__insp.InspectMember("map<unsigned int,std::pair<double,double> >", (void*)&sobj->fBounds, "fBounds.", false);
04299       R__insp.GenericShowMembers("ROOT::Math::Minimizer", ( ::ROOT::Math::Minimizer * )( (::ROOT::Math::GSLSimAnMinimizer*) obj ), false);
04300    }
04301 
04302 }
04303 
04304 namespace ROOT {
04305    // Wrappers around operator new
04306    static void *new_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p) {
04307       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLSimAnMinimizer : new ::ROOT::Math::GSLSimAnMinimizer;
04308    }
04309    static void *newArray_ROOTcLcLMathcLcLGSLSimAnMinimizer(Long_t nElements, void *p) {
04310       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLSimAnMinimizer[nElements] : new ::ROOT::Math::GSLSimAnMinimizer[nElements];
04311    }
04312    // Wrapper around operator delete
04313    static void delete_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p) {
04314       delete ((::ROOT::Math::GSLSimAnMinimizer*)p);
04315    }
04316    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p) {
04317       delete [] ((::ROOT::Math::GSLSimAnMinimizer*)p);
04318    }
04319    static void destruct_ROOTcLcLMathcLcLGSLSimAnMinimizer(void *p) {
04320       typedef ::ROOT::Math::GSLSimAnMinimizer current_t;
04321       ((current_t*)p)->~current_t();
04322    }
04323 } // end of namespace ROOT for class ::ROOT::Math::GSLSimAnMinimizer
04324 
04325 //______________________________________________________________________________
04326 namespace ROOT {
04327    void ROOTcLcLMathcLcLGSLSimAnFunc_ShowMembers(void *obj, TMemberInspector &R__insp)
04328    {
04329       // Inspect the data members of an object of class ROOT::Math::GSLSimAnFunc.
04330       typedef ::ROOT::Shadow::ROOT::Math::GSLSimAnFunc ShadowClass;
04331       ShadowClass *sobj = (ShadowClass*)obj;
04332       if (sobj) { } // Dummy usage just in case there is no datamember.
04333 
04334       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnFunc*)0x0)->GetClass();
04335       if (R__cl || R__insp.IsA()) { }
04336       R__insp.Inspect(R__cl, R__insp.GetParent(), "fX", (void*)&sobj->fX);
04337       R__insp.InspectMember("vector<double>", (void*)&sobj->fX, "fX.", false);
04338       R__insp.Inspect(R__cl, R__insp.GetParent(), "fScale", (void*)&sobj->fScale);
04339       R__insp.InspectMember("vector<double>", (void*)&sobj->fScale, "fScale.", false);
04340       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunc", &sobj->fFunc);
04341    }
04342 
04343 }
04344 
04345 namespace ROOT {
04346    // Wrapper around operator delete
04347    static void delete_ROOTcLcLMathcLcLGSLSimAnFunc(void *p) {
04348       delete ((::ROOT::Math::GSLSimAnFunc*)p);
04349    }
04350    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnFunc(void *p) {
04351       delete [] ((::ROOT::Math::GSLSimAnFunc*)p);
04352    }
04353    static void destruct_ROOTcLcLMathcLcLGSLSimAnFunc(void *p) {
04354       typedef ::ROOT::Math::GSLSimAnFunc current_t;
04355       ((current_t*)p)->~current_t();
04356    }
04357 } // end of namespace ROOT for class ::ROOT::Math::GSLSimAnFunc
04358 
04359 //______________________________________________________________________________
04360 namespace ROOT {
04361    void ROOTcLcLMathcLcLGSLSimAnParams_ShowMembers(void *obj, TMemberInspector &R__insp)
04362    {
04363       // Inspect the data members of an object of class ROOT::Math::GSLSimAnParams.
04364       typedef ::ROOT::Shadow::ROOT::Math::GSLSimAnParams ShadowClass;
04365       ShadowClass *sobj = (ShadowClass*)obj;
04366       if (sobj) { } // Dummy usage just in case there is no datamember.
04367 
04368       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnParams*)0x0)->GetClass();
04369       if (R__cl || R__insp.IsA()) { }
04370       R__insp.Inspect(R__cl, R__insp.GetParent(), "n_tries", &sobj->n_tries);
04371       R__insp.Inspect(R__cl, R__insp.GetParent(), "iters_fixed_T", &sobj->iters_fixed_T);
04372       R__insp.Inspect(R__cl, R__insp.GetParent(), "step_size", &sobj->step_size);
04373       R__insp.Inspect(R__cl, R__insp.GetParent(), "k", &sobj->k);
04374       R__insp.Inspect(R__cl, R__insp.GetParent(), "t_initial", &sobj->t_initial);
04375       R__insp.Inspect(R__cl, R__insp.GetParent(), "mu", &sobj->mu);
04376       R__insp.Inspect(R__cl, R__insp.GetParent(), "t_min", &sobj->t_min);
04377    }
04378 
04379 }
04380 
04381 namespace ROOT {
04382    // Wrappers around operator new
04383    static void *new_ROOTcLcLMathcLcLGSLSimAnParams(void *p) {
04384       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLSimAnParams : new ::ROOT::Math::GSLSimAnParams;
04385    }
04386    static void *newArray_ROOTcLcLMathcLcLGSLSimAnParams(Long_t nElements, void *p) {
04387       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLSimAnParams[nElements] : new ::ROOT::Math::GSLSimAnParams[nElements];
04388    }
04389    // Wrapper around operator delete
04390    static void delete_ROOTcLcLMathcLcLGSLSimAnParams(void *p) {
04391       delete ((::ROOT::Math::GSLSimAnParams*)p);
04392    }
04393    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnParams(void *p) {
04394       delete [] ((::ROOT::Math::GSLSimAnParams*)p);
04395    }
04396    static void destruct_ROOTcLcLMathcLcLGSLSimAnParams(void *p) {
04397       typedef ::ROOT::Math::GSLSimAnParams current_t;
04398       ((current_t*)p)->~current_t();
04399    }
04400 } // end of namespace ROOT for class ::ROOT::Math::GSLSimAnParams
04401 
04402 //______________________________________________________________________________
04403 namespace ROOT {
04404    void ROOTcLcLMathcLcLGSLSimAnnealing_ShowMembers(void *obj, TMemberInspector &R__insp)
04405    {
04406       // Inspect the data members of an object of class ROOT::Math::GSLSimAnnealing.
04407       typedef ::ROOT::Shadow::ROOT::Math::GSLSimAnnealing ShadowClass;
04408       ShadowClass *sobj = (ShadowClass*)obj;
04409       if (sobj) { } // Dummy usage just in case there is no datamember.
04410 
04411       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLSimAnnealing*)0x0)->GetClass();
04412       if (R__cl || R__insp.IsA()) { }
04413       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParams", (void*)&sobj->fParams);
04414       R__insp.InspectMember("ROOT::Math::GSLSimAnParams", (void*)&sobj->fParams, "fParams.", false);
04415    }
04416 
04417 }
04418 
04419 namespace ROOT {
04420    // Wrappers around operator new
04421    static void *new_ROOTcLcLMathcLcLGSLSimAnnealing(void *p) {
04422       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLSimAnnealing : new ::ROOT::Math::GSLSimAnnealing;
04423    }
04424    static void *newArray_ROOTcLcLMathcLcLGSLSimAnnealing(Long_t nElements, void *p) {
04425       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLSimAnnealing[nElements] : new ::ROOT::Math::GSLSimAnnealing[nElements];
04426    }
04427    // Wrapper around operator delete
04428    static void delete_ROOTcLcLMathcLcLGSLSimAnnealing(void *p) {
04429       delete ((::ROOT::Math::GSLSimAnnealing*)p);
04430    }
04431    static void deleteArray_ROOTcLcLMathcLcLGSLSimAnnealing(void *p) {
04432       delete [] ((::ROOT::Math::GSLSimAnnealing*)p);
04433    }
04434    static void destruct_ROOTcLcLMathcLcLGSLSimAnnealing(void *p) {
04435       typedef ::ROOT::Math::GSLSimAnnealing current_t;
04436       ((current_t*)p)->~current_t();
04437    }
04438 } // end of namespace ROOT for class ::ROOT::Math::GSLSimAnnealing
04439 
04440 namespace ROOT {
04441    // Wrappers around operator new
04442    static void *new_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p) {
04443       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLNLSMinimizer : new ::ROOT::Math::GSLNLSMinimizer;
04444    }
04445    static void *newArray_ROOTcLcLMathcLcLGSLNLSMinimizer(Long_t nElements, void *p) {
04446       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLNLSMinimizer[nElements] : new ::ROOT::Math::GSLNLSMinimizer[nElements];
04447    }
04448    // Wrapper around operator delete
04449    static void delete_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p) {
04450       delete ((::ROOT::Math::GSLNLSMinimizer*)p);
04451    }
04452    static void deleteArray_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p) {
04453       delete [] ((::ROOT::Math::GSLNLSMinimizer*)p);
04454    }
04455    static void destruct_ROOTcLcLMathcLcLGSLNLSMinimizer(void *p) {
04456       typedef ::ROOT::Math::GSLNLSMinimizer current_t;
04457       ((current_t*)p)->~current_t();
04458    }
04459 } // end of namespace ROOT for class ::ROOT::Math::GSLNLSMinimizer
04460 
04461 namespace ROOT {
04462    // Wrappers around operator new
04463    static void *new_ROOTcLcLMathcLcLLSResidualFunc(void *p) {
04464       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::LSResidualFunc : new ::ROOT::Math::LSResidualFunc;
04465    }
04466    static void *newArray_ROOTcLcLMathcLcLLSResidualFunc(Long_t nElements, void *p) {
04467       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::LSResidualFunc[nElements] : new ::ROOT::Math::LSResidualFunc[nElements];
04468    }
04469    // Wrapper around operator delete
04470    static void delete_ROOTcLcLMathcLcLLSResidualFunc(void *p) {
04471       delete ((::ROOT::Math::LSResidualFunc*)p);
04472    }
04473    static void deleteArray_ROOTcLcLMathcLcLLSResidualFunc(void *p) {
04474       delete [] ((::ROOT::Math::LSResidualFunc*)p);
04475    }
04476    static void destruct_ROOTcLcLMathcLcLLSResidualFunc(void *p) {
04477       typedef ::ROOT::Math::LSResidualFunc current_t;
04478       ((current_t*)p)->~current_t();
04479    }
04480 } // end of namespace ROOT for class ::ROOT::Math::LSResidualFunc
04481 
04482 //______________________________________________________________________________
04483 namespace ROOT {
04484    void ROOTcLcLMathcLcLGSLMCIntegrator_ShowMembers(void *obj, TMemberInspector &R__insp)
04485    {
04486       // Inspect the data members of an object of class ROOT::Math::GSLMCIntegrator.
04487       typedef ::ROOT::Shadow::ROOT::Math::GSLMCIntegrator ShadowClass;
04488       ShadowClass *sobj = (ShadowClass*)obj;
04489       if (sobj) { } // Dummy usage just in case there is no datamember.
04490 
04491       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLMCIntegrator*)0x0)->GetClass();
04492       if (R__cl || R__insp.IsA()) { }
04493       R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &sobj->fType);
04494       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRng", &sobj->fRng);
04495       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &sobj->fDim);
04496       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCalls", &sobj->fCalls);
04497       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAbsTol", &sobj->fAbsTol);
04498       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRelTol", &sobj->fRelTol);
04499       R__insp.Inspect(R__cl, R__insp.GetParent(), "fResult", &sobj->fResult);
04500       R__insp.Inspect(R__cl, R__insp.GetParent(), "fError", &sobj->fError);
04501       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &sobj->fStatus);
04502       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkspace", &sobj->fWorkspace);
04503       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &sobj->fFunction);
04504       R__insp.GenericShowMembers("ROOT::Math::VirtualIntegratorMultiDim", ( ::ROOT::Math::VirtualIntegratorMultiDim * )( (::ROOT::Math::GSLMCIntegrator*) obj ), false);
04505    }
04506 
04507 }
04508 
04509 namespace ROOT {
04510    // Wrappers around operator new
04511    static void *new_ROOTcLcLMathcLcLGSLMCIntegrator(void *p) {
04512       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLMCIntegrator : new ::ROOT::Math::GSLMCIntegrator;
04513    }
04514    static void *newArray_ROOTcLcLMathcLcLGSLMCIntegrator(Long_t nElements, void *p) {
04515       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLMCIntegrator[nElements] : new ::ROOT::Math::GSLMCIntegrator[nElements];
04516    }
04517    // Wrapper around operator delete
04518    static void delete_ROOTcLcLMathcLcLGSLMCIntegrator(void *p) {
04519       delete ((::ROOT::Math::GSLMCIntegrator*)p);
04520    }
04521    static void deleteArray_ROOTcLcLMathcLcLGSLMCIntegrator(void *p) {
04522       delete [] ((::ROOT::Math::GSLMCIntegrator*)p);
04523    }
04524    static void destruct_ROOTcLcLMathcLcLGSLMCIntegrator(void *p) {
04525       typedef ::ROOT::Math::GSLMCIntegrator current_t;
04526       ((current_t*)p)->~current_t();
04527    }
04528 } // end of namespace ROOT for class ::ROOT::Math::GSLMCIntegrator
04529 
04530 //______________________________________________________________________________
04531 namespace ROOT {
04532    void ROOTcLcLMathcLcLVegasParameters_ShowMembers(void *obj, TMemberInspector &R__insp)
04533    {
04534       // Inspect the data members of an object of class ROOT::Math::VegasParameters.
04535       typedef ::ROOT::Shadow::ROOT::Math::VegasParameters ShadowClass;
04536       ShadowClass *sobj = (ShadowClass*)obj;
04537       if (sobj) { } // Dummy usage just in case there is no datamember.
04538 
04539       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::VegasParameters*)0x0)->GetClass();
04540       if (R__cl || R__insp.IsA()) { }
04541       R__insp.Inspect(R__cl, R__insp.GetParent(), "alpha", &sobj->alpha);
04542       R__insp.Inspect(R__cl, R__insp.GetParent(), "iterations", &sobj->iterations);
04543       R__insp.Inspect(R__cl, R__insp.GetParent(), "stage", &sobj->stage);
04544       R__insp.Inspect(R__cl, R__insp.GetParent(), "mode", &sobj->mode);
04545       R__insp.Inspect(R__cl, R__insp.GetParent(), "verbose", &sobj->verbose);
04546    }
04547 
04548 }
04549 
04550 namespace ROOT {
04551    // Wrappers around operator new
04552    static void *new_ROOTcLcLMathcLcLVegasParameters(void *p) {
04553       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VegasParameters : new ::ROOT::Math::VegasParameters;
04554    }
04555    static void *newArray_ROOTcLcLMathcLcLVegasParameters(Long_t nElements, void *p) {
04556       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::VegasParameters[nElements] : new ::ROOT::Math::VegasParameters[nElements];
04557    }
04558    // Wrapper around operator delete
04559    static void delete_ROOTcLcLMathcLcLVegasParameters(void *p) {
04560       delete ((::ROOT::Math::VegasParameters*)p);
04561    }
04562    static void deleteArray_ROOTcLcLMathcLcLVegasParameters(void *p) {
04563       delete [] ((::ROOT::Math::VegasParameters*)p);
04564    }
04565    static void destruct_ROOTcLcLMathcLcLVegasParameters(void *p) {
04566       typedef ::ROOT::Math::VegasParameters current_t;
04567       ((current_t*)p)->~current_t();
04568    }
04569 } // end of namespace ROOT for class ::ROOT::Math::VegasParameters
04570 
04571 //______________________________________________________________________________
04572 namespace ROOT {
04573    void ROOTcLcLMathcLcLMiserParameters_ShowMembers(void *obj, TMemberInspector &R__insp)
04574    {
04575       // Inspect the data members of an object of class ROOT::Math::MiserParameters.
04576       typedef ::ROOT::Shadow::ROOT::Math::MiserParameters ShadowClass;
04577       ShadowClass *sobj = (ShadowClass*)obj;
04578       if (sobj) { } // Dummy usage just in case there is no datamember.
04579 
04580       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::MiserParameters*)0x0)->GetClass();
04581       if (R__cl || R__insp.IsA()) { }
04582       R__insp.Inspect(R__cl, R__insp.GetParent(), "estimate_frac", &sobj->estimate_frac);
04583       R__insp.Inspect(R__cl, R__insp.GetParent(), "min_calls", &sobj->min_calls);
04584       R__insp.Inspect(R__cl, R__insp.GetParent(), "min_calls_per_bisection", &sobj->min_calls_per_bisection);
04585       R__insp.Inspect(R__cl, R__insp.GetParent(), "alpha", &sobj->alpha);
04586       R__insp.Inspect(R__cl, R__insp.GetParent(), "dither", &sobj->dither);
04587    }
04588 
04589 }
04590 
04591 namespace ROOT {
04592    // Wrappers around operator new
04593    static void *new_ROOTcLcLMathcLcLMiserParameters(void *p) {
04594       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::MiserParameters : new ::ROOT::Math::MiserParameters;
04595    }
04596    static void *newArray_ROOTcLcLMathcLcLMiserParameters(Long_t nElements, void *p) {
04597       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::MiserParameters[nElements] : new ::ROOT::Math::MiserParameters[nElements];
04598    }
04599    // Wrapper around operator delete
04600    static void delete_ROOTcLcLMathcLcLMiserParameters(void *p) {
04601       delete ((::ROOT::Math::MiserParameters*)p);
04602    }
04603    static void deleteArray_ROOTcLcLMathcLcLMiserParameters(void *p) {
04604       delete [] ((::ROOT::Math::MiserParameters*)p);
04605    }
04606    static void destruct_ROOTcLcLMathcLcLMiserParameters(void *p) {
04607       typedef ::ROOT::Math::MiserParameters current_t;
04608       ((current_t*)p)->~current_t();
04609    }
04610 } // end of namespace ROOT for class ::ROOT::Math::MiserParameters
04611 
04612 //______________________________________________________________________________
04613 namespace ROOT {
04614    void ROOTcLcLMathcLcLGSLRootFinder_ShowMembers(void *obj, TMemberInspector &R__insp)
04615    {
04616       // Inspect the data members of an object of class ROOT::Math::GSLRootFinder.
04617       typedef ::ROOT::Shadow::ROOT::Math::GSLRootFinder ShadowClass;
04618       ShadowClass *sobj = (ShadowClass*)obj;
04619       if (sobj) { } // Dummy usage just in case there is no datamember.
04620 
04621       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRootFinder*)0x0)->GetClass();
04622       if (R__cl || R__insp.IsA()) { }
04623       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &sobj->fFunction);
04624       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fS", &sobj->fS);
04625       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRoot", &sobj->fRoot);
04626       R__insp.Inspect(R__cl, R__insp.GetParent(), "fXlow", &sobj->fXlow);
04627       R__insp.Inspect(R__cl, R__insp.GetParent(), "fXup", &sobj->fXup);
04628       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", &sobj->fIter);
04629       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &sobj->fStatus);
04630       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValidInterval", &sobj->fValidInterval);
04631       R__insp.GenericShowMembers("ROOT::Math::IRootFinderMethod", ( ::ROOT::Math::IRootFinderMethod * )( (::ROOT::Math::GSLRootFinder*) obj ), false);
04632    }
04633 
04634 }
04635 
04636 namespace ROOT {
04637    // Wrappers around operator new
04638    static void *new_ROOTcLcLMathcLcLGSLRootFinder(void *p) {
04639       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRootFinder : new ::ROOT::Math::GSLRootFinder;
04640    }
04641    static void *newArray_ROOTcLcLMathcLcLGSLRootFinder(Long_t nElements, void *p) {
04642       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRootFinder[nElements] : new ::ROOT::Math::GSLRootFinder[nElements];
04643    }
04644    // Wrapper around operator delete
04645    static void delete_ROOTcLcLMathcLcLGSLRootFinder(void *p) {
04646       delete ((::ROOT::Math::GSLRootFinder*)p);
04647    }
04648    static void deleteArray_ROOTcLcLMathcLcLGSLRootFinder(void *p) {
04649       delete [] ((::ROOT::Math::GSLRootFinder*)p);
04650    }
04651    static void destruct_ROOTcLcLMathcLcLGSLRootFinder(void *p) {
04652       typedef ::ROOT::Math::GSLRootFinder current_t;
04653       ((current_t*)p)->~current_t();
04654    }
04655 } // end of namespace ROOT for class ::ROOT::Math::GSLRootFinder
04656 
04657 //______________________________________________________________________________
04658 namespace ROOT {
04659    void ROOTcLcLMathcLcLGSLRootFinderDeriv_ShowMembers(void *obj, TMemberInspector &R__insp)
04660    {
04661       // Inspect the data members of an object of class ROOT::Math::GSLRootFinderDeriv.
04662       typedef ::ROOT::Shadow::ROOT::Math::GSLRootFinderDeriv ShadowClass;
04663       ShadowClass *sobj = (ShadowClass*)obj;
04664       if (sobj) { } // Dummy usage just in case there is no datamember.
04665 
04666       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::GSLRootFinderDeriv*)0x0)->GetClass();
04667       if (R__cl || R__insp.IsA()) { }
04668       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFunction", &sobj->fFunction);
04669       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fS", &sobj->fS);
04670       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRoot", &sobj->fRoot);
04671       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrevRoot", &sobj->fPrevRoot);
04672       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", &sobj->fIter);
04673       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &sobj->fStatus);
04674       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValidPoint", &sobj->fValidPoint);
04675       R__insp.GenericShowMembers("ROOT::Math::IRootFinderMethod", ( ::ROOT::Math::IRootFinderMethod * )( (::ROOT::Math::GSLRootFinderDeriv*) obj ), false);
04676    }
04677 
04678 }
04679 
04680 namespace ROOT {
04681    // Wrappers around operator new
04682    static void *new_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p) {
04683       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRootFinderDeriv : new ::ROOT::Math::GSLRootFinderDeriv;
04684    }
04685    static void *newArray_ROOTcLcLMathcLcLGSLRootFinderDeriv(Long_t nElements, void *p) {
04686       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::GSLRootFinderDeriv[nElements] : new ::ROOT::Math::GSLRootFinderDeriv[nElements];
04687    }
04688    // Wrapper around operator delete
04689    static void delete_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p) {
04690       delete ((::ROOT::Math::GSLRootFinderDeriv*)p);
04691    }
04692    static void deleteArray_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p) {
04693       delete [] ((::ROOT::Math::GSLRootFinderDeriv*)p);
04694    }
04695    static void destruct_ROOTcLcLMathcLcLGSLRootFinderDeriv(void *p) {
04696       typedef ::ROOT::Math::GSLRootFinderDeriv current_t;
04697       ((current_t*)p)->~current_t();
04698    }
04699 } // end of namespace ROOT for class ::ROOT::Math::GSLRootFinderDeriv
04700 
04701 //______________________________________________________________________________
04702 namespace ROOT {
04703    void ROOTcLcLMathcLcLRootscLcLBisection_ShowMembers(void *obj, TMemberInspector &R__insp)
04704    {
04705       // Inspect the data members of an object of class ROOT::Math::Roots::Bisection.
04706       typedef ::ROOT::Shadow::ROOT::Math::Roots::Bisection ShadowClass;
04707       ShadowClass *sobj = (ShadowClass*)obj;
04708       if (sobj) { } // Dummy usage just in case there is no datamember.
04709 
04710       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Bisection*)0x0)->GetClass();
04711       if (R__cl || R__insp.IsA()) { }
04712       R__insp.GenericShowMembers("ROOT::Math::GSLRootFinder", ( ::ROOT::Math::GSLRootFinder * )( (::ROOT::Math::Roots::Bisection*) obj ), false);
04713    }
04714 
04715 }
04716 
04717 namespace ROOT {
04718    // Wrappers around operator new
04719    static void *new_ROOTcLcLMathcLcLRootscLcLBisection(void *p) {
04720       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Bisection : new ::ROOT::Math::Roots::Bisection;
04721    }
04722    static void *newArray_ROOTcLcLMathcLcLRootscLcLBisection(Long_t nElements, void *p) {
04723       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Bisection[nElements] : new ::ROOT::Math::Roots::Bisection[nElements];
04724    }
04725    // Wrapper around operator delete
04726    static void delete_ROOTcLcLMathcLcLRootscLcLBisection(void *p) {
04727       delete ((::ROOT::Math::Roots::Bisection*)p);
04728    }
04729    static void deleteArray_ROOTcLcLMathcLcLRootscLcLBisection(void *p) {
04730       delete [] ((::ROOT::Math::Roots::Bisection*)p);
04731    }
04732    static void destruct_ROOTcLcLMathcLcLRootscLcLBisection(void *p) {
04733       typedef ::ROOT::Math::Roots::Bisection current_t;
04734       ((current_t*)p)->~current_t();
04735    }
04736 } // end of namespace ROOT for class ::ROOT::Math::Roots::Bisection
04737 
04738 //______________________________________________________________________________
04739 namespace ROOT {
04740    void ROOTcLcLMathcLcLRootscLcLFalsePos_ShowMembers(void *obj, TMemberInspector &R__insp)
04741    {
04742       // Inspect the data members of an object of class ROOT::Math::Roots::FalsePos.
04743       typedef ::ROOT::Shadow::ROOT::Math::Roots::FalsePos ShadowClass;
04744       ShadowClass *sobj = (ShadowClass*)obj;
04745       if (sobj) { } // Dummy usage just in case there is no datamember.
04746 
04747       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::FalsePos*)0x0)->GetClass();
04748       if (R__cl || R__insp.IsA()) { }
04749       R__insp.GenericShowMembers("ROOT::Math::GSLRootFinder", ( ::ROOT::Math::GSLRootFinder * )( (::ROOT::Math::Roots::FalsePos*) obj ), false);
04750    }
04751 
04752 }
04753 
04754 namespace ROOT {
04755    // Wrappers around operator new
04756    static void *new_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p) {
04757       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::FalsePos : new ::ROOT::Math::Roots::FalsePos;
04758    }
04759    static void *newArray_ROOTcLcLMathcLcLRootscLcLFalsePos(Long_t nElements, void *p) {
04760       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::FalsePos[nElements] : new ::ROOT::Math::Roots::FalsePos[nElements];
04761    }
04762    // Wrapper around operator delete
04763    static void delete_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p) {
04764       delete ((::ROOT::Math::Roots::FalsePos*)p);
04765    }
04766    static void deleteArray_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p) {
04767       delete [] ((::ROOT::Math::Roots::FalsePos*)p);
04768    }
04769    static void destruct_ROOTcLcLMathcLcLRootscLcLFalsePos(void *p) {
04770       typedef ::ROOT::Math::Roots::FalsePos current_t;
04771       ((current_t*)p)->~current_t();
04772    }
04773 } // end of namespace ROOT for class ::ROOT::Math::Roots::FalsePos
04774 
04775 //______________________________________________________________________________
04776 namespace ROOT {
04777    void ROOTcLcLMathcLcLRootscLcLBrent_ShowMembers(void *obj, TMemberInspector &R__insp)
04778    {
04779       // Inspect the data members of an object of class ROOT::Math::Roots::Brent.
04780       typedef ::ROOT::Shadow::ROOT::Math::Roots::Brent ShadowClass;
04781       ShadowClass *sobj = (ShadowClass*)obj;
04782       if (sobj) { } // Dummy usage just in case there is no datamember.
04783 
04784       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Brent*)0x0)->GetClass();
04785       if (R__cl || R__insp.IsA()) { }
04786       R__insp.GenericShowMembers("ROOT::Math::GSLRootFinder", ( ::ROOT::Math::GSLRootFinder * )( (::ROOT::Math::Roots::Brent*) obj ), false);
04787    }
04788 
04789 }
04790 
04791 namespace ROOT {
04792    // Wrappers around operator new
04793    static void *new_ROOTcLcLMathcLcLRootscLcLBrent(void *p) {
04794       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Brent : new ::ROOT::Math::Roots::Brent;
04795    }
04796    static void *newArray_ROOTcLcLMathcLcLRootscLcLBrent(Long_t nElements, void *p) {
04797       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Brent[nElements] : new ::ROOT::Math::Roots::Brent[nElements];
04798    }
04799    // Wrapper around operator delete
04800    static void delete_ROOTcLcLMathcLcLRootscLcLBrent(void *p) {
04801       delete ((::ROOT::Math::Roots::Brent*)p);
04802    }
04803    static void deleteArray_ROOTcLcLMathcLcLRootscLcLBrent(void *p) {
04804       delete [] ((::ROOT::Math::Roots::Brent*)p);
04805    }
04806    static void destruct_ROOTcLcLMathcLcLRootscLcLBrent(void *p) {
04807       typedef ::ROOT::Math::Roots::Brent current_t;
04808       ((current_t*)p)->~current_t();
04809    }
04810 } // end of namespace ROOT for class ::ROOT::Math::Roots::Brent
04811 
04812 //______________________________________________________________________________
04813 namespace ROOT {
04814    void ROOTcLcLMathcLcLRootscLcLNewton_ShowMembers(void *obj, TMemberInspector &R__insp)
04815    {
04816       // Inspect the data members of an object of class ROOT::Math::Roots::Newton.
04817       typedef ::ROOT::Shadow::ROOT::Math::Roots::Newton ShadowClass;
04818       ShadowClass *sobj = (ShadowClass*)obj;
04819       if (sobj) { } // Dummy usage just in case there is no datamember.
04820 
04821       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Newton*)0x0)->GetClass();
04822       if (R__cl || R__insp.IsA()) { }
04823       R__insp.GenericShowMembers("ROOT::Math::GSLRootFinderDeriv", ( ::ROOT::Math::GSLRootFinderDeriv * )( (::ROOT::Math::Roots::Newton*) obj ), false);
04824    }
04825 
04826 }
04827 
04828 namespace ROOT {
04829    // Wrappers around operator new
04830    static void *new_ROOTcLcLMathcLcLRootscLcLNewton(void *p) {
04831       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Newton : new ::ROOT::Math::Roots::Newton;
04832    }
04833    static void *newArray_ROOTcLcLMathcLcLRootscLcLNewton(Long_t nElements, void *p) {
04834       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Newton[nElements] : new ::ROOT::Math::Roots::Newton[nElements];
04835    }
04836    // Wrapper around operator delete
04837    static void delete_ROOTcLcLMathcLcLRootscLcLNewton(void *p) {
04838       delete ((::ROOT::Math::Roots::Newton*)p);
04839    }
04840    static void deleteArray_ROOTcLcLMathcLcLRootscLcLNewton(void *p) {
04841       delete [] ((::ROOT::Math::Roots::Newton*)p);
04842    }
04843    static void destruct_ROOTcLcLMathcLcLRootscLcLNewton(void *p) {
04844       typedef ::ROOT::Math::Roots::Newton current_t;
04845       ((current_t*)p)->~current_t();
04846    }
04847 } // end of namespace ROOT for class ::ROOT::Math::Roots::Newton
04848 
04849 //______________________________________________________________________________
04850 namespace ROOT {
04851    void ROOTcLcLMathcLcLRootscLcLSecant_ShowMembers(void *obj, TMemberInspector &R__insp)
04852    {
04853       // Inspect the data members of an object of class ROOT::Math::Roots::Secant.
04854       typedef ::ROOT::Shadow::ROOT::Math::Roots::Secant ShadowClass;
04855       ShadowClass *sobj = (ShadowClass*)obj;
04856       if (sobj) { } // Dummy usage just in case there is no datamember.
04857 
04858       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Secant*)0x0)->GetClass();
04859       if (R__cl || R__insp.IsA()) { }
04860       R__insp.GenericShowMembers("ROOT::Math::GSLRootFinderDeriv", ( ::ROOT::Math::GSLRootFinderDeriv * )( (::ROOT::Math::Roots::Secant*) obj ), false);
04861    }
04862 
04863 }
04864 
04865 namespace ROOT {
04866    // Wrappers around operator new
04867    static void *new_ROOTcLcLMathcLcLRootscLcLSecant(void *p) {
04868       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Secant : new ::ROOT::Math::Roots::Secant;
04869    }
04870    static void *newArray_ROOTcLcLMathcLcLRootscLcLSecant(Long_t nElements, void *p) {
04871       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Secant[nElements] : new ::ROOT::Math::Roots::Secant[nElements];
04872    }
04873    // Wrapper around operator delete
04874    static void delete_ROOTcLcLMathcLcLRootscLcLSecant(void *p) {
04875       delete ((::ROOT::Math::Roots::Secant*)p);
04876    }
04877    static void deleteArray_ROOTcLcLMathcLcLRootscLcLSecant(void *p) {
04878       delete [] ((::ROOT::Math::Roots::Secant*)p);
04879    }
04880    static void destruct_ROOTcLcLMathcLcLRootscLcLSecant(void *p) {
04881       typedef ::ROOT::Math::Roots::Secant current_t;
04882       ((current_t*)p)->~current_t();
04883    }
04884 } // end of namespace ROOT for class ::ROOT::Math::Roots::Secant
04885 
04886 //______________________________________________________________________________
04887 namespace ROOT {
04888    void ROOTcLcLMathcLcLRootscLcLSteffenson_ShowMembers(void *obj, TMemberInspector &R__insp)
04889    {
04890       // Inspect the data members of an object of class ROOT::Math::Roots::Steffenson.
04891       typedef ::ROOT::Shadow::ROOT::Math::Roots::Steffenson ShadowClass;
04892       ShadowClass *sobj = (ShadowClass*)obj;
04893       if (sobj) { } // Dummy usage just in case there is no datamember.
04894 
04895       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Math::Roots::Steffenson*)0x0)->GetClass();
04896       if (R__cl || R__insp.IsA()) { }
04897       R__insp.GenericShowMembers("ROOT::Math::GSLRootFinderDeriv", ( ::ROOT::Math::GSLRootFinderDeriv * )( (::ROOT::Math::Roots::Steffenson*) obj ), false);
04898    }
04899 
04900 }
04901 
04902 namespace ROOT {
04903    // Wrappers around operator new
04904    static void *new_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p) {
04905       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Steffenson : new ::ROOT::Math::Roots::Steffenson;
04906    }
04907    static void *newArray_ROOTcLcLMathcLcLRootscLcLSteffenson(Long_t nElements, void *p) {
04908       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Math::Roots::Steffenson[nElements] : new ::ROOT::Math::Roots::Steffenson[nElements];
04909    }
04910    // Wrapper around operator delete
04911    static void delete_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p) {
04912       delete ((::ROOT::Math::Roots::Steffenson*)p);
04913    }
04914    static void deleteArray_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p) {
04915       delete [] ((::ROOT::Math::Roots::Steffenson*)p);
04916    }
04917    static void destruct_ROOTcLcLMathcLcLRootscLcLSteffenson(void *p) {
04918       typedef ::ROOT::Math::Roots::Steffenson current_t;
04919       ((current_t*)p)->~current_t();
04920    }
04921 } // end of namespace ROOT for class ::ROOT::Math::Roots::Steffenson
04922 
04923 namespace ROOT {
04924    void maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
04925    static void maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_Dictionary();
04926    static void *new_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p = 0);
04927    static void *newArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(Long_t size, void *p);
04928    static void delete_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p);
04929    static void deleteArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p);
04930    static void destruct_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p);
04931 
04932    // Function generating the singleton type initializer
04933    static TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,pair<double,double> >*)
04934    {
04935       map<unsigned int,pair<double,double> > *ptr = 0;
04936       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,pair<double,double> >),0);
04937       static ::ROOT::TGenericClassInfo 
04938          instance("map<unsigned int,pair<double,double> >", -2, "prec_stl/map", 63,
04939                   typeid(map<unsigned int,pair<double,double> >), DefineBehavior(ptr, ptr),
04940                   0, &maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_Dictionary, isa_proxy, 0,
04941                   sizeof(map<unsigned int,pair<double,double> >) );
04942       instance.SetNew(&new_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
04943       instance.SetNewArray(&newArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
04944       instance.SetDelete(&delete_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
04945       instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
04946       instance.SetDestructor(&destruct_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
04947       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<unsigned int,pair<double,double> > >()));
04948       return &instance;
04949    }
04950    // Static variable to force the class initialization
04951    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned int,pair<double,double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
04952 
04953    // Dictionary for non-ClassDef classes
04954    static void maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_Dictionary() {
04955       ::ROOT::GenerateInitInstanceLocal((const map<unsigned int,pair<double,double> >*)0x0)->GetClass();
04956    }
04957 
04958 } // end of namespace ROOT
04959 
04960 namespace ROOT {
04961    // Wrappers around operator new
04962    static void *new_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
04963       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,pair<double,double> > : new map<unsigned int,pair<double,double> >;
04964    }
04965    static void *newArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(Long_t nElements, void *p) {
04966       return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,pair<double,double> >[nElements] : new map<unsigned int,pair<double,double> >[nElements];
04967    }
04968    // Wrapper around operator delete
04969    static void delete_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
04970       delete ((map<unsigned int,pair<double,double> >*)p);
04971    }
04972    static void deleteArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
04973       delete [] ((map<unsigned int,pair<double,double> >*)p);
04974    }
04975    static void destruct_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
04976       typedef map<unsigned int,pair<double,double> > current_t;
04977       ((current_t*)p)->~current_t();
04978    }
04979 } // end of namespace ROOT for class map<unsigned int,pair<double,double> >
04980 
04981 namespace ROOT {
04982    void vectorlEROOTcLcLMathcLcLEMinimVariableTypegR_ShowMembers(void *obj, TMemberInspector &R__insp);
04983    static void vectorlEROOTcLcLMathcLcLEMinimVariableTypegR_Dictionary();
04984    static void *new_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p = 0);
04985    static void *newArray_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(Long_t size, void *p);
04986    static void delete_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p);
04987    static void deleteArray_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p);
04988    static void destruct_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p);
04989 
04990    // Function generating the singleton type initializer
04991    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<ROOT::Math::EMinimVariableType>*)
04992    {
04993       vector<ROOT::Math::EMinimVariableType> *ptr = 0;
04994       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<ROOT::Math::EMinimVariableType>),0);
04995       static ::ROOT::TGenericClassInfo 
04996          instance("vector<ROOT::Math::EMinimVariableType>", -2, "prec_stl/vector", 49,
04997                   typeid(vector<ROOT::Math::EMinimVariableType>), DefineBehavior(ptr, ptr),
04998                   0, &vectorlEROOTcLcLMathcLcLEMinimVariableTypegR_Dictionary, isa_proxy, 0,
04999                   sizeof(vector<ROOT::Math::EMinimVariableType>) );
05000       instance.SetNew(&new_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR);
05001       instance.SetNewArray(&newArray_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR);
05002       instance.SetDelete(&delete_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR);
05003       instance.SetDeleteArray(&deleteArray_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR);
05004       instance.SetDestructor(&destruct_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR);
05005       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<ROOT::Math::EMinimVariableType> >()));
05006       return &instance;
05007    }
05008    // Static variable to force the class initialization
05009    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<ROOT::Math::EMinimVariableType>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
05010 
05011    // Dictionary for non-ClassDef classes
05012    static void vectorlEROOTcLcLMathcLcLEMinimVariableTypegR_Dictionary() {
05013       ::ROOT::GenerateInitInstanceLocal((const vector<ROOT::Math::EMinimVariableType>*)0x0)->GetClass();
05014    }
05015 
05016 } // end of namespace ROOT
05017 
05018 namespace ROOT {
05019    // Wrappers around operator new
05020    static void *new_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p) {
05021       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ROOT::Math::EMinimVariableType> : new vector<ROOT::Math::EMinimVariableType>;
05022    }
05023    static void *newArray_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(Long_t nElements, void *p) {
05024       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ROOT::Math::EMinimVariableType>[nElements] : new vector<ROOT::Math::EMinimVariableType>[nElements];
05025    }
05026    // Wrapper around operator delete
05027    static void delete_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p) {
05028       delete ((vector<ROOT::Math::EMinimVariableType>*)p);
05029    }
05030    static void deleteArray_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p) {
05031       delete [] ((vector<ROOT::Math::EMinimVariableType>*)p);
05032    }
05033    static void destruct_vectorlEROOTcLcLMathcLcLEMinimVariableTypegR(void *p) {
05034       typedef vector<ROOT::Math::EMinimVariableType> current_t;
05035       ((current_t*)p)->~current_t();
05036    }
05037 } // end of namespace ROOT for class vector<ROOT::Math::EMinimVariableType>
05038 
05039 namespace ROOT {
05040    void vectorlEcomplexlEdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
05041    static void vectorlEcomplexlEdoublegRsPgR_Dictionary();
05042    static void *new_vectorlEcomplexlEdoublegRsPgR(void *p = 0);
05043    static void *newArray_vectorlEcomplexlEdoublegRsPgR(Long_t size, void *p);
05044    static void delete_vectorlEcomplexlEdoublegRsPgR(void *p);
05045    static void deleteArray_vectorlEcomplexlEdoublegRsPgR(void *p);
05046    static void destruct_vectorlEcomplexlEdoublegRsPgR(void *p);
05047 
05048    // Function generating the singleton type initializer
05049    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<complex<double> >*)
05050    {
05051       vector<complex<double> > *ptr = 0;
05052       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<complex<double> >),0);
05053       static ::ROOT::TGenericClassInfo 
05054          instance("vector<complex<double> >", -2, "prec_stl/vector", 49,
05055                   typeid(vector<complex<double> >), DefineBehavior(ptr, ptr),
05056                   0, &vectorlEcomplexlEdoublegRsPgR_Dictionary, isa_proxy, 0,
05057                   sizeof(vector<complex<double> >) );
05058       instance.SetNew(&new_vectorlEcomplexlEdoublegRsPgR);
05059       instance.SetNewArray(&newArray_vectorlEcomplexlEdoublegRsPgR);
05060       instance.SetDelete(&delete_vectorlEcomplexlEdoublegRsPgR);
05061       instance.SetDeleteArray(&deleteArray_vectorlEcomplexlEdoublegRsPgR);
05062       instance.SetDestructor(&destruct_vectorlEcomplexlEdoublegRsPgR);
05063       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<complex<double> > >()));
05064       return &instance;
05065    }
05066    // Static variable to force the class initialization
05067    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<complex<double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
05068 
05069    // Dictionary for non-ClassDef classes
05070    static void vectorlEcomplexlEdoublegRsPgR_Dictionary() {
05071       ::ROOT::GenerateInitInstanceLocal((const vector<complex<double> >*)0x0)->GetClass();
05072    }
05073 
05074 } // end of namespace ROOT
05075 
05076 namespace ROOT {
05077    // Wrappers around operator new
05078    static void *new_vectorlEcomplexlEdoublegRsPgR(void *p) {
05079       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<complex<double> > : new vector<complex<double> >;
05080    }
05081    static void *newArray_vectorlEcomplexlEdoublegRsPgR(Long_t nElements, void *p) {
05082       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<complex<double> >[nElements] : new vector<complex<double> >[nElements];
05083    }
05084    // Wrapper around operator delete
05085    static void delete_vectorlEcomplexlEdoublegRsPgR(void *p) {
05086       delete ((vector<complex<double> >*)p);
05087    }
05088    static void deleteArray_vectorlEcomplexlEdoublegRsPgR(void *p) {
05089       delete [] ((vector<complex<double> >*)p);
05090    }
05091    static void destruct_vectorlEcomplexlEdoublegRsPgR(void *p) {
05092       typedef vector<complex<double> > current_t;
05093       ((current_t*)p)->~current_t();
05094    }
05095 } // end of namespace ROOT for class vector<complex<double> >
05096 
05097 namespace ROOT {
05098    void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
05099    static void vectorlEdoublegR_Dictionary();
05100    static void *new_vectorlEdoublegR(void *p = 0);
05101    static void *newArray_vectorlEdoublegR(Long_t size, void *p);
05102    static void delete_vectorlEdoublegR(void *p);
05103    static void deleteArray_vectorlEdoublegR(void *p);
05104    static void destruct_vectorlEdoublegR(void *p);
05105 
05106    // Function generating the singleton type initializer
05107    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
05108    {
05109       vector<double> *ptr = 0;
05110       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
05111       static ::ROOT::TGenericClassInfo 
05112          instance("vector<double>", -2, "prec_stl/vector", 49,
05113                   typeid(vector<double>), DefineBehavior(ptr, ptr),
05114                   0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
05115                   sizeof(vector<double>) );
05116       instance.SetNew(&new_vectorlEdoublegR);
05117       instance.SetNewArray(&newArray_vectorlEdoublegR);
05118       instance.SetDelete(&delete_vectorlEdoublegR);
05119       instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
05120       instance.SetDestructor(&destruct_vectorlEdoublegR);
05121       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
05122       return &instance;
05123    }
05124    // Static variable to force the class initialization
05125    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
05126 
05127    // Dictionary for non-ClassDef classes
05128    static void vectorlEdoublegR_Dictionary() {
05129       ::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
05130    }
05131 
05132 } // end of namespace ROOT
05133 
05134 namespace ROOT {
05135    // Wrappers around operator new
05136    static void *new_vectorlEdoublegR(void *p) {
05137       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
05138    }
05139    static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
05140       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
05141    }
05142    // Wrapper around operator delete
05143    static void delete_vectorlEdoublegR(void *p) {
05144       delete ((vector<double>*)p);
05145    }
05146    static void deleteArray_vectorlEdoublegR(void *p) {
05147       delete [] ((vector<double>*)p);
05148    }
05149    static void destruct_vectorlEdoublegR(void *p) {
05150       typedef vector<double> current_t;
05151       ((current_t*)p)->~current_t();
05152    }
05153 } // end of namespace ROOT for class vector<double>
05154 
05155 namespace ROOT {
05156    void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
05157    static void vectorlEstringgR_Dictionary();
05158    static void *new_vectorlEstringgR(void *p = 0);
05159    static void *newArray_vectorlEstringgR(Long_t size, void *p);
05160    static void delete_vectorlEstringgR(void *p);
05161    static void deleteArray_vectorlEstringgR(void *p);
05162    static void destruct_vectorlEstringgR(void *p);
05163 
05164    // Function generating the singleton type initializer
05165    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
05166    {
05167       vector<string> *ptr = 0;
05168       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
05169       static ::ROOT::TGenericClassInfo 
05170          instance("vector<string>", -2, "prec_stl/vector", 49,
05171                   typeid(vector<string>), DefineBehavior(ptr, ptr),
05172                   0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
05173                   sizeof(vector<string>) );
05174       instance.SetNew(&new_vectorlEstringgR);
05175       instance.SetNewArray(&newArray_vectorlEstringgR);
05176       instance.SetDelete(&delete_vectorlEstringgR);
05177       instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
05178       instance.SetDestructor(&destruct_vectorlEstringgR);
05179       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
05180       return &instance;
05181    }
05182    // Static variable to force the class initialization
05183    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
05184 
05185    // Dictionary for non-ClassDef classes
05186    static void vectorlEstringgR_Dictionary() {
05187       ::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
05188    }
05189 
05190 } // end of namespace ROOT
05191 
05192 namespace ROOT {
05193    // Wrappers around operator new
05194    static void *new_vectorlEstringgR(void *p) {
05195       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
05196    }
05197    static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
05198       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
05199    }
05200    // Wrapper around operator delete
05201    static void delete_vectorlEstringgR(void *p) {
05202       delete ((vector<string>*)p);
05203    }
05204    static void deleteArray_vectorlEstringgR(void *p) {
05205       delete [] ((vector<string>*)p);
05206    }
05207    static void destruct_vectorlEstringgR(void *p) {
05208       typedef vector<string> current_t;
05209       ((current_t*)p)->~current_t();
05210    }
05211 } // end of namespace ROOT for class vector<string>
05212 
05213 /********************************************************
05214 * math/mathmore/src/G__MathMore.cxx
05215 * CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
05216 *          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
05217 *          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
05218 ********************************************************/
05219 
05220 #ifdef G__MEMTEST
05221 #undef malloc
05222 #undef free
05223 #endif
05224 
05225 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
05226 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
05227 #endif
05228 
05229 extern "C" void G__cpp_reset_tagtableG__MathMore();
05230 
05231 extern "C" void G__set_cpp_environmentG__MathMore() {
05232   G__add_compiledheader("TObject.h");
05233   G__add_compiledheader("TMemberInspector.h");
05234   G__add_compiledheader("Math/DistFuncMathMore.h");
05235   G__add_compiledheader("Math/SpecFuncMathMore.h");
05236   G__add_compiledheader("Math/PdfFuncMathMore.h");
05237   G__add_compiledheader("Math/Polynomial.h");
05238   G__add_compiledheader("Math/Derivator.h");
05239   G__add_compiledheader("Math/Interpolator.h");
05240   G__add_compiledheader("Math/InterpolationTypes.h");
05241   G__add_compiledheader("Math/GSLRootFinder.h");
05242   G__add_compiledheader("Math/GSLRootFinderDeriv.h");
05243   G__add_compiledheader("Math/RootFinderAlgorithms.h");
05244   G__add_compiledheader("Math/GSLIntegrator.h");
05245   G__add_compiledheader("Math/GSLMCIntegrator.h");
05246   G__add_compiledheader("Math/MCParameters.h");
05247   G__add_compiledheader("Math/GSLMinimizer1D.h");
05248   G__add_compiledheader("Math/Chebyshev.h");
05249   G__add_compiledheader("Math/Random.h");
05250   G__add_compiledheader("Math/GSLRndmEngines.h");
05251   G__add_compiledheader("Math/KelvinFunctions.h");
05252   G__add_compiledheader("Math/GSLMinimizer.h");
05253   G__add_compiledheader("Math/GSLNLSMinimizer.h");
05254   G__add_compiledheader("Math/GSLSimAnMinimizer.h");
05255   G__add_compiledheader("Math/Vavilov.h");
05256   G__add_compiledheader("Math/VavilovAccurate.h");
05257   G__add_compiledheader("Math/VavilovAccuratePdf.h");
05258   G__add_compiledheader("Math/VavilovAccurateCdf.h");
05259   G__add_compiledheader("Math/VavilovAccurateQuantile.h");
05260   G__add_compiledheader("Math/VavilovFast.h");
05261   G__add_compiledheader("/misc/hadessoftware/etch32/install/root-5.28.00b/math/mathmore/src/GSLError.h");
05262   G__cpp_reset_tagtableG__MathMore();
05263 }
05264 #include <new>
05265 extern "C" int G__cpp_dllrevG__MathMore() { return(30051515); }
05266 
05267 /*********************************************************
05268 * Member function Interface Method
05269 *********************************************************/
05270 
05271 /* ROOT */
05272 static int G__G__MathMore_19_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05273 {
05274       G__letint(result7, 85, (long) ROOT::CreateClass(
05275 (const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
05276 , *(type_info*) libp->para[2].ref, (TVirtualIsAProxy*) G__int(libp->para[3])
05277 , (ShowMembersFunc_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
05278 , (const char*) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
05279 , (Int_t) G__int(libp->para[8])));
05280    return(1 || funcname || hash || result7 || libp) ;
05281 }
05282 
05283 static int G__G__MathMore_19_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05284 {
05285       ROOT::AddClass((const char*) G__int(libp->para[0]), (Version_t) G__int(libp->para[1])
05286 , *(type_info*) libp->para[2].ref, (VoidFuncPtr_t) G__int(libp->para[3])
05287 , (Int_t) G__int(libp->para[4]));
05288       G__setnull(result7);
05289    return(1 || funcname || hash || result7 || libp) ;
05290 }
05291 
05292 static int G__G__MathMore_19_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05293 {
05294       ROOT::RemoveClass((const char*) G__int(libp->para[0]));
05295       G__setnull(result7);
05296    return(1 || funcname || hash || result7 || libp) ;
05297 }
05298 
05299 static int G__G__MathMore_19_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05300 {
05301       ROOT::ResetClassVersion((TClass*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05302 , (Short_t) G__int(libp->para[2]));
05303       G__setnull(result7);
05304    return(1 || funcname || hash || result7 || libp) ;
05305 }
05306 
05307 static int G__G__MathMore_19_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05308 {
05309       G__letint(result7, 85, (long) ROOT::RegisterClassTemplate((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05310 , (Int_t) G__int(libp->para[2])));
05311    return(1 || funcname || hash || result7 || libp) ;
05312 }
05313 
05314 static int G__G__MathMore_19_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05315 {
05316       G__letint(result7, 85, (long) ROOT::DefineBehavior((void*) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
05317    return(1 || funcname || hash || result7 || libp) ;
05318 }
05319 
05320 
05321 /* ROOT::Math */
05322 static int G__G__MathMore_99_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05323 {
05324       G__letdouble(result7, 100, (double) ROOT::Math::noncentral_chisquared_pdf((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05325 , (double) G__double(libp->para[2])));
05326    return(1 || funcname || hash || result7 || libp) ;
05327 }
05328 
05329 static int G__G__MathMore_99_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05330 {
05331       G__letdouble(result7, 100, (double) ROOT::Math::tdistribution_quantile_c((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05332    return(1 || funcname || hash || result7 || libp) ;
05333 }
05334 
05335 static int G__G__MathMore_99_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05336 {
05337       G__letdouble(result7, 100, (double) ROOT::Math::tdistribution_quantile((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05338    return(1 || funcname || hash || result7 || libp) ;
05339 }
05340 
05341 static int G__G__MathMore_99_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05342 {
05343       G__letdouble(result7, 100, (double) ROOT::Math::assoc_laguerre((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
05344 , (double) G__double(libp->para[2])));
05345    return(1 || funcname || hash || result7 || libp) ;
05346 }
05347 
05348 static int G__G__MathMore_99_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05349 {
05350       G__letdouble(result7, 100, (double) ROOT::Math::assoc_legendre((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
05351 , (double) G__double(libp->para[2])));
05352    return(1 || funcname || hash || result7 || libp) ;
05353 }
05354 
05355 static int G__G__MathMore_99_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05356 {
05357       G__letdouble(result7, 100, (double) ROOT::Math::comp_ellint_1((double) G__double(libp->para[0])));
05358    return(1 || funcname || hash || result7 || libp) ;
05359 }
05360 
05361 static int G__G__MathMore_99_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05362 {
05363       G__letdouble(result7, 100, (double) ROOT::Math::comp_ellint_2((double) G__double(libp->para[0])));
05364    return(1 || funcname || hash || result7 || libp) ;
05365 }
05366 
05367 static int G__G__MathMore_99_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05368 {
05369       G__letdouble(result7, 100, (double) ROOT::Math::comp_ellint_3((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05370    return(1 || funcname || hash || result7 || libp) ;
05371 }
05372 
05373 static int G__G__MathMore_99_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05374 {
05375       G__letdouble(result7, 100, (double) ROOT::Math::conf_hyperg((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05376 , (double) G__double(libp->para[2])));
05377    return(1 || funcname || hash || result7 || libp) ;
05378 }
05379 
05380 static int G__G__MathMore_99_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05381 {
05382       G__letdouble(result7, 100, (double) ROOT::Math::conf_hypergU((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05383 , (double) G__double(libp->para[2])));
05384    return(1 || funcname || hash || result7 || libp) ;
05385 }
05386 
05387 static int G__G__MathMore_99_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05388 {
05389       G__letdouble(result7, 100, (double) ROOT::Math::cyl_bessel_i((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05390    return(1 || funcname || hash || result7 || libp) ;
05391 }
05392 
05393 static int G__G__MathMore_99_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05394 {
05395       G__letdouble(result7, 100, (double) ROOT::Math::cyl_bessel_j((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05396    return(1 || funcname || hash || result7 || libp) ;
05397 }
05398 
05399 static int G__G__MathMore_99_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05400 {
05401       G__letdouble(result7, 100, (double) ROOT::Math::cyl_bessel_k((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05402    return(1 || funcname || hash || result7 || libp) ;
05403 }
05404 
05405 static int G__G__MathMore_99_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05406 {
05407       G__letdouble(result7, 100, (double) ROOT::Math::cyl_neumann((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05408    return(1 || funcname || hash || result7 || libp) ;
05409 }
05410 
05411 static int G__G__MathMore_99_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05412 {
05413       G__letdouble(result7, 100, (double) ROOT::Math::ellint_1((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05414    return(1 || funcname || hash || result7 || libp) ;
05415 }
05416 
05417 static int G__G__MathMore_99_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05418 {
05419       G__letdouble(result7, 100, (double) ROOT::Math::ellint_2((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05420    return(1 || funcname || hash || result7 || libp) ;
05421 }
05422 
05423 static int G__G__MathMore_99_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05424 {
05425       G__letdouble(result7, 100, (double) ROOT::Math::ellint_3((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05426 , (double) G__double(libp->para[2])));
05427    return(1 || funcname || hash || result7 || libp) ;
05428 }
05429 
05430 static int G__G__MathMore_99_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05431 {
05432       G__letdouble(result7, 100, (double) ROOT::Math::expint((double) G__double(libp->para[0])));
05433    return(1 || funcname || hash || result7 || libp) ;
05434 }
05435 
05436 static int G__G__MathMore_99_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05437 {
05438       G__letdouble(result7, 100, (double) ROOT::Math::hyperg((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05439 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
05440    return(1 || funcname || hash || result7 || libp) ;
05441 }
05442 
05443 static int G__G__MathMore_99_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05444 {
05445       G__letdouble(result7, 100, (double) ROOT::Math::laguerre((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
05446    return(1 || funcname || hash || result7 || libp) ;
05447 }
05448 
05449 static int G__G__MathMore_99_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05450 {
05451       G__letdouble(result7, 100, (double) ROOT::Math::legendre((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
05452    return(1 || funcname || hash || result7 || libp) ;
05453 }
05454 
05455 static int G__G__MathMore_99_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05456 {
05457       G__letdouble(result7, 100, (double) ROOT::Math::riemann_zeta((double) G__double(libp->para[0])));
05458    return(1 || funcname || hash || result7 || libp) ;
05459 }
05460 
05461 static int G__G__MathMore_99_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05462 {
05463       G__letdouble(result7, 100, (double) ROOT::Math::sph_bessel((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
05464    return(1 || funcname || hash || result7 || libp) ;
05465 }
05466 
05467 static int G__G__MathMore_99_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05468 {
05469       G__letdouble(result7, 100, (double) ROOT::Math::sph_legendre((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
05470 , (double) G__double(libp->para[2])));
05471    return(1 || funcname || hash || result7 || libp) ;
05472 }
05473 
05474 static int G__G__MathMore_99_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05475 {
05476       G__letdouble(result7, 100, (double) ROOT::Math::sph_neumann((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
05477    return(1 || funcname || hash || result7 || libp) ;
05478 }
05479 
05480 static int G__G__MathMore_99_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05481 {
05482       G__letdouble(result7, 100, (double) ROOT::Math::airy_Ai((double) G__double(libp->para[0])));
05483    return(1 || funcname || hash || result7 || libp) ;
05484 }
05485 
05486 static int G__G__MathMore_99_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05487 {
05488       G__letdouble(result7, 100, (double) ROOT::Math::airy_Bi((double) G__double(libp->para[0])));
05489    return(1 || funcname || hash || result7 || libp) ;
05490 }
05491 
05492 static int G__G__MathMore_99_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05493 {
05494       G__letdouble(result7, 100, (double) ROOT::Math::airy_Ai_deriv((double) G__double(libp->para[0])));
05495    return(1 || funcname || hash || result7 || libp) ;
05496 }
05497 
05498 static int G__G__MathMore_99_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05499 {
05500       G__letdouble(result7, 100, (double) ROOT::Math::airy_Bi_deriv((double) G__double(libp->para[0])));
05501    return(1 || funcname || hash || result7 || libp) ;
05502 }
05503 
05504 static int G__G__MathMore_99_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05505 {
05506       G__letdouble(result7, 100, (double) ROOT::Math::airy_zero_Ai((unsigned int) G__int(libp->para[0])));
05507    return(1 || funcname || hash || result7 || libp) ;
05508 }
05509 
05510 static int G__G__MathMore_99_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05511 {
05512       G__letdouble(result7, 100, (double) ROOT::Math::airy_zero_Bi((unsigned int) G__int(libp->para[0])));
05513    return(1 || funcname || hash || result7 || libp) ;
05514 }
05515 
05516 static int G__G__MathMore_99_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05517 {
05518       G__letdouble(result7, 100, (double) ROOT::Math::airy_zero_Ai_deriv((unsigned int) G__int(libp->para[0])));
05519    return(1 || funcname || hash || result7 || libp) ;
05520 }
05521 
05522 static int G__G__MathMore_99_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05523 {
05524       G__letdouble(result7, 100, (double) ROOT::Math::airy_zero_Bi_deriv((unsigned int) G__int(libp->para[0])));
05525    return(1 || funcname || hash || result7 || libp) ;
05526 }
05527 
05528 static int G__G__MathMore_99_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05529 {
05530       G__letdouble(result7, 100, (double) ROOT::Math::wigner_3j((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
05531 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
05532 , (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
05533    return(1 || funcname || hash || result7 || libp) ;
05534 }
05535 
05536 static int G__G__MathMore_99_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05537 {
05538       G__letdouble(result7, 100, (double) ROOT::Math::wigner_6j((int) G__int(libp->para[0]), (int) G__int(libp->para[1])
05539 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
05540 , (int) G__int(libp->para[4]), (int) G__int(libp->para[5])));
05541    return(1 || funcname || hash || result7 || libp) ;
05542 }
05543 
05544 static int G__G__MathMore_99_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05545 {
05546       G__letdouble(result7, 100, (double) ROOT::Math::wigner_9j(
05547 (int) G__int(libp->para[0]), (int) G__int(libp->para[1])
05548 , (int) G__int(libp->para[2]), (int) G__int(libp->para[3])
05549 , (int) G__int(libp->para[4]), (int) G__int(libp->para[5])
05550 , (int) G__int(libp->para[6]), (int) G__int(libp->para[7])
05551 , (int) G__int(libp->para[8])));
05552    return(1 || funcname || hash || result7 || libp) ;
05553 }
05554 
05555 static int G__G__MathMore_99_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05556 {
05557       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_accurate_pdf((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05558 , (double) G__double(libp->para[2])));
05559    return(1 || funcname || hash || result7 || libp) ;
05560 }
05561 
05562 static int G__G__MathMore_99_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05563 {
05564       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_accurate_cdf((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05565 , (double) G__double(libp->para[2])));
05566    return(1 || funcname || hash || result7 || libp) ;
05567 }
05568 
05569 static int G__G__MathMore_99_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05570 {
05571       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_accurate_cdf_c((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05572 , (double) G__double(libp->para[2])));
05573    return(1 || funcname || hash || result7 || libp) ;
05574 }
05575 
05576 static int G__G__MathMore_99_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05577 {
05578       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_accurate_quantile((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05579 , (double) G__double(libp->para[2])));
05580    return(1 || funcname || hash || result7 || libp) ;
05581 }
05582 
05583 static int G__G__MathMore_99_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05584 {
05585       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_accurate_quantile_c((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05586 , (double) G__double(libp->para[2])));
05587    return(1 || funcname || hash || result7 || libp) ;
05588 }
05589 
05590 static int G__G__MathMore_99_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05591 {
05592       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_fast_pdf((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05593 , (double) G__double(libp->para[2])));
05594    return(1 || funcname || hash || result7 || libp) ;
05595 }
05596 
05597 static int G__G__MathMore_99_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05598 {
05599       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_fast_cdf((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05600 , (double) G__double(libp->para[2])));
05601    return(1 || funcname || hash || result7 || libp) ;
05602 }
05603 
05604 static int G__G__MathMore_99_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05605 {
05606       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_fast_cdf_c((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05607 , (double) G__double(libp->para[2])));
05608    return(1 || funcname || hash || result7 || libp) ;
05609 }
05610 
05611 static int G__G__MathMore_99_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05612 {
05613       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_fast_quantile((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05614 , (double) G__double(libp->para[2])));
05615    return(1 || funcname || hash || result7 || libp) ;
05616 }
05617 
05618 static int G__G__MathMore_99_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05619 {
05620       G__letdouble(result7, 100, (double) ROOT::Math::vavilov_fast_quantile_c((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05621 , (double) G__double(libp->para[2])));
05622    return(1 || funcname || hash || result7 || libp) ;
05623 }
05624 
05625 
05626 /* ROOT::MathMore */
05627 static int G__G__MathMore_100_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05628 {
05629       G__letdouble(result7, 100, (double) ROOT::MathMore::chisquared_quantile((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
05630    return(1 || funcname || hash || result7 || libp) ;
05631 }
05632 
05633 static int G__G__MathMore_100_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05634 {
05635       G__letdouble(result7, 100, (double) ROOT::MathMore::gamma_quantile((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05636 , (double) G__double(libp->para[2])));
05637    return(1 || funcname || hash || result7 || libp) ;
05638 }
05639 
05640 
05641 /* ROOT::Math::Polynomial */
05642 static int G__G__MathMore_113_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05643 {
05644    ROOT::Math::Polynomial* p = NULL;
05645    char* gvp = (char*) G__getgvp();
05646    switch (libp->paran) {
05647    case 1:
05648      //m: 1
05649      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05650        p = new ROOT::Math::Polynomial((unsigned int) G__int(libp->para[0]));
05651      } else {
05652        p = new((void*) gvp) ROOT::Math::Polynomial((unsigned int) G__int(libp->para[0]));
05653      }
05654      break;
05655    case 0:
05656      int n = G__getaryconstruct();
05657      if (n) {
05658        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05659          p = new ROOT::Math::Polynomial[n];
05660        } else {
05661          p = new((void*) gvp) ROOT::Math::Polynomial[n];
05662        }
05663      } else {
05664        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05665          p = new ROOT::Math::Polynomial;
05666        } else {
05667          p = new((void*) gvp) ROOT::Math::Polynomial;
05668        }
05669      }
05670      break;
05671    }
05672    result7->obj.i = (long) p;
05673    result7->ref = (long) p;
05674    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
05675    return(1 || funcname || hash || result7 || libp) ;
05676 }
05677 
05678 static int G__G__MathMore_113_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05679 {
05680    ROOT::Math::Polynomial* p = NULL;
05681    char* gvp = (char*) G__getgvp();
05682    //m: 2
05683    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05684      p = new ROOT::Math::Polynomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
05685    } else {
05686      p = new((void*) gvp) ROOT::Math::Polynomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
05687    }
05688    result7->obj.i = (long) p;
05689    result7->ref = (long) p;
05690    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
05691    return(1 || funcname || hash || result7 || libp) ;
05692 }
05693 
05694 static int G__G__MathMore_113_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05695 {
05696    ROOT::Math::Polynomial* p = NULL;
05697    char* gvp = (char*) G__getgvp();
05698    //m: 3
05699    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05700      p = new ROOT::Math::Polynomial(
05701 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05702 , (double) G__double(libp->para[2]));
05703    } else {
05704      p = new((void*) gvp) ROOT::Math::Polynomial(
05705 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05706 , (double) G__double(libp->para[2]));
05707    }
05708    result7->obj.i = (long) p;
05709    result7->ref = (long) p;
05710    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
05711    return(1 || funcname || hash || result7 || libp) ;
05712 }
05713 
05714 static int G__G__MathMore_113_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05715 {
05716    ROOT::Math::Polynomial* p = NULL;
05717    char* gvp = (char*) G__getgvp();
05718    //m: 4
05719    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05720      p = new ROOT::Math::Polynomial(
05721 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05722 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
05723    } else {
05724      p = new((void*) gvp) ROOT::Math::Polynomial(
05725 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05726 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
05727    }
05728    result7->obj.i = (long) p;
05729    result7->ref = (long) p;
05730    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
05731    return(1 || funcname || hash || result7 || libp) ;
05732 }
05733 
05734 static int G__G__MathMore_113_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05735 {
05736    ROOT::Math::Polynomial* p = NULL;
05737    char* gvp = (char*) G__getgvp();
05738    //m: 5
05739    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05740      p = new ROOT::Math::Polynomial(
05741 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05742 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
05743 , (double) G__double(libp->para[4]));
05744    } else {
05745      p = new((void*) gvp) ROOT::Math::Polynomial(
05746 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
05747 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
05748 , (double) G__double(libp->para[4]));
05749    }
05750    result7->obj.i = (long) p;
05751    result7->ref = (long) p;
05752    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
05753    return(1 || funcname || hash || result7 || libp) ;
05754 }
05755 
05756 static int G__G__MathMore_113_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05757 {
05758       {
05759          const vector<std::complex<double> >& obj = ((ROOT::Math::Polynomial*) G__getstructoffset())->FindRoots();
05760          result7->ref = (long) (&obj);
05761          result7->obj.i = (long) (&obj);
05762       }
05763    return(1 || funcname || hash || result7 || libp) ;
05764 }
05765 
05766 static int G__G__MathMore_113_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05767 {
05768       {
05769          vector<double>* pobj;
05770          vector<double> xobj = ((ROOT::Math::Polynomial*) G__getstructoffset())->FindRealRoots();
05771          pobj = new vector<double>(xobj);
05772          result7->obj.i = (long) ((void*) pobj);
05773          result7->ref = result7->obj.i;
05774          G__store_tempobject(*result7);
05775       }
05776    return(1 || funcname || hash || result7 || libp) ;
05777 }
05778 
05779 static int G__G__MathMore_113_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05780 {
05781       {
05782          const vector<std::complex<double> >& obj = ((ROOT::Math::Polynomial*) G__getstructoffset())->FindNumRoots();
05783          result7->ref = (long) (&obj);
05784          result7->obj.i = (long) (&obj);
05785       }
05786    return(1 || funcname || hash || result7 || libp) ;
05787 }
05788 
05789 static int G__G__MathMore_113_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05790 {
05791       G__letint(result7, 104, (long) ((const ROOT::Math::Polynomial*) G__getstructoffset())->Order());
05792    return(1 || funcname || hash || result7 || libp) ;
05793 }
05794 
05795 // automatic copy constructor
05796 static int G__G__MathMore_113_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05797 
05798 {
05799    ROOT::Math::Polynomial* p;
05800    void* tmp = (void*) G__int(libp->para[0]);
05801    p = new ROOT::Math::Polynomial(*(ROOT::Math::Polynomial*) tmp);
05802    result7->obj.i = (long) p;
05803    result7->ref = (long) p;
05804    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
05805    return(1 || funcname || hash || result7 || libp) ;
05806 }
05807 
05808 // automatic destructor
05809 typedef ROOT::Math::Polynomial G__TROOTcLcLMathcLcLPolynomial;
05810 static int G__G__MathMore_113_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05811 {
05812    char* gvp = (char*) G__getgvp();
05813    long soff = G__getstructoffset();
05814    int n = G__getaryconstruct();
05815    //
05816    //has_a_delete: 0
05817    //has_own_delete1arg: 0
05818    //has_own_delete2arg: 0
05819    //
05820    if (!soff) {
05821      return(1);
05822    }
05823    if (n) {
05824      if (gvp == (char*)G__PVOID) {
05825        delete[] (ROOT::Math::Polynomial*) soff;
05826      } else {
05827        G__setgvp((long) G__PVOID);
05828        for (int i = n - 1; i >= 0; --i) {
05829          ((ROOT::Math::Polynomial*) (soff+(sizeof(ROOT::Math::Polynomial)*i)))->~G__TROOTcLcLMathcLcLPolynomial();
05830        }
05831        G__setgvp((long)gvp);
05832      }
05833    } else {
05834      if (gvp == (char*)G__PVOID) {
05835        delete (ROOT::Math::Polynomial*) soff;
05836      } else {
05837        G__setgvp((long) G__PVOID);
05838        ((ROOT::Math::Polynomial*) (soff))->~G__TROOTcLcLMathcLcLPolynomial();
05839        G__setgvp((long)gvp);
05840      }
05841    }
05842    G__setnull(result7);
05843    return(1 || funcname || hash || result7 || libp) ;
05844 }
05845 
05846 // automatic assignment operator
05847 static int G__G__MathMore_113_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05848 {
05849    ROOT::Math::Polynomial* dest = (ROOT::Math::Polynomial*) G__getstructoffset();
05850    *dest = *(ROOT::Math::Polynomial*) libp->para[0].ref;
05851    const ROOT::Math::Polynomial& obj = *dest;
05852    result7->ref = (long) (&obj);
05853    result7->obj.i = (long) (&obj);
05854    return(1 || funcname || hash || result7 || libp) ;
05855 }
05856 
05857 
05858 /* ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> */
05859 // automatic destructor
05860 typedef ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> G__TROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR;
05861 static int G__G__MathMore_114_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05862 {
05863    char* gvp = (char*) G__getgvp();
05864    long soff = G__getstructoffset();
05865    int n = G__getaryconstruct();
05866    //
05867    //has_a_delete: 0
05868    //has_own_delete1arg: 0
05869    //has_own_delete2arg: 0
05870    //
05871    if (!soff) {
05872      return(1);
05873    }
05874    if (n) {
05875      if (gvp == (char*)G__PVOID) {
05876        delete[] (ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*) soff;
05877      } else {
05878        G__setgvp((long) G__PVOID);
05879        for (int i = n - 1; i >= 0; --i) {
05880          ((ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*) (soff+(sizeof(ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>)*i)))->~G__TROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR();
05881        }
05882        G__setgvp((long)gvp);
05883      }
05884    } else {
05885      if (gvp == (char*)G__PVOID) {
05886        delete (ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*) soff;
05887      } else {
05888        G__setgvp((long) G__PVOID);
05889        ((ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*) (soff))->~G__TROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR();
05890        G__setgvp((long)gvp);
05891      }
05892    }
05893    G__setnull(result7);
05894    return(1 || funcname || hash || result7 || libp) ;
05895 }
05896 
05897 // automatic assignment operator
05898 static int G__G__MathMore_114_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05899 {
05900    ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>* dest = (ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*) G__getstructoffset();
05901    *dest = *(ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*) libp->para[0].ref;
05902    const ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>& obj = *dest;
05903    result7->ref = (long) (&obj);
05904    result7->obj.i = (long) (&obj);
05905    return(1 || funcname || hash || result7 || libp) ;
05906 }
05907 
05908 
05909 /* ROOT::Math::Derivator */
05910 static int G__G__MathMore_125_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05911 {
05912    ROOT::Math::Derivator* p = NULL;
05913    char* gvp = (char*) G__getgvp();
05914    int n = G__getaryconstruct();
05915    if (n) {
05916      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05917        p = new ROOT::Math::Derivator[n];
05918      } else {
05919        p = new((void*) gvp) ROOT::Math::Derivator[n];
05920      }
05921    } else {
05922      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05923        p = new ROOT::Math::Derivator;
05924      } else {
05925        p = new((void*) gvp) ROOT::Math::Derivator;
05926      }
05927    }
05928    result7->obj.i = (long) p;
05929    result7->ref = (long) p;
05930    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator));
05931    return(1 || funcname || hash || result7 || libp) ;
05932 }
05933 
05934 static int G__G__MathMore_125_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05935 {
05936    ROOT::Math::Derivator* p = NULL;
05937    char* gvp = (char*) G__getgvp();
05938    //m: 1
05939    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05940      p = new ROOT::Math::Derivator(*(ROOT::Math::IGenFunction*) libp->para[0].ref);
05941    } else {
05942      p = new((void*) gvp) ROOT::Math::Derivator(*(ROOT::Math::IGenFunction*) libp->para[0].ref);
05943    }
05944    result7->obj.i = (long) p;
05945    result7->ref = (long) p;
05946    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator));
05947    return(1 || funcname || hash || result7 || libp) ;
05948 }
05949 
05950 static int G__G__MathMore_125_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05951 {
05952    ROOT::Math::Derivator* p = NULL;
05953    char* gvp = (char*) G__getgvp();
05954    switch (libp->paran) {
05955    case 2:
05956      //m: 2
05957      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05958        p = new ROOT::Math::Derivator(libp->para[0].ref ? *(const ROOT::Math::Derivator::GSLFuncPointer*) libp->para[0].ref : *(const ROOT::Math::Derivator::GSLFuncPointer*) (void*) (&G__Mlong(libp->para[0])), (void*) G__int(libp->para[1]));
05959      } else {
05960        p = new((void*) gvp) ROOT::Math::Derivator(libp->para[0].ref ? *(const ROOT::Math::Derivator::GSLFuncPointer*) libp->para[0].ref : *(const ROOT::Math::Derivator::GSLFuncPointer*) (void*) (&G__Mlong(libp->para[0])), (void*) G__int(libp->para[1]));
05961      }
05962      break;
05963    case 1:
05964      //m: 1
05965      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05966        p = new ROOT::Math::Derivator(libp->para[0].ref ? *(const ROOT::Math::Derivator::GSLFuncPointer*) libp->para[0].ref : *(const ROOT::Math::Derivator::GSLFuncPointer*) (void*) (&G__Mlong(libp->para[0])));
05967      } else {
05968        p = new((void*) gvp) ROOT::Math::Derivator(libp->para[0].ref ? *(const ROOT::Math::Derivator::GSLFuncPointer*) libp->para[0].ref : *(const ROOT::Math::Derivator::GSLFuncPointer*) (void*) (&G__Mlong(libp->para[0])));
05969      }
05970      break;
05971    }
05972    result7->obj.i = (long) p;
05973    result7->ref = (long) p;
05974    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator));
05975    return(1 || funcname || hash || result7 || libp) ;
05976 }
05977 
05978 static int G__G__MathMore_125_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05979 {
05980       ((ROOT::Math::Derivator*) G__getstructoffset())->SetFunction(*(ROOT::Math::IGenFunction*) libp->para[0].ref);
05981       G__setnull(result7);
05982    return(1 || funcname || hash || result7 || libp) ;
05983 }
05984 
05985 static int G__G__MathMore_125_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05986 {
05987    switch (libp->paran) {
05988    case 2:
05989       ((ROOT::Math::Derivator*) G__getstructoffset())->SetFunction(libp->para[0].ref ? *(const ROOT::Math::Derivator::GSLFuncPointer*) libp->para[0].ref : *(const ROOT::Math::Derivator::GSLFuncPointer*) (void*) (&G__Mlong(libp->para[0])), (void*) G__int(libp->para[1]));
05990       G__setnull(result7);
05991       break;
05992    case 1:
05993       ((ROOT::Math::Derivator*) G__getstructoffset())->SetFunction(libp->para[0].ref ? *(const ROOT::Math::Derivator::GSLFuncPointer*) libp->para[0].ref : *(const ROOT::Math::Derivator::GSLFuncPointer*) (void*) (&G__Mlong(libp->para[0])));
05994       G__setnull(result7);
05995       break;
05996    }
05997    return(1 || funcname || hash || result7 || libp) ;
05998 }
05999 
06000 static int G__G__MathMore_125_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06001 {
06002    switch (libp->paran) {
06003    case 2:
06004       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->Eval((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
06005       break;
06006    case 1:
06007       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->Eval((double) G__double(libp->para[0])));
06008       break;
06009    }
06010    return(1 || funcname || hash || result7 || libp) ;
06011 }
06012 
06013 static int G__G__MathMore_125_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06014 {
06015    switch (libp->paran) {
06016    case 2:
06017       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->EvalCentral((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
06018       break;
06019    case 1:
06020       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->EvalCentral((double) G__double(libp->para[0])));
06021       break;
06022    }
06023    return(1 || funcname || hash || result7 || libp) ;
06024 }
06025 
06026 static int G__G__MathMore_125_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06027 {
06028    switch (libp->paran) {
06029    case 2:
06030       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->EvalForward((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
06031       break;
06032    case 1:
06033       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->EvalForward((double) G__double(libp->para[0])));
06034       break;
06035    }
06036    return(1 || funcname || hash || result7 || libp) ;
06037 }
06038 
06039 static int G__G__MathMore_125_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06040 {
06041    switch (libp->paran) {
06042    case 2:
06043       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->EvalBackward((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
06044       break;
06045    case 1:
06046       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->EvalBackward((double) G__double(libp->para[0])));
06047       break;
06048    }
06049    return(1 || funcname || hash || result7 || libp) ;
06050 }
06051 
06052 static int G__G__MathMore_125_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06053 {
06054    switch (libp->paran) {
06055    case 3:
06056       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
06057 , (double) G__double(libp->para[2])));
06058       break;
06059    case 2:
06060       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])));
06061       break;
06062    }
06063    return(1 || funcname || hash || result7 || libp) ;
06064 }
06065 
06066 static int G__G__MathMore_125_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06067 {
06068    switch (libp->paran) {
06069    case 3:
06070       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::EvalCentral(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
06071 , (double) G__double(libp->para[2])));
06072       break;
06073    case 2:
06074       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::EvalCentral(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])));
06075       break;
06076    }
06077    return(1 || funcname || hash || result7 || libp) ;
06078 }
06079 
06080 static int G__G__MathMore_125_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06081 {
06082    switch (libp->paran) {
06083    case 3:
06084       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::EvalForward(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
06085 , (double) G__double(libp->para[2])));
06086       break;
06087    case 2:
06088       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::EvalForward(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])));
06089       break;
06090    }
06091    return(1 || funcname || hash || result7 || libp) ;
06092 }
06093 
06094 static int G__G__MathMore_125_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06095 {
06096    switch (libp->paran) {
06097    case 3:
06098       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::EvalBackward(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
06099 , (double) G__double(libp->para[2])));
06100       break;
06101    case 2:
06102       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::EvalBackward(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])));
06103       break;
06104    }
06105    return(1 || funcname || hash || result7 || libp) ;
06106 }
06107 
06108 static int G__G__MathMore_125_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06109 {
06110    switch (libp->paran) {
06111    case 4:
06112       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
06113 , (unsigned int) G__int(libp->para[2]), (double) G__double(libp->para[3])));
06114       break;
06115    case 3:
06116       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
06117 , (unsigned int) G__int(libp->para[2])));
06118       break;
06119    case 2:
06120       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])));
06121       break;
06122    }
06123    return(1 || funcname || hash || result7 || libp) ;
06124 }
06125 
06126 static int G__G__MathMore_125_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06127 {
06128    switch (libp->paran) {
06129    case 5:
06130       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IParamFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
06131 , (double*) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
06132 , (double) G__double(libp->para[4])));
06133       break;
06134    case 4:
06135       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IParamFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
06136 , (double*) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])));
06137       break;
06138    case 3:
06139       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IParamFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
06140 , (double*) G__int(libp->para[2])));
06141       break;
06142    }
06143    return(1 || funcname || hash || result7 || libp) ;
06144 }
06145 
06146 static int G__G__MathMore_125_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06147 {
06148    switch (libp->paran) {
06149    case 5:
06150       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IParamMultiFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
06151 , (double*) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
06152 , (double) G__double(libp->para[4])));
06153       break;
06154    case 4:
06155       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IParamMultiFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
06156 , (double*) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])));
06157       break;
06158    case 3:
06159       G__letdouble(result7, 100, (double) ROOT::Math::Derivator::Eval(*(ROOT::Math::IParamMultiFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
06160 , (double*) G__int(libp->para[2])));
06161       break;
06162    }
06163    return(1 || funcname || hash || result7 || libp) ;
06164 }
06165 
06166 static int G__G__MathMore_125_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06167 {
06168       G__letint(result7, 105, (long) ((const ROOT::Math::Derivator*) G__getstructoffset())->Status());
06169    return(1 || funcname || hash || result7 || libp) ;
06170 }
06171 
06172 static int G__G__MathMore_125_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06173 {
06174       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->Result());
06175    return(1 || funcname || hash || result7 || libp) ;
06176 }
06177 
06178 static int G__G__MathMore_125_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06179 {
06180       G__letdouble(result7, 100, (double) ((const ROOT::Math::Derivator*) G__getstructoffset())->Error());
06181    return(1 || funcname || hash || result7 || libp) ;
06182 }
06183 
06184 // automatic destructor
06185 typedef ROOT::Math::Derivator G__TROOTcLcLMathcLcLDerivator;
06186 static int G__G__MathMore_125_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06187 {
06188    char* gvp = (char*) G__getgvp();
06189    long soff = G__getstructoffset();
06190    int n = G__getaryconstruct();
06191    //
06192    //has_a_delete: 0
06193    //has_own_delete1arg: 0
06194    //has_own_delete2arg: 0
06195    //
06196    if (!soff) {
06197      return(1);
06198    }
06199    if (n) {
06200      if (gvp == (char*)G__PVOID) {
06201        delete[] (ROOT::Math::Derivator*) soff;
06202      } else {
06203        G__setgvp((long) G__PVOID);
06204        for (int i = n - 1; i >= 0; --i) {
06205          ((ROOT::Math::Derivator*) (soff+(sizeof(ROOT::Math::Derivator)*i)))->~G__TROOTcLcLMathcLcLDerivator();
06206        }
06207        G__setgvp((long)gvp);
06208      }
06209    } else {
06210      if (gvp == (char*)G__PVOID) {
06211        delete (ROOT::Math::Derivator*) soff;
06212      } else {
06213        G__setgvp((long) G__PVOID);
06214        ((ROOT::Math::Derivator*) (soff))->~G__TROOTcLcLMathcLcLDerivator();
06215        G__setgvp((long)gvp);
06216      }
06217    }
06218    G__setnull(result7);
06219    return(1 || funcname || hash || result7 || libp) ;
06220 }
06221 
06222 
06223 /* ROOT::Math::Interpolator */
06224 static int G__G__MathMore_129_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06225 {
06226    ROOT::Math::Interpolator* p = NULL;
06227    char* gvp = (char*) G__getgvp();
06228    switch (libp->paran) {
06229    case 2:
06230      //m: 2
06231      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06232        p = new ROOT::Math::Interpolator((unsigned int) G__int(libp->para[0]), (ROOT::Math::Interpolation::Type) G__int(libp->para[1]));
06233      } else {
06234        p = new((void*) gvp) ROOT::Math::Interpolator((unsigned int) G__int(libp->para[0]), (ROOT::Math::Interpolation::Type) G__int(libp->para[1]));
06235      }
06236      break;
06237    case 1:
06238      //m: 1
06239      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06240        p = new ROOT::Math::Interpolator((unsigned int) G__int(libp->para[0]));
06241      } else {
06242        p = new((void*) gvp) ROOT::Math::Interpolator((unsigned int) G__int(libp->para[0]));
06243      }
06244      break;
06245    case 0:
06246      int n = G__getaryconstruct();
06247      if (n) {
06248        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06249          p = new ROOT::Math::Interpolator[n];
06250        } else {
06251          p = new((void*) gvp) ROOT::Math::Interpolator[n];
06252        }
06253      } else {
06254        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06255          p = new ROOT::Math::Interpolator;
06256        } else {
06257          p = new((void*) gvp) ROOT::Math::Interpolator;
06258        }
06259      }
06260      break;
06261    }
06262    result7->obj.i = (long) p;
06263    result7->ref = (long) p;
06264    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator));
06265    return(1 || funcname || hash || result7 || libp) ;
06266 }
06267 
06268 static int G__G__MathMore_129_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06269 {
06270    ROOT::Math::Interpolator* p = NULL;
06271    char* gvp = (char*) G__getgvp();
06272    switch (libp->paran) {
06273    case 3:
06274      //m: 3
06275      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06276        p = new ROOT::Math::Interpolator(
06277 *(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
06278 , (ROOT::Math::Interpolation::Type) G__int(libp->para[2]));
06279      } else {
06280        p = new((void*) gvp) ROOT::Math::Interpolator(
06281 *(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
06282 , (ROOT::Math::Interpolation::Type) G__int(libp->para[2]));
06283      }
06284      break;
06285    case 2:
06286      //m: 2
06287      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06288        p = new ROOT::Math::Interpolator(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
06289      } else {
06290        p = new((void*) gvp) ROOT::Math::Interpolator(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
06291      }
06292      break;
06293    }
06294    result7->obj.i = (long) p;
06295    result7->ref = (long) p;
06296    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator));
06297    return(1 || funcname || hash || result7 || libp) ;
06298 }
06299 
06300 static int G__G__MathMore_129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06301 {
06302       G__letint(result7, 103, (long) ((ROOT::Math::Interpolator*) G__getstructoffset())->SetData(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref));
06303    return(1 || funcname || hash || result7 || libp) ;
06304 }
06305 
06306 static int G__G__MathMore_129_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06307 {
06308       G__letint(result7, 103, (long) ((ROOT::Math::Interpolator*) G__getstructoffset())->SetData((unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
06309 , (double*) G__int(libp->para[2])));
06310    return(1 || funcname || hash || result7 || libp) ;
06311 }
06312 
06313 static int G__G__MathMore_129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06314 {
06315       G__letdouble(result7, 100, (double) ((const ROOT::Math::Interpolator*) G__getstructoffset())->Eval((double) G__double(libp->para[0])));
06316    return(1 || funcname || hash || result7 || libp) ;
06317 }
06318 
06319 static int G__G__MathMore_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06320 {
06321       G__letdouble(result7, 100, (double) ((const ROOT::Math::Interpolator*) G__getstructoffset())->Deriv((double) G__double(libp->para[0])));
06322    return(1 || funcname || hash || result7 || libp) ;
06323 }
06324 
06325 static int G__G__MathMore_129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06326 {
06327       G__letdouble(result7, 100, (double) ((const ROOT::Math::Interpolator*) G__getstructoffset())->Deriv2((double) G__double(libp->para[0])));
06328    return(1 || funcname || hash || result7 || libp) ;
06329 }
06330 
06331 static int G__G__MathMore_129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06332 {
06333       G__letdouble(result7, 100, (double) ((const ROOT::Math::Interpolator*) G__getstructoffset())->Integ((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
06334    return(1 || funcname || hash || result7 || libp) ;
06335 }
06336 
06337 static int G__G__MathMore_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06338 {
06339       {
06340          const string* pobj;
06341          const string xobj = ((const ROOT::Math::Interpolator*) G__getstructoffset())->Type();
06342          pobj = new string(xobj);
06343          result7->obj.i = (long) ((void*) pobj);
06344          result7->ref = result7->obj.i;
06345          G__store_tempobject(*result7);
06346       }
06347    return(1 || funcname || hash || result7 || libp) ;
06348 }
06349 
06350 static int G__G__MathMore_129_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06351 {
06352       {
06353          const string* pobj;
06354          const string xobj = ((const ROOT::Math::Interpolator*) G__getstructoffset())->TypeGet();
06355          pobj = new string(xobj);
06356          result7->obj.i = (long) ((void*) pobj);
06357          result7->ref = result7->obj.i;
06358          G__store_tempobject(*result7);
06359       }
06360    return(1 || funcname || hash || result7 || libp) ;
06361 }
06362 
06363 // automatic destructor
06364 typedef ROOT::Math::Interpolator G__TROOTcLcLMathcLcLInterpolator;
06365 static int G__G__MathMore_129_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06366 {
06367    char* gvp = (char*) G__getgvp();
06368    long soff = G__getstructoffset();
06369    int n = G__getaryconstruct();
06370    //
06371    //has_a_delete: 0
06372    //has_own_delete1arg: 0
06373    //has_own_delete2arg: 0
06374    //
06375    if (!soff) {
06376      return(1);
06377    }
06378    if (n) {
06379      if (gvp == (char*)G__PVOID) {
06380        delete[] (ROOT::Math::Interpolator*) soff;
06381      } else {
06382        G__setgvp((long) G__PVOID);
06383        for (int i = n - 1; i >= 0; --i) {
06384          ((ROOT::Math::Interpolator*) (soff+(sizeof(ROOT::Math::Interpolator)*i)))->~G__TROOTcLcLMathcLcLInterpolator();
06385        }
06386        G__setgvp((long)gvp);
06387      }
06388    } else {
06389      if (gvp == (char*)G__PVOID) {
06390        delete (ROOT::Math::Interpolator*) soff;
06391      } else {
06392        G__setgvp((long) G__PVOID);
06393        ((ROOT::Math::Interpolator*) (soff))->~G__TROOTcLcLMathcLcLInterpolator();
06394        G__setgvp((long)gvp);
06395      }
06396    }
06397    G__setnull(result7);
06398    return(1 || funcname || hash || result7 || libp) ;
06399 }
06400 
06401 
06402 /* ROOT::Math::GSLRootFinder */
06403 static int G__G__MathMore_133_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06404 {
06405    ROOT::Math::GSLRootFinder* p = NULL;
06406    char* gvp = (char*) G__getgvp();
06407    int n = G__getaryconstruct();
06408    if (n) {
06409      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06410        p = new ROOT::Math::GSLRootFinder[n];
06411      } else {
06412        p = new((void*) gvp) ROOT::Math::GSLRootFinder[n];
06413      }
06414    } else {
06415      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06416        p = new ROOT::Math::GSLRootFinder;
06417      } else {
06418        p = new((void*) gvp) ROOT::Math::GSLRootFinder;
06419      }
06420    }
06421    result7->obj.i = (long) p;
06422    result7->ref = (long) p;
06423    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder));
06424    return(1 || funcname || hash || result7 || libp) ;
06425 }
06426 
06427 static int G__G__MathMore_133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06428 {
06429       G__letint(result7, 103, (long) ((ROOT::Math::GSLRootFinder*) G__getstructoffset())->SetFunction((ROOT::Math::GSLRootFinder::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
06430 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
06431    return(1 || funcname || hash || result7 || libp) ;
06432 }
06433 
06434 // automatic destructor
06435 typedef ROOT::Math::GSLRootFinder G__TROOTcLcLMathcLcLGSLRootFinder;
06436 static int G__G__MathMore_133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06437 {
06438    char* gvp = (char*) G__getgvp();
06439    long soff = G__getstructoffset();
06440    int n = G__getaryconstruct();
06441    //
06442    //has_a_delete: 0
06443    //has_own_delete1arg: 0
06444    //has_own_delete2arg: 0
06445    //
06446    if (!soff) {
06447      return(1);
06448    }
06449    if (n) {
06450      if (gvp == (char*)G__PVOID) {
06451        delete[] (ROOT::Math::GSLRootFinder*) soff;
06452      } else {
06453        G__setgvp((long) G__PVOID);
06454        for (int i = n - 1; i >= 0; --i) {
06455          ((ROOT::Math::GSLRootFinder*) (soff+(sizeof(ROOT::Math::GSLRootFinder)*i)))->~G__TROOTcLcLMathcLcLGSLRootFinder();
06456        }
06457        G__setgvp((long)gvp);
06458      }
06459    } else {
06460      if (gvp == (char*)G__PVOID) {
06461        delete (ROOT::Math::GSLRootFinder*) soff;
06462      } else {
06463        G__setgvp((long) G__PVOID);
06464        ((ROOT::Math::GSLRootFinder*) (soff))->~G__TROOTcLcLMathcLcLGSLRootFinder();
06465        G__setgvp((long)gvp);
06466      }
06467    }
06468    G__setnull(result7);
06469    return(1 || funcname || hash || result7 || libp) ;
06470 }
06471 
06472 
06473 /* ROOT::Math::GSLRootFinderDeriv */
06474 static int G__G__MathMore_136_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06475 {
06476    ROOT::Math::GSLRootFinderDeriv* p = NULL;
06477    char* gvp = (char*) G__getgvp();
06478    int n = G__getaryconstruct();
06479    if (n) {
06480      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06481        p = new ROOT::Math::GSLRootFinderDeriv[n];
06482      } else {
06483        p = new((void*) gvp) ROOT::Math::GSLRootFinderDeriv[n];
06484      }
06485    } else {
06486      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06487        p = new ROOT::Math::GSLRootFinderDeriv;
06488      } else {
06489        p = new((void*) gvp) ROOT::Math::GSLRootFinderDeriv;
06490      }
06491    }
06492    result7->obj.i = (long) p;
06493    result7->ref = (long) p;
06494    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv));
06495    return(1 || funcname || hash || result7 || libp) ;
06496 }
06497 
06498 static int G__G__MathMore_136_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06499 {
06500       G__letint(result7, 103, (long) ((ROOT::Math::GSLRootFinderDeriv*) G__getstructoffset())->SetFunction((ROOT::Math::GSLRootFinderDeriv::GSLFuncPointer) G__int(libp->para[0]), (ROOT::Math::GSLRootFinderDeriv::GSLFuncPointer) G__int(libp->para[1])
06501 , (ROOT::Math::GSLRootFinderDeriv::GSLFdFPointer) G__int(libp->para[2]), (void*) G__int(libp->para[3])
06502 , (double) G__double(libp->para[4])));
06503    return(1 || funcname || hash || result7 || libp) ;
06504 }
06505 
06506 // automatic destructor
06507 typedef ROOT::Math::GSLRootFinderDeriv G__TROOTcLcLMathcLcLGSLRootFinderDeriv;
06508 static int G__G__MathMore_136_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06509 {
06510    char* gvp = (char*) G__getgvp();
06511    long soff = G__getstructoffset();
06512    int n = G__getaryconstruct();
06513    //
06514    //has_a_delete: 0
06515    //has_own_delete1arg: 0
06516    //has_own_delete2arg: 0
06517    //
06518    if (!soff) {
06519      return(1);
06520    }
06521    if (n) {
06522      if (gvp == (char*)G__PVOID) {
06523        delete[] (ROOT::Math::GSLRootFinderDeriv*) soff;
06524      } else {
06525        G__setgvp((long) G__PVOID);
06526        for (int i = n - 1; i >= 0; --i) {
06527          ((ROOT::Math::GSLRootFinderDeriv*) (soff+(sizeof(ROOT::Math::GSLRootFinderDeriv)*i)))->~G__TROOTcLcLMathcLcLGSLRootFinderDeriv();
06528        }
06529        G__setgvp((long)gvp);
06530      }
06531    } else {
06532      if (gvp == (char*)G__PVOID) {
06533        delete (ROOT::Math::GSLRootFinderDeriv*) soff;
06534      } else {
06535        G__setgvp((long) G__PVOID);
06536        ((ROOT::Math::GSLRootFinderDeriv*) (soff))->~G__TROOTcLcLMathcLcLGSLRootFinderDeriv();
06537        G__setgvp((long)gvp);
06538      }
06539    }
06540    G__setnull(result7);
06541    return(1 || funcname || hash || result7 || libp) ;
06542 }
06543 
06544 
06545 /* ROOT::Math::Roots */
06546 
06547 /* ROOT::Math::Roots::Bisection */
06548 static int G__G__MathMore_138_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06549 {
06550    ROOT::Math::Roots::Bisection* p = NULL;
06551    char* gvp = (char*) G__getgvp();
06552    int n = G__getaryconstruct();
06553    if (n) {
06554      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06555        p = new ROOT::Math::Roots::Bisection[n];
06556      } else {
06557        p = new((void*) gvp) ROOT::Math::Roots::Bisection[n];
06558      }
06559    } else {
06560      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06561        p = new ROOT::Math::Roots::Bisection;
06562      } else {
06563        p = new((void*) gvp) ROOT::Math::Roots::Bisection;
06564      }
06565    }
06566    result7->obj.i = (long) p;
06567    result7->ref = (long) p;
06568    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection));
06569    return(1 || funcname || hash || result7 || libp) ;
06570 }
06571 
06572 // automatic destructor
06573 typedef ROOT::Math::Roots::Bisection G__TROOTcLcLMathcLcLRootscLcLBisection;
06574 static int G__G__MathMore_138_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06575 {
06576    char* gvp = (char*) G__getgvp();
06577    long soff = G__getstructoffset();
06578    int n = G__getaryconstruct();
06579    //
06580    //has_a_delete: 0
06581    //has_own_delete1arg: 0
06582    //has_own_delete2arg: 0
06583    //
06584    if (!soff) {
06585      return(1);
06586    }
06587    if (n) {
06588      if (gvp == (char*)G__PVOID) {
06589        delete[] (ROOT::Math::Roots::Bisection*) soff;
06590      } else {
06591        G__setgvp((long) G__PVOID);
06592        for (int i = n - 1; i >= 0; --i) {
06593          ((ROOT::Math::Roots::Bisection*) (soff+(sizeof(ROOT::Math::Roots::Bisection)*i)))->~G__TROOTcLcLMathcLcLRootscLcLBisection();
06594        }
06595        G__setgvp((long)gvp);
06596      }
06597    } else {
06598      if (gvp == (char*)G__PVOID) {
06599        delete (ROOT::Math::Roots::Bisection*) soff;
06600      } else {
06601        G__setgvp((long) G__PVOID);
06602        ((ROOT::Math::Roots::Bisection*) (soff))->~G__TROOTcLcLMathcLcLRootscLcLBisection();
06603        G__setgvp((long)gvp);
06604      }
06605    }
06606    G__setnull(result7);
06607    return(1 || funcname || hash || result7 || libp) ;
06608 }
06609 
06610 
06611 /* ROOT::Math::Roots::FalsePos */
06612 static int G__G__MathMore_139_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06613 {
06614    ROOT::Math::Roots::FalsePos* p = NULL;
06615    char* gvp = (char*) G__getgvp();
06616    int n = G__getaryconstruct();
06617    if (n) {
06618      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06619        p = new ROOT::Math::Roots::FalsePos[n];
06620      } else {
06621        p = new((void*) gvp) ROOT::Math::Roots::FalsePos[n];
06622      }
06623    } else {
06624      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06625        p = new ROOT::Math::Roots::FalsePos;
06626      } else {
06627        p = new((void*) gvp) ROOT::Math::Roots::FalsePos;
06628      }
06629    }
06630    result7->obj.i = (long) p;
06631    result7->ref = (long) p;
06632    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos));
06633    return(1 || funcname || hash || result7 || libp) ;
06634 }
06635 
06636 // automatic destructor
06637 typedef ROOT::Math::Roots::FalsePos G__TROOTcLcLMathcLcLRootscLcLFalsePos;
06638 static int G__G__MathMore_139_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06639 {
06640    char* gvp = (char*) G__getgvp();
06641    long soff = G__getstructoffset();
06642    int n = G__getaryconstruct();
06643    //
06644    //has_a_delete: 0
06645    //has_own_delete1arg: 0
06646    //has_own_delete2arg: 0
06647    //
06648    if (!soff) {
06649      return(1);
06650    }
06651    if (n) {
06652      if (gvp == (char*)G__PVOID) {
06653        delete[] (ROOT::Math::Roots::FalsePos*) soff;
06654      } else {
06655        G__setgvp((long) G__PVOID);
06656        for (int i = n - 1; i >= 0; --i) {
06657          ((ROOT::Math::Roots::FalsePos*) (soff+(sizeof(ROOT::Math::Roots::FalsePos)*i)))->~G__TROOTcLcLMathcLcLRootscLcLFalsePos();
06658        }
06659        G__setgvp((long)gvp);
06660      }
06661    } else {
06662      if (gvp == (char*)G__PVOID) {
06663        delete (ROOT::Math::Roots::FalsePos*) soff;
06664      } else {
06665        G__setgvp((long) G__PVOID);
06666        ((ROOT::Math::Roots::FalsePos*) (soff))->~G__TROOTcLcLMathcLcLRootscLcLFalsePos();
06667        G__setgvp((long)gvp);
06668      }
06669    }
06670    G__setnull(result7);
06671    return(1 || funcname || hash || result7 || libp) ;
06672 }
06673 
06674 
06675 /* ROOT::Math::Roots::Brent */
06676 static int G__G__MathMore_140_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06677 {
06678    ROOT::Math::Roots::Brent* p = NULL;
06679    char* gvp = (char*) G__getgvp();
06680    int n = G__getaryconstruct();
06681    if (n) {
06682      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06683        p = new ROOT::Math::Roots::Brent[n];
06684      } else {
06685        p = new((void*) gvp) ROOT::Math::Roots::Brent[n];
06686      }
06687    } else {
06688      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06689        p = new ROOT::Math::Roots::Brent;
06690      } else {
06691        p = new((void*) gvp) ROOT::Math::Roots::Brent;
06692      }
06693    }
06694    result7->obj.i = (long) p;
06695    result7->ref = (long) p;
06696    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent));
06697    return(1 || funcname || hash || result7 || libp) ;
06698 }
06699 
06700 // automatic destructor
06701 typedef ROOT::Math::Roots::Brent G__TROOTcLcLMathcLcLRootscLcLBrent;
06702 static int G__G__MathMore_140_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06703 {
06704    char* gvp = (char*) G__getgvp();
06705    long soff = G__getstructoffset();
06706    int n = G__getaryconstruct();
06707    //
06708    //has_a_delete: 0
06709    //has_own_delete1arg: 0
06710    //has_own_delete2arg: 0
06711    //
06712    if (!soff) {
06713      return(1);
06714    }
06715    if (n) {
06716      if (gvp == (char*)G__PVOID) {
06717        delete[] (ROOT::Math::Roots::Brent*) soff;
06718      } else {
06719        G__setgvp((long) G__PVOID);
06720        for (int i = n - 1; i >= 0; --i) {
06721          ((ROOT::Math::Roots::Brent*) (soff+(sizeof(ROOT::Math::Roots::Brent)*i)))->~G__TROOTcLcLMathcLcLRootscLcLBrent();
06722        }
06723        G__setgvp((long)gvp);
06724      }
06725    } else {
06726      if (gvp == (char*)G__PVOID) {
06727        delete (ROOT::Math::Roots::Brent*) soff;
06728      } else {
06729        G__setgvp((long) G__PVOID);
06730        ((ROOT::Math::Roots::Brent*) (soff))->~G__TROOTcLcLMathcLcLRootscLcLBrent();
06731        G__setgvp((long)gvp);
06732      }
06733    }
06734    G__setnull(result7);
06735    return(1 || funcname || hash || result7 || libp) ;
06736 }
06737 
06738 
06739 /* ROOT::Math::Roots::Newton */
06740 static int G__G__MathMore_141_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06741 {
06742    ROOT::Math::Roots::Newton* p = NULL;
06743    char* gvp = (char*) G__getgvp();
06744    int n = G__getaryconstruct();
06745    if (n) {
06746      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06747        p = new ROOT::Math::Roots::Newton[n];
06748      } else {
06749        p = new((void*) gvp) ROOT::Math::Roots::Newton[n];
06750      }
06751    } else {
06752      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06753        p = new ROOT::Math::Roots::Newton;
06754      } else {
06755        p = new((void*) gvp) ROOT::Math::Roots::Newton;
06756      }
06757    }
06758    result7->obj.i = (long) p;
06759    result7->ref = (long) p;
06760    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton));
06761    return(1 || funcname || hash || result7 || libp) ;
06762 }
06763 
06764 // automatic destructor
06765 typedef ROOT::Math::Roots::Newton G__TROOTcLcLMathcLcLRootscLcLNewton;
06766 static int G__G__MathMore_141_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06767 {
06768    char* gvp = (char*) G__getgvp();
06769    long soff = G__getstructoffset();
06770    int n = G__getaryconstruct();
06771    //
06772    //has_a_delete: 0
06773    //has_own_delete1arg: 0
06774    //has_own_delete2arg: 0
06775    //
06776    if (!soff) {
06777      return(1);
06778    }
06779    if (n) {
06780      if (gvp == (char*)G__PVOID) {
06781        delete[] (ROOT::Math::Roots::Newton*) soff;
06782      } else {
06783        G__setgvp((long) G__PVOID);
06784        for (int i = n - 1; i >= 0; --i) {
06785          ((ROOT::Math::Roots::Newton*) (soff+(sizeof(ROOT::Math::Roots::Newton)*i)))->~G__TROOTcLcLMathcLcLRootscLcLNewton();
06786        }
06787        G__setgvp((long)gvp);
06788      }
06789    } else {
06790      if (gvp == (char*)G__PVOID) {
06791        delete (ROOT::Math::Roots::Newton*) soff;
06792      } else {
06793        G__setgvp((long) G__PVOID);
06794        ((ROOT::Math::Roots::Newton*) (soff))->~G__TROOTcLcLMathcLcLRootscLcLNewton();
06795        G__setgvp((long)gvp);
06796      }
06797    }
06798    G__setnull(result7);
06799    return(1 || funcname || hash || result7 || libp) ;
06800 }
06801 
06802 
06803 /* ROOT::Math::Roots::Secant */
06804 static int G__G__MathMore_142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06805 {
06806    ROOT::Math::Roots::Secant* p = NULL;
06807    char* gvp = (char*) G__getgvp();
06808    int n = G__getaryconstruct();
06809    if (n) {
06810      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06811        p = new ROOT::Math::Roots::Secant[n];
06812      } else {
06813        p = new((void*) gvp) ROOT::Math::Roots::Secant[n];
06814      }
06815    } else {
06816      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06817        p = new ROOT::Math::Roots::Secant;
06818      } else {
06819        p = new((void*) gvp) ROOT::Math::Roots::Secant;
06820      }
06821    }
06822    result7->obj.i = (long) p;
06823    result7->ref = (long) p;
06824    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant));
06825    return(1 || funcname || hash || result7 || libp) ;
06826 }
06827 
06828 // automatic destructor
06829 typedef ROOT::Math::Roots::Secant G__TROOTcLcLMathcLcLRootscLcLSecant;
06830 static int G__G__MathMore_142_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06831 {
06832    char* gvp = (char*) G__getgvp();
06833    long soff = G__getstructoffset();
06834    int n = G__getaryconstruct();
06835    //
06836    //has_a_delete: 0
06837    //has_own_delete1arg: 0
06838    //has_own_delete2arg: 0
06839    //
06840    if (!soff) {
06841      return(1);
06842    }
06843    if (n) {
06844      if (gvp == (char*)G__PVOID) {
06845        delete[] (ROOT::Math::Roots::Secant*) soff;
06846      } else {
06847        G__setgvp((long) G__PVOID);
06848        for (int i = n - 1; i >= 0; --i) {
06849          ((ROOT::Math::Roots::Secant*) (soff+(sizeof(ROOT::Math::Roots::Secant)*i)))->~G__TROOTcLcLMathcLcLRootscLcLSecant();
06850        }
06851        G__setgvp((long)gvp);
06852      }
06853    } else {
06854      if (gvp == (char*)G__PVOID) {
06855        delete (ROOT::Math::Roots::Secant*) soff;
06856      } else {
06857        G__setgvp((long) G__PVOID);
06858        ((ROOT::Math::Roots::Secant*) (soff))->~G__TROOTcLcLMathcLcLRootscLcLSecant();
06859        G__setgvp((long)gvp);
06860      }
06861    }
06862    G__setnull(result7);
06863    return(1 || funcname || hash || result7 || libp) ;
06864 }
06865 
06866 
06867 /* ROOT::Math::Roots::Steffenson */
06868 static int G__G__MathMore_143_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06869 {
06870    ROOT::Math::Roots::Steffenson* p = NULL;
06871    char* gvp = (char*) G__getgvp();
06872    int n = G__getaryconstruct();
06873    if (n) {
06874      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06875        p = new ROOT::Math::Roots::Steffenson[n];
06876      } else {
06877        p = new((void*) gvp) ROOT::Math::Roots::Steffenson[n];
06878      }
06879    } else {
06880      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06881        p = new ROOT::Math::Roots::Steffenson;
06882      } else {
06883        p = new((void*) gvp) ROOT::Math::Roots::Steffenson;
06884      }
06885    }
06886    result7->obj.i = (long) p;
06887    result7->ref = (long) p;
06888    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson));
06889    return(1 || funcname || hash || result7 || libp) ;
06890 }
06891 
06892 // automatic destructor
06893 typedef ROOT::Math::Roots::Steffenson G__TROOTcLcLMathcLcLRootscLcLSteffenson;
06894 static int G__G__MathMore_143_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06895 {
06896    char* gvp = (char*) G__getgvp();
06897    long soff = G__getstructoffset();
06898    int n = G__getaryconstruct();
06899    //
06900    //has_a_delete: 0
06901    //has_own_delete1arg: 0
06902    //has_own_delete2arg: 0
06903    //
06904    if (!soff) {
06905      return(1);
06906    }
06907    if (n) {
06908      if (gvp == (char*)G__PVOID) {
06909        delete[] (ROOT::Math::Roots::Steffenson*) soff;
06910      } else {
06911        G__setgvp((long) G__PVOID);
06912        for (int i = n - 1; i >= 0; --i) {
06913          ((ROOT::Math::Roots::Steffenson*) (soff+(sizeof(ROOT::Math::Roots::Steffenson)*i)))->~G__TROOTcLcLMathcLcLRootscLcLSteffenson();
06914        }
06915        G__setgvp((long)gvp);
06916      }
06917    } else {
06918      if (gvp == (char*)G__PVOID) {
06919        delete (ROOT::Math::Roots::Steffenson*) soff;
06920      } else {
06921        G__setgvp((long) G__PVOID);
06922        ((ROOT::Math::Roots::Steffenson*) (soff))->~G__TROOTcLcLMathcLcLRootscLcLSteffenson();
06923        G__setgvp((long)gvp);
06924      }
06925    }
06926    G__setnull(result7);
06927    return(1 || funcname || hash || result7 || libp) ;
06928 }
06929 
06930 
06931 /* ROOT::Math::Integration */
06932 
06933 /* ROOT::Math::GSLIntegrator */
06934 static int G__G__MathMore_158_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06935 {
06936    ROOT::Math::GSLIntegrator* p = NULL;
06937    char* gvp = (char*) G__getgvp();
06938    switch (libp->paran) {
06939    case 3:
06940      //m: 3
06941      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06942        p = new ROOT::Math::GSLIntegrator(
06943 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
06944 , (size_t) G__int(libp->para[2]));
06945      } else {
06946        p = new((void*) gvp) ROOT::Math::GSLIntegrator(
06947 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
06948 , (size_t) G__int(libp->para[2]));
06949      }
06950      break;
06951    case 2:
06952      //m: 2
06953      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06954        p = new ROOT::Math::GSLIntegrator((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
06955      } else {
06956        p = new((void*) gvp) ROOT::Math::GSLIntegrator((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
06957      }
06958      break;
06959    case 1:
06960      //m: 1
06961      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06962        p = new ROOT::Math::GSLIntegrator((double) G__double(libp->para[0]));
06963      } else {
06964        p = new((void*) gvp) ROOT::Math::GSLIntegrator((double) G__double(libp->para[0]));
06965      }
06966      break;
06967    case 0:
06968      int n = G__getaryconstruct();
06969      if (n) {
06970        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06971          p = new ROOT::Math::GSLIntegrator[n];
06972        } else {
06973          p = new((void*) gvp) ROOT::Math::GSLIntegrator[n];
06974        }
06975      } else {
06976        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06977          p = new ROOT::Math::GSLIntegrator;
06978        } else {
06979          p = new((void*) gvp) ROOT::Math::GSLIntegrator;
06980        }
06981      }
06982      break;
06983    }
06984    result7->obj.i = (long) p;
06985    result7->ref = (long) p;
06986    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator));
06987    return(1 || funcname || hash || result7 || libp) ;
06988 }
06989 
06990 static int G__G__MathMore_158_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06991 {
06992    ROOT::Math::GSLIntegrator* p = NULL;
06993    char* gvp = (char*) G__getgvp();
06994    switch (libp->paran) {
06995    case 4:
06996      //m: 4
06997      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06998        p = new ROOT::Math::GSLIntegrator(
06999 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07000 , (double) G__double(libp->para[2]), (size_t) G__int(libp->para[3]));
07001      } else {
07002        p = new((void*) gvp) ROOT::Math::GSLIntegrator(
07003 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07004 , (double) G__double(libp->para[2]), (size_t) G__int(libp->para[3]));
07005      }
07006      break;
07007    case 3:
07008      //m: 3
07009      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07010        p = new ROOT::Math::GSLIntegrator(
07011 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07012 , (double) G__double(libp->para[2]));
07013      } else {
07014        p = new((void*) gvp) ROOT::Math::GSLIntegrator(
07015 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07016 , (double) G__double(libp->para[2]));
07017      }
07018      break;
07019    case 2:
07020      //m: 2
07021      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07022        p = new ROOT::Math::GSLIntegrator((const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1]));
07023      } else {
07024        p = new((void*) gvp) ROOT::Math::GSLIntegrator((const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1]));
07025      }
07026      break;
07027    case 1:
07028      //m: 1
07029      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07030        p = new ROOT::Math::GSLIntegrator((const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]));
07031      } else {
07032        p = new((void*) gvp) ROOT::Math::GSLIntegrator((const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]));
07033      }
07034      break;
07035    }
07036    result7->obj.i = (long) p;
07037    result7->ref = (long) p;
07038    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator));
07039    return(1 || funcname || hash || result7 || libp) ;
07040 }
07041 
07042 static int G__G__MathMore_158_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07043 {
07044    ROOT::Math::GSLIntegrator* p = NULL;
07045    char* gvp = (char*) G__getgvp();
07046    switch (libp->paran) {
07047    case 5:
07048      //m: 5
07049      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07050        p = new ROOT::Math::GSLIntegrator(
07051 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1])
07052 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
07053 , (size_t) G__int(libp->para[4]));
07054      } else {
07055        p = new((void*) gvp) ROOT::Math::GSLIntegrator(
07056 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1])
07057 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
07058 , (size_t) G__int(libp->para[4]));
07059      }
07060      break;
07061    case 4:
07062      //m: 4
07063      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07064        p = new ROOT::Math::GSLIntegrator(
07065 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1])
07066 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
07067      } else {
07068        p = new((void*) gvp) ROOT::Math::GSLIntegrator(
07069 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1])
07070 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
07071      }
07072      break;
07073    case 3:
07074      //m: 3
07075      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07076        p = new ROOT::Math::GSLIntegrator(
07077 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1])
07078 , (double) G__double(libp->para[2]));
07079      } else {
07080        p = new((void*) gvp) ROOT::Math::GSLIntegrator(
07081 (const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1])
07082 , (double) G__double(libp->para[2]));
07083      }
07084      break;
07085    case 2:
07086      //m: 2
07087      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07088        p = new ROOT::Math::GSLIntegrator((const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1]));
07089      } else {
07090        p = new((void*) gvp) ROOT::Math::GSLIntegrator((const ROOT::Math::IntegrationOneDim::Type) G__int(libp->para[0]), (const ROOT::Math::Integration::GKRule) G__int(libp->para[1]));
07091      }
07092      break;
07093    }
07094    result7->obj.i = (long) p;
07095    result7->ref = (long) p;
07096    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator));
07097    return(1 || funcname || hash || result7 || libp) ;
07098 }
07099 
07100 static int G__G__MathMore_158_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07101 {
07102    ROOT::Math::GSLIntegrator* p = NULL;
07103    char* gvp = (char*) G__getgvp();
07104    //m: 5
07105    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07106      p = new ROOT::Math::GSLIntegrator(
07107 (const char*) G__int(libp->para[0]), (int) G__int(libp->para[1])
07108 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
07109 , (size_t) G__int(libp->para[4]));
07110    } else {
07111      p = new((void*) gvp) ROOT::Math::GSLIntegrator(
07112 (const char*) G__int(libp->para[0]), (int) G__int(libp->para[1])
07113 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
07114 , (size_t) G__int(libp->para[4]));
07115    }
07116    result7->obj.i = (long) p;
07117    result7->ref = (long) p;
07118    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator));
07119    return(1 || funcname || hash || result7 || libp) ;
07120 }
07121 
07122 static int G__G__MathMore_158_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07123 {
07124    switch (libp->paran) {
07125    case 2:
07126       ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->SetFunction((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1]));
07127       G__setnull(result7);
07128       break;
07129    case 1:
07130       ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->SetFunction((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]));
07131       G__setnull(result7);
07132       break;
07133    }
07134    return(1 || funcname || hash || result7 || libp) ;
07135 }
07136 
07137 static int G__G__MathMore_158_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07138 {
07139       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->Integral(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
07140 , (double) G__double(libp->para[2])));
07141    return(1 || funcname || hash || result7 || libp) ;
07142 }
07143 
07144 static int G__G__MathMore_158_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07145 {
07146       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->Integral(*(ROOT::Math::IGenFunction*) libp->para[0].ref));
07147    return(1 || funcname || hash || result7 || libp) ;
07148 }
07149 
07150 static int G__G__MathMore_158_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07151 {
07152       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->IntegralCauchy(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
07153 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
07154    return(1 || funcname || hash || result7 || libp) ;
07155 }
07156 
07157 static int G__G__MathMore_158_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07158 {
07159       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->IntegralUp(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])));
07160    return(1 || funcname || hash || result7 || libp) ;
07161 }
07162 
07163 static int G__G__MathMore_158_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07164 {
07165       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->IntegralLow(*(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])));
07166    return(1 || funcname || hash || result7 || libp) ;
07167 }
07168 
07169 static int G__G__MathMore_158_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07170 {
07171       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->Integral(*(ROOT::Math::IGenFunction*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref));
07172    return(1 || funcname || hash || result7 || libp) ;
07173 }
07174 
07175 static int G__G__MathMore_158_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07176 {
07177       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->Integral((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
07178 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
07179    return(1 || funcname || hash || result7 || libp) ;
07180 }
07181 
07182 static int G__G__MathMore_158_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07183 {
07184       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->Integral((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])));
07185    return(1 || funcname || hash || result7 || libp) ;
07186 }
07187 
07188 static int G__G__MathMore_158_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07189 {
07190       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->IntegralUp((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
07191 , (double) G__double(libp->para[2])));
07192    return(1 || funcname || hash || result7 || libp) ;
07193 }
07194 
07195 static int G__G__MathMore_158_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07196 {
07197       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->IntegralLow((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
07198 , (double) G__double(libp->para[2])));
07199    return(1 || funcname || hash || result7 || libp) ;
07200 }
07201 
07202 static int G__G__MathMore_158_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07203 {
07204       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->Integral((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
07205 , *(vector<double>*) libp->para[2].ref));
07206    return(1 || funcname || hash || result7 || libp) ;
07207 }
07208 
07209 static int G__G__MathMore_158_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07210 {
07211       ((ROOT::Math::GSLIntegrator*) G__getstructoffset())->SetIntegrationRule((ROOT::Math::Integration::GKRule) G__int(libp->para[0]));
07212       G__setnull(result7);
07213    return(1 || funcname || hash || result7 || libp) ;
07214 }
07215 
07216 static int G__G__MathMore_158_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07217 {
07218       G__letint(result7, 105, (long) ((const ROOT::Math::GSLIntegrator*) G__getstructoffset())->GetType());
07219    return(1 || funcname || hash || result7 || libp) ;
07220 }
07221 
07222 static int G__G__MathMore_158_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07223 {
07224       G__letint(result7, 67, (long) ((const ROOT::Math::GSLIntegrator*) G__getstructoffset())->GetTypeName());
07225    return(1 || funcname || hash || result7 || libp) ;
07226 }
07227 
07228 // automatic destructor
07229 typedef ROOT::Math::GSLIntegrator G__TROOTcLcLMathcLcLGSLIntegrator;
07230 static int G__G__MathMore_158_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07231 {
07232    char* gvp = (char*) G__getgvp();
07233    long soff = G__getstructoffset();
07234    int n = G__getaryconstruct();
07235    //
07236    //has_a_delete: 0
07237    //has_own_delete1arg: 0
07238    //has_own_delete2arg: 0
07239    //
07240    if (!soff) {
07241      return(1);
07242    }
07243    if (n) {
07244      if (gvp == (char*)G__PVOID) {
07245        delete[] (ROOT::Math::GSLIntegrator*) soff;
07246      } else {
07247        G__setgvp((long) G__PVOID);
07248        for (int i = n - 1; i >= 0; --i) {
07249          ((ROOT::Math::GSLIntegrator*) (soff+(sizeof(ROOT::Math::GSLIntegrator)*i)))->~G__TROOTcLcLMathcLcLGSLIntegrator();
07250        }
07251        G__setgvp((long)gvp);
07252      }
07253    } else {
07254      if (gvp == (char*)G__PVOID) {
07255        delete (ROOT::Math::GSLIntegrator*) soff;
07256      } else {
07257        G__setgvp((long) G__PVOID);
07258        ((ROOT::Math::GSLIntegrator*) (soff))->~G__TROOTcLcLMathcLcLGSLIntegrator();
07259        G__setgvp((long)gvp);
07260      }
07261    }
07262    G__setnull(result7);
07263    return(1 || funcname || hash || result7 || libp) ;
07264 }
07265 
07266 
07267 /* ROOT::Math::VegasParameters */
07268 static int G__G__MathMore_161_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07269 {
07270    ROOT::Math::VegasParameters* p = NULL;
07271    char* gvp = (char*) G__getgvp();
07272    int n = G__getaryconstruct();
07273    if (n) {
07274      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07275        p = new ROOT::Math::VegasParameters[n];
07276      } else {
07277        p = new((void*) gvp) ROOT::Math::VegasParameters[n];
07278      }
07279    } else {
07280      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07281        p = new ROOT::Math::VegasParameters;
07282      } else {
07283        p = new((void*) gvp) ROOT::Math::VegasParameters;
07284      }
07285    }
07286    result7->obj.i = (long) p;
07287    result7->ref = (long) p;
07288    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters));
07289    return(1 || funcname || hash || result7 || libp) ;
07290 }
07291 
07292 static int G__G__MathMore_161_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07293 {
07294    ROOT::Math::VegasParameters* p = NULL;
07295    char* gvp = (char*) G__getgvp();
07296    //m: 1
07297    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07298      p = new ROOT::Math::VegasParameters(*(ROOT::Math::IOptions*) libp->para[0].ref);
07299    } else {
07300      p = new((void*) gvp) ROOT::Math::VegasParameters(*(ROOT::Math::IOptions*) libp->para[0].ref);
07301    }
07302    result7->obj.i = (long) p;
07303    result7->ref = (long) p;
07304    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters));
07305    return(1 || funcname || hash || result7 || libp) ;
07306 }
07307 
07308 static int G__G__MathMore_161_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07309 {
07310       ((ROOT::Math::VegasParameters*) G__getstructoffset())->SetDefaultValues();
07311       G__setnull(result7);
07312    return(1 || funcname || hash || result7 || libp) ;
07313 }
07314 
07315 static int G__G__MathMore_161_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07316 {
07317       {
07318          const ROOT::Math::VegasParameters& obj = ((ROOT::Math::VegasParameters*) G__getstructoffset())->operator=(*(ROOT::Math::IOptions*) libp->para[0].ref);
07319          result7->ref = (long) (&obj);
07320          result7->obj.i = (long) (&obj);
07321       }
07322    return(1 || funcname || hash || result7 || libp) ;
07323 }
07324 
07325 static int G__G__MathMore_161_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07326 {
07327       G__letint(result7, 85, (long) ((const ROOT::Math::VegasParameters*) G__getstructoffset())->operator()());
07328    return(1 || funcname || hash || result7 || libp) ;
07329 }
07330 
07331 // automatic copy constructor
07332 static int G__G__MathMore_161_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07333 
07334 {
07335    ROOT::Math::VegasParameters* p;
07336    void* tmp = (void*) G__int(libp->para[0]);
07337    p = new ROOT::Math::VegasParameters(*(ROOT::Math::VegasParameters*) tmp);
07338    result7->obj.i = (long) p;
07339    result7->ref = (long) p;
07340    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters));
07341    return(1 || funcname || hash || result7 || libp) ;
07342 }
07343 
07344 // automatic destructor
07345 typedef ROOT::Math::VegasParameters G__TROOTcLcLMathcLcLVegasParameters;
07346 static int G__G__MathMore_161_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07347 {
07348    char* gvp = (char*) G__getgvp();
07349    long soff = G__getstructoffset();
07350    int n = G__getaryconstruct();
07351    //
07352    //has_a_delete: 0
07353    //has_own_delete1arg: 0
07354    //has_own_delete2arg: 0
07355    //
07356    if (!soff) {
07357      return(1);
07358    }
07359    if (n) {
07360      if (gvp == (char*)G__PVOID) {
07361        delete[] (ROOT::Math::VegasParameters*) soff;
07362      } else {
07363        G__setgvp((long) G__PVOID);
07364        for (int i = n - 1; i >= 0; --i) {
07365          ((ROOT::Math::VegasParameters*) (soff+(sizeof(ROOT::Math::VegasParameters)*i)))->~G__TROOTcLcLMathcLcLVegasParameters();
07366        }
07367        G__setgvp((long)gvp);
07368      }
07369    } else {
07370      if (gvp == (char*)G__PVOID) {
07371        delete (ROOT::Math::VegasParameters*) soff;
07372      } else {
07373        G__setgvp((long) G__PVOID);
07374        ((ROOT::Math::VegasParameters*) (soff))->~G__TROOTcLcLMathcLcLVegasParameters();
07375        G__setgvp((long)gvp);
07376      }
07377    }
07378    G__setnull(result7);
07379    return(1 || funcname || hash || result7 || libp) ;
07380 }
07381 
07382 // automatic assignment operator
07383 static int G__G__MathMore_161_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07384 {
07385    ROOT::Math::VegasParameters* dest = (ROOT::Math::VegasParameters*) G__getstructoffset();
07386    *dest = *(ROOT::Math::VegasParameters*) libp->para[0].ref;
07387    const ROOT::Math::VegasParameters& obj = *dest;
07388    result7->ref = (long) (&obj);
07389    result7->obj.i = (long) (&obj);
07390    return(1 || funcname || hash || result7 || libp) ;
07391 }
07392 
07393 
07394 /* ROOT::Math::MiserParameters */
07395 static int G__G__MathMore_162_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07396 {
07397    ROOT::Math::MiserParameters* p = NULL;
07398    char* gvp = (char*) G__getgvp();
07399    switch (libp->paran) {
07400    case 1:
07401      //m: 1
07402      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07403        p = new ROOT::Math::MiserParameters((size_t) G__int(libp->para[0]));
07404      } else {
07405        p = new((void*) gvp) ROOT::Math::MiserParameters((size_t) G__int(libp->para[0]));
07406      }
07407      break;
07408    case 0:
07409      int n = G__getaryconstruct();
07410      if (n) {
07411        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07412          p = new ROOT::Math::MiserParameters[n];
07413        } else {
07414          p = new((void*) gvp) ROOT::Math::MiserParameters[n];
07415        }
07416      } else {
07417        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07418          p = new ROOT::Math::MiserParameters;
07419        } else {
07420          p = new((void*) gvp) ROOT::Math::MiserParameters;
07421        }
07422      }
07423      break;
07424    }
07425    result7->obj.i = (long) p;
07426    result7->ref = (long) p;
07427    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters));
07428    return(1 || funcname || hash || result7 || libp) ;
07429 }
07430 
07431 static int G__G__MathMore_162_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07432 {
07433    switch (libp->paran) {
07434    case 1:
07435       ((ROOT::Math::MiserParameters*) G__getstructoffset())->SetDefaultValues((size_t) G__int(libp->para[0]));
07436       G__setnull(result7);
07437       break;
07438    case 0:
07439       ((ROOT::Math::MiserParameters*) G__getstructoffset())->SetDefaultValues();
07440       G__setnull(result7);
07441       break;
07442    }
07443    return(1 || funcname || hash || result7 || libp) ;
07444 }
07445 
07446 static int G__G__MathMore_162_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07447 {
07448    ROOT::Math::MiserParameters* p = NULL;
07449    char* gvp = (char*) G__getgvp();
07450    switch (libp->paran) {
07451    case 2:
07452      //m: 2
07453      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07454        p = new ROOT::Math::MiserParameters(*(ROOT::Math::IOptions*) libp->para[0].ref, (size_t) G__int(libp->para[1]));
07455      } else {
07456        p = new((void*) gvp) ROOT::Math::MiserParameters(*(ROOT::Math::IOptions*) libp->para[0].ref, (size_t) G__int(libp->para[1]));
07457      }
07458      break;
07459    case 1:
07460      //m: 1
07461      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07462        p = new ROOT::Math::MiserParameters(*(ROOT::Math::IOptions*) libp->para[0].ref);
07463      } else {
07464        p = new((void*) gvp) ROOT::Math::MiserParameters(*(ROOT::Math::IOptions*) libp->para[0].ref);
07465      }
07466      break;
07467    }
07468    result7->obj.i = (long) p;
07469    result7->ref = (long) p;
07470    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters));
07471    return(1 || funcname || hash || result7 || libp) ;
07472 }
07473 
07474 static int G__G__MathMore_162_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07475 {
07476       {
07477          const ROOT::Math::MiserParameters& obj = ((ROOT::Math::MiserParameters*) G__getstructoffset())->operator=(*(ROOT::Math::IOptions*) libp->para[0].ref);
07478          result7->ref = (long) (&obj);
07479          result7->obj.i = (long) (&obj);
07480       }
07481    return(1 || funcname || hash || result7 || libp) ;
07482 }
07483 
07484 static int G__G__MathMore_162_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07485 {
07486       G__letint(result7, 85, (long) ((const ROOT::Math::MiserParameters*) G__getstructoffset())->operator()());
07487    return(1 || funcname || hash || result7 || libp) ;
07488 }
07489 
07490 // automatic copy constructor
07491 static int G__G__MathMore_162_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07492 
07493 {
07494    ROOT::Math::MiserParameters* p;
07495    void* tmp = (void*) G__int(libp->para[0]);
07496    p = new ROOT::Math::MiserParameters(*(ROOT::Math::MiserParameters*) tmp);
07497    result7->obj.i = (long) p;
07498    result7->ref = (long) p;
07499    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters));
07500    return(1 || funcname || hash || result7 || libp) ;
07501 }
07502 
07503 // automatic destructor
07504 typedef ROOT::Math::MiserParameters G__TROOTcLcLMathcLcLMiserParameters;
07505 static int G__G__MathMore_162_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07506 {
07507    char* gvp = (char*) G__getgvp();
07508    long soff = G__getstructoffset();
07509    int n = G__getaryconstruct();
07510    //
07511    //has_a_delete: 0
07512    //has_own_delete1arg: 0
07513    //has_own_delete2arg: 0
07514    //
07515    if (!soff) {
07516      return(1);
07517    }
07518    if (n) {
07519      if (gvp == (char*)G__PVOID) {
07520        delete[] (ROOT::Math::MiserParameters*) soff;
07521      } else {
07522        G__setgvp((long) G__PVOID);
07523        for (int i = n - 1; i >= 0; --i) {
07524          ((ROOT::Math::MiserParameters*) (soff+(sizeof(ROOT::Math::MiserParameters)*i)))->~G__TROOTcLcLMathcLcLMiserParameters();
07525        }
07526        G__setgvp((long)gvp);
07527      }
07528    } else {
07529      if (gvp == (char*)G__PVOID) {
07530        delete (ROOT::Math::MiserParameters*) soff;
07531      } else {
07532        G__setgvp((long) G__PVOID);
07533        ((ROOT::Math::MiserParameters*) (soff))->~G__TROOTcLcLMathcLcLMiserParameters();
07534        G__setgvp((long)gvp);
07535      }
07536    }
07537    G__setnull(result7);
07538    return(1 || funcname || hash || result7 || libp) ;
07539 }
07540 
07541 // automatic assignment operator
07542 static int G__G__MathMore_162_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07543 {
07544    ROOT::Math::MiserParameters* dest = (ROOT::Math::MiserParameters*) G__getstructoffset();
07545    *dest = *(ROOT::Math::MiserParameters*) libp->para[0].ref;
07546    const ROOT::Math::MiserParameters& obj = *dest;
07547    result7->ref = (long) (&obj);
07548    result7->obj.i = (long) (&obj);
07549    return(1 || funcname || hash || result7 || libp) ;
07550 }
07551 
07552 
07553 /* ROOT::Math::GSLMCIntegrator */
07554 static int G__G__MathMore_167_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07555 {
07556    ROOT::Math::GSLMCIntegrator* p = NULL;
07557    char* gvp = (char*) G__getgvp();
07558    switch (libp->paran) {
07559    case 4:
07560      //m: 4
07561      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07562        p = new ROOT::Math::GSLMCIntegrator(
07563 (ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07564 , (double) G__double(libp->para[2]), (unsigned int) G__int(libp->para[3]));
07565      } else {
07566        p = new((void*) gvp) ROOT::Math::GSLMCIntegrator(
07567 (ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07568 , (double) G__double(libp->para[2]), (unsigned int) G__int(libp->para[3]));
07569      }
07570      break;
07571    case 3:
07572      //m: 3
07573      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07574        p = new ROOT::Math::GSLMCIntegrator(
07575 (ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07576 , (double) G__double(libp->para[2]));
07577      } else {
07578        p = new((void*) gvp) ROOT::Math::GSLMCIntegrator(
07579 (ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1])
07580 , (double) G__double(libp->para[2]));
07581      }
07582      break;
07583    case 2:
07584      //m: 2
07585      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07586        p = new ROOT::Math::GSLMCIntegrator((ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1]));
07587      } else {
07588        p = new((void*) gvp) ROOT::Math::GSLMCIntegrator((ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]), (double) G__double(libp->para[1]));
07589      }
07590      break;
07591    case 1:
07592      //m: 1
07593      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07594        p = new ROOT::Math::GSLMCIntegrator((ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]));
07595      } else {
07596        p = new((void*) gvp) ROOT::Math::GSLMCIntegrator((ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]));
07597      }
07598      break;
07599    case 0:
07600      int n = G__getaryconstruct();
07601      if (n) {
07602        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07603          p = new ROOT::Math::GSLMCIntegrator[n];
07604        } else {
07605          p = new((void*) gvp) ROOT::Math::GSLMCIntegrator[n];
07606        }
07607      } else {
07608        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07609          p = new ROOT::Math::GSLMCIntegrator;
07610        } else {
07611          p = new((void*) gvp) ROOT::Math::GSLMCIntegrator;
07612        }
07613      }
07614      break;
07615    }
07616    result7->obj.i = (long) p;
07617    result7->ref = (long) p;
07618    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator));
07619    return(1 || funcname || hash || result7 || libp) ;
07620 }
07621 
07622 static int G__G__MathMore_167_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07623 {
07624    ROOT::Math::GSLMCIntegrator* p = NULL;
07625    char* gvp = (char*) G__getgvp();
07626    //m: 4
07627    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07628      p = new ROOT::Math::GSLMCIntegrator(
07629 (const char*) G__int(libp->para[0]), (double) G__double(libp->para[1])
07630 , (double) G__double(libp->para[2]), (unsigned int) G__int(libp->para[3]));
07631    } else {
07632      p = new((void*) gvp) ROOT::Math::GSLMCIntegrator(
07633 (const char*) G__int(libp->para[0]), (double) G__double(libp->para[1])
07634 , (double) G__double(libp->para[2]), (unsigned int) G__int(libp->para[3]));
07635    }
07636    result7->obj.i = (long) p;
07637    result7->ref = (long) p;
07638    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator));
07639    return(1 || funcname || hash || result7 || libp) ;
07640 }
07641 
07642 static int G__G__MathMore_167_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07643 {
07644    switch (libp->paran) {
07645    case 3:
07646       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetFunction((ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
07647 , (void*) G__int(libp->para[2]));
07648       G__setnull(result7);
07649       break;
07650    case 2:
07651       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetFunction((ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
07652       G__setnull(result7);
07653       break;
07654    }
07655    return(1 || funcname || hash || result7 || libp) ;
07656 }
07657 
07658 static int G__G__MathMore_167_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07659 {
07660    switch (libp->paran) {
07661    case 5:
07662       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->Integral(libp->para[0].ref ? *(const ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer*) libp->para[0].ref : *(const ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer*) (void*) (&G__Mlong(libp->para[0])), (unsigned int) G__int(libp->para[1])
07663 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
07664 , (void*) G__int(libp->para[4])));
07665       break;
07666    case 4:
07667       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->Integral(libp->para[0].ref ? *(const ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer*) libp->para[0].ref : *(const ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer*) (void*) (&G__Mlong(libp->para[0])), (unsigned int) G__int(libp->para[1])
07668 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])));
07669       break;
07670    }
07671    return(1 || funcname || hash || result7 || libp) ;
07672 }
07673 
07674 static int G__G__MathMore_167_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07675 {
07676       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetGenerator((ROOT::Math::GSLRngWrapper*) G__int(libp->para[0]));
07677       G__setnull(result7);
07678    return(1 || funcname || hash || result7 || libp) ;
07679 }
07680 
07681 static int G__G__MathMore_167_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07682 {
07683       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetType((ROOT::Math::IntegrationMultiDim::Type) G__int(libp->para[0]));
07684       G__setnull(result7);
07685    return(1 || funcname || hash || result7 || libp) ;
07686 }
07687 
07688 static int G__G__MathMore_167_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07689 {
07690       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetTypeName((const char*) G__int(libp->para[0]));
07691       G__setnull(result7);
07692    return(1 || funcname || hash || result7 || libp) ;
07693 }
07694 
07695 static int G__G__MathMore_167_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07696 {
07697       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetMode((ROOT::Math::MCIntegration::Mode) G__int(libp->para[0]));
07698       G__setnull(result7);
07699    return(1 || funcname || hash || result7 || libp) ;
07700 }
07701 
07702 static int G__G__MathMore_167_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07703 {
07704       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetParameters(*(ROOT::Math::VegasParameters*) libp->para[0].ref);
07705       G__setnull(result7);
07706    return(1 || funcname || hash || result7 || libp) ;
07707 }
07708 
07709 static int G__G__MathMore_167_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07710 {
07711       ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->SetParameters(*(ROOT::Math::MiserParameters*) libp->para[0].ref);
07712       G__setnull(result7);
07713    return(1 || funcname || hash || result7 || libp) ;
07714 }
07715 
07716 static int G__G__MathMore_167_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07717 {
07718       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->Sigma());
07719    return(1 || funcname || hash || result7 || libp) ;
07720 }
07721 
07722 static int G__G__MathMore_167_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07723 {
07724       G__letdouble(result7, 100, (double) ((ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->ChiSqr());
07725    return(1 || funcname || hash || result7 || libp) ;
07726 }
07727 
07728 static int G__G__MathMore_167_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07729 {
07730       G__letint(result7, 105, (long) ((const ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->GetType());
07731    return(1 || funcname || hash || result7 || libp) ;
07732 }
07733 
07734 static int G__G__MathMore_167_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07735 {
07736       G__letint(result7, 67, (long) ((const ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->GetTypeName());
07737    return(1 || funcname || hash || result7 || libp) ;
07738 }
07739 
07740 static int G__G__MathMore_167_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07741 {
07742       G__letint(result7, 85, (long) ((const ROOT::Math::GSLMCIntegrator*) G__getstructoffset())->ExtraOptions());
07743    return(1 || funcname || hash || result7 || libp) ;
07744 }
07745 
07746 // automatic destructor
07747 typedef ROOT::Math::GSLMCIntegrator G__TROOTcLcLMathcLcLGSLMCIntegrator;
07748 static int G__G__MathMore_167_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07749 {
07750    char* gvp = (char*) G__getgvp();
07751    long soff = G__getstructoffset();
07752    int n = G__getaryconstruct();
07753    //
07754    //has_a_delete: 0
07755    //has_own_delete1arg: 0
07756    //has_own_delete2arg: 0
07757    //
07758    if (!soff) {
07759      return(1);
07760    }
07761    if (n) {
07762      if (gvp == (char*)G__PVOID) {
07763        delete[] (ROOT::Math::GSLMCIntegrator*) soff;
07764      } else {
07765        G__setgvp((long) G__PVOID);
07766        for (int i = n - 1; i >= 0; --i) {
07767          ((ROOT::Math::GSLMCIntegrator*) (soff+(sizeof(ROOT::Math::GSLMCIntegrator)*i)))->~G__TROOTcLcLMathcLcLGSLMCIntegrator();
07768        }
07769        G__setgvp((long)gvp);
07770      }
07771    } else {
07772      if (gvp == (char*)G__PVOID) {
07773        delete (ROOT::Math::GSLMCIntegrator*) soff;
07774      } else {
07775        G__setgvp((long) G__PVOID);
07776        ((ROOT::Math::GSLMCIntegrator*) (soff))->~G__TROOTcLcLMathcLcLGSLMCIntegrator();
07777        G__setgvp((long)gvp);
07778      }
07779    }
07780    G__setnull(result7);
07781    return(1 || funcname || hash || result7 || libp) ;
07782 }
07783 
07784 
07785 /* ROOT::Math::Minim1D */
07786 
07787 /* ROOT::Math::GSLMinimizer1D */
07788 static int G__G__MathMore_172_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07789 {
07790    ROOT::Math::GSLMinimizer1D* p = NULL;
07791    char* gvp = (char*) G__getgvp();
07792    switch (libp->paran) {
07793    case 1:
07794      //m: 1
07795      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07796        p = new ROOT::Math::GSLMinimizer1D((ROOT::Math::Minim1D::Type) G__int(libp->para[0]));
07797      } else {
07798        p = new((void*) gvp) ROOT::Math::GSLMinimizer1D((ROOT::Math::Minim1D::Type) G__int(libp->para[0]));
07799      }
07800      break;
07801    case 0:
07802      int n = G__getaryconstruct();
07803      if (n) {
07804        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07805          p = new ROOT::Math::GSLMinimizer1D[n];
07806        } else {
07807          p = new((void*) gvp) ROOT::Math::GSLMinimizer1D[n];
07808        }
07809      } else {
07810        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07811          p = new ROOT::Math::GSLMinimizer1D;
07812        } else {
07813          p = new((void*) gvp) ROOT::Math::GSLMinimizer1D;
07814        }
07815      }
07816      break;
07817    }
07818    result7->obj.i = (long) p;
07819    result7->ref = (long) p;
07820    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D));
07821    return(1 || funcname || hash || result7 || libp) ;
07822 }
07823 
07824 static int G__G__MathMore_172_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07825 {
07826       ((ROOT::Math::GSLMinimizer1D*) G__getstructoffset())->SetFunction((ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
07827 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
07828 , (double) G__double(libp->para[4]));
07829       G__setnull(result7);
07830    return(1 || funcname || hash || result7 || libp) ;
07831 }
07832 
07833 static int G__G__MathMore_172_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07834 {
07835       G__letint(result7, 105, (long) ((ROOT::Math::GSLMinimizer1D*) G__getstructoffset())->Iterate());
07836    return(1 || funcname || hash || result7 || libp) ;
07837 }
07838 
07839 static int G__G__MathMore_172_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07840 {
07841       G__letint(result7, 105, (long) ROOT::Math::GSLMinimizer1D::TestInterval((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
07842 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])));
07843    return(1 || funcname || hash || result7 || libp) ;
07844 }
07845 
07846 // automatic destructor
07847 typedef ROOT::Math::GSLMinimizer1D G__TROOTcLcLMathcLcLGSLMinimizer1D;
07848 static int G__G__MathMore_172_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07849 {
07850    char* gvp = (char*) G__getgvp();
07851    long soff = G__getstructoffset();
07852    int n = G__getaryconstruct();
07853    //
07854    //has_a_delete: 0
07855    //has_own_delete1arg: 0
07856    //has_own_delete2arg: 0
07857    //
07858    if (!soff) {
07859      return(1);
07860    }
07861    if (n) {
07862      if (gvp == (char*)G__PVOID) {
07863        delete[] (ROOT::Math::GSLMinimizer1D*) soff;
07864      } else {
07865        G__setgvp((long) G__PVOID);
07866        for (int i = n - 1; i >= 0; --i) {
07867          ((ROOT::Math::GSLMinimizer1D*) (soff+(sizeof(ROOT::Math::GSLMinimizer1D)*i)))->~G__TROOTcLcLMathcLcLGSLMinimizer1D();
07868        }
07869        G__setgvp((long)gvp);
07870      }
07871    } else {
07872      if (gvp == (char*)G__PVOID) {
07873        delete (ROOT::Math::GSLMinimizer1D*) soff;
07874      } else {
07875        G__setgvp((long) G__PVOID);
07876        ((ROOT::Math::GSLMinimizer1D*) (soff))->~G__TROOTcLcLMathcLcLGSLMinimizer1D();
07877        G__setgvp((long)gvp);
07878      }
07879    }
07880    G__setnull(result7);
07881    return(1 || funcname || hash || result7 || libp) ;
07882 }
07883 
07884 
07885 /* ROOT::Math::Chebyshev */
07886 static int G__G__MathMore_174_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07887 {
07888    ROOT::Math::Chebyshev* p = NULL;
07889    char* gvp = (char*) G__getgvp();
07890    //m: 4
07891    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07892      p = new ROOT::Math::Chebyshev(
07893 *(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
07894 , (double) G__double(libp->para[2]), (size_t) G__int(libp->para[3]));
07895    } else {
07896      p = new((void*) gvp) ROOT::Math::Chebyshev(
07897 *(ROOT::Math::IGenFunction*) libp->para[0].ref, (double) G__double(libp->para[1])
07898 , (double) G__double(libp->para[2]), (size_t) G__int(libp->para[3]));
07899    }
07900    result7->obj.i = (long) p;
07901    result7->ref = (long) p;
07902    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev));
07903    return(1 || funcname || hash || result7 || libp) ;
07904 }
07905 
07906 static int G__G__MathMore_174_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07907 {
07908    ROOT::Math::Chebyshev* p = NULL;
07909    char* gvp = (char*) G__getgvp();
07910    //m: 5
07911    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07912      p = new ROOT::Math::Chebyshev(
07913 (ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
07914 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
07915 , (size_t) G__int(libp->para[4]));
07916    } else {
07917      p = new((void*) gvp) ROOT::Math::Chebyshev(
07918 (ROOT::Math::GSLFuncPointer) G__int(libp->para[0]), (void*) G__int(libp->para[1])
07919 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
07920 , (size_t) G__int(libp->para[4]));
07921    }
07922    result7->obj.i = (long) p;
07923    result7->ref = (long) p;
07924    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev));
07925    return(1 || funcname || hash || result7 || libp) ;
07926 }
07927 
07928 static int G__G__MathMore_174_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07929 {
07930       G__letdouble(result7, 100, (double) ((const ROOT::Math::Chebyshev*) G__getstructoffset())->operator()((double) G__double(libp->para[0])));
07931    return(1 || funcname || hash || result7 || libp) ;
07932 }
07933 
07934 static int G__G__MathMore_174_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07935 {
07936       {
07937          const pair<double,double>* pobj;
07938          const pair<double,double> xobj = ((const ROOT::Math::Chebyshev*) G__getstructoffset())->EvalErr((double) G__double(libp->para[0]));
07939          pobj = new pair<double,double>(xobj);
07940          result7->obj.i = (long) ((void*) pobj);
07941          result7->ref = result7->obj.i;
07942          G__store_tempobject(*result7);
07943       }
07944    return(1 || funcname || hash || result7 || libp) ;
07945 }
07946 
07947 static int G__G__MathMore_174_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07948 {
07949       G__letdouble(result7, 100, (double) ((const ROOT::Math::Chebyshev*) G__getstructoffset())->operator()((double) G__double(libp->para[0]), (size_t) G__int(libp->para[1])));
07950    return(1 || funcname || hash || result7 || libp) ;
07951 }
07952 
07953 static int G__G__MathMore_174_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07954 {
07955       {
07956          const pair<double,double>* pobj;
07957          const pair<double,double> xobj = ((const ROOT::Math::Chebyshev*) G__getstructoffset())->EvalErr((double) G__double(libp->para[0]), (size_t) G__int(libp->para[1]));
07958          pobj = new pair<double,double>(xobj);
07959          result7->obj.i = (long) ((void*) pobj);
07960          result7->ref = result7->obj.i;
07961          G__store_tempobject(*result7);
07962       }
07963    return(1 || funcname || hash || result7 || libp) ;
07964 }
07965 
07966 static int G__G__MathMore_174_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07967 {
07968       G__letint(result7, 85, (long) ((ROOT::Math::Chebyshev*) G__getstructoffset())->Deriv());
07969    return(1 || funcname || hash || result7 || libp) ;
07970 }
07971 
07972 static int G__G__MathMore_174_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07973 {
07974       G__letint(result7, 85, (long) ((ROOT::Math::Chebyshev*) G__getstructoffset())->Integral());
07975    return(1 || funcname || hash || result7 || libp) ;
07976 }
07977 
07978 // automatic destructor
07979 typedef ROOT::Math::Chebyshev G__TROOTcLcLMathcLcLChebyshev;
07980 static int G__G__MathMore_174_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07981 {
07982    char* gvp = (char*) G__getgvp();
07983    long soff = G__getstructoffset();
07984    int n = G__getaryconstruct();
07985    //
07986    //has_a_delete: 0
07987    //has_own_delete1arg: 0
07988    //has_own_delete2arg: 0
07989    //
07990    if (!soff) {
07991      return(1);
07992    }
07993    if (n) {
07994      if (gvp == (char*)G__PVOID) {
07995        delete[] (ROOT::Math::Chebyshev*) soff;
07996      } else {
07997        G__setgvp((long) G__PVOID);
07998        for (int i = n - 1; i >= 0; --i) {
07999          ((ROOT::Math::Chebyshev*) (soff+(sizeof(ROOT::Math::Chebyshev)*i)))->~G__TROOTcLcLMathcLcLChebyshev();
08000        }
08001        G__setgvp((long)gvp);
08002      }
08003    } else {
08004      if (gvp == (char*)G__PVOID) {
08005        delete (ROOT::Math::Chebyshev*) soff;
08006      } else {
08007        G__setgvp((long) G__PVOID);
08008        ((ROOT::Math::Chebyshev*) (soff))->~G__TROOTcLcLMathcLcLChebyshev();
08009        G__setgvp((long)gvp);
08010      }
08011    }
08012    G__setnull(result7);
08013    return(1 || funcname || hash || result7 || libp) ;
08014 }
08015 
08016 
08017 /* ROOT::Math::GSLRandomEngine */
08018 static int G__G__MathMore_176_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08019 {
08020    ROOT::Math::GSLRandomEngine* p = NULL;
08021    char* gvp = (char*) G__getgvp();
08022    int n = G__getaryconstruct();
08023    if (n) {
08024      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08025        p = new ROOT::Math::GSLRandomEngine[n];
08026      } else {
08027        p = new((void*) gvp) ROOT::Math::GSLRandomEngine[n];
08028      }
08029    } else {
08030      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08031        p = new ROOT::Math::GSLRandomEngine;
08032      } else {
08033        p = new((void*) gvp) ROOT::Math::GSLRandomEngine;
08034      }
08035    }
08036    result7->obj.i = (long) p;
08037    result7->ref = (long) p;
08038    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine));
08039    return(1 || funcname || hash || result7 || libp) ;
08040 }
08041 
08042 static int G__G__MathMore_176_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08043 {
08044    ROOT::Math::GSLRandomEngine* p = NULL;
08045    char* gvp = (char*) G__getgvp();
08046    //m: 1
08047    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08048      p = new ROOT::Math::GSLRandomEngine((ROOT::Math::GSLRngWrapper*) G__int(libp->para[0]));
08049    } else {
08050      p = new((void*) gvp) ROOT::Math::GSLRandomEngine((ROOT::Math::GSLRngWrapper*) G__int(libp->para[0]));
08051    }
08052    result7->obj.i = (long) p;
08053    result7->ref = (long) p;
08054    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine));
08055    return(1 || funcname || hash || result7 || libp) ;
08056 }
08057 
08058 static int G__G__MathMore_176_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08059 {
08060       ((ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Initialize();
08061       G__setnull(result7);
08062    return(1 || funcname || hash || result7 || libp) ;
08063 }
08064 
08065 static int G__G__MathMore_176_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08066 {
08067       ((ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Terminate();
08068       G__setnull(result7);
08069    return(1 || funcname || hash || result7 || libp) ;
08070 }
08071 
08072 static int G__G__MathMore_176_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08073 {
08074       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->operator()());
08075    return(1 || funcname || hash || result7 || libp) ;
08076 }
08077 
08078 static int G__G__MathMore_176_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08079 {
08080       G__letint(result7, 104, (long) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->RndmInt((unsigned int) G__int(libp->para[0])));
08081    return(1 || funcname || hash || result7 || libp) ;
08082 }
08083 
08084 static int G__G__MathMore_176_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08085 {
08086       ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->RandomArray((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
08087       G__setnull(result7);
08088    return(1 || funcname || hash || result7 || libp) ;
08089 }
08090 
08091 static int G__G__MathMore_176_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08092 {
08093       {
08094          const string* pobj;
08095          const string xobj = ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Name();
08096          pobj = new string(xobj);
08097          result7->obj.i = (long) ((void*) pobj);
08098          result7->ref = result7->obj.i;
08099          G__store_tempobject(*result7);
08100       }
08101    return(1 || funcname || hash || result7 || libp) ;
08102 }
08103 
08104 static int G__G__MathMore_176_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08105 {
08106       G__letint(result7, 104, (long) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Size());
08107    return(1 || funcname || hash || result7 || libp) ;
08108 }
08109 
08110 static int G__G__MathMore_176_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08111 {
08112       ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
08113       G__setnull(result7);
08114    return(1 || funcname || hash || result7 || libp) ;
08115 }
08116 
08117 static int G__G__MathMore_176_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08118 {
08119       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Gaussian((double) G__double(libp->para[0])));
08120    return(1 || funcname || hash || result7 || libp) ;
08121 }
08122 
08123 static int G__G__MathMore_176_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08124 {
08125       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->GaussianZig((double) G__double(libp->para[0])));
08126    return(1 || funcname || hash || result7 || libp) ;
08127 }
08128 
08129 static int G__G__MathMore_176_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08130 {
08131       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->GaussianRatio((double) G__double(libp->para[0])));
08132    return(1 || funcname || hash || result7 || libp) ;
08133 }
08134 
08135 static int G__G__MathMore_176_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08136 {
08137       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
08138    return(1 || funcname || hash || result7 || libp) ;
08139 }
08140 
08141 static int G__G__MathMore_176_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08142 {
08143       ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
08144 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
08145 , *(double*) G__Doubleref(&libp->para[4]));
08146       G__setnull(result7);
08147    return(1 || funcname || hash || result7 || libp) ;
08148 }
08149 
08150 static int G__G__MathMore_176_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08151 {
08152       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Exponential((double) G__double(libp->para[0])));
08153    return(1 || funcname || hash || result7 || libp) ;
08154 }
08155 
08156 static int G__G__MathMore_176_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08157 {
08158       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Cauchy((double) G__double(libp->para[0])));
08159    return(1 || funcname || hash || result7 || libp) ;
08160 }
08161 
08162 static int G__G__MathMore_176_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08163 {
08164       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Landau());
08165    return(1 || funcname || hash || result7 || libp) ;
08166 }
08167 
08168 static int G__G__MathMore_176_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08169 {
08170       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
08171    return(1 || funcname || hash || result7 || libp) ;
08172 }
08173 
08174 static int G__G__MathMore_176_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08175 {
08176       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
08177    return(1 || funcname || hash || result7 || libp) ;
08178 }
08179 
08180 static int G__G__MathMore_176_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08181 {
08182       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
08183    return(1 || funcname || hash || result7 || libp) ;
08184 }
08185 
08186 static int G__G__MathMore_176_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08187 {
08188       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
08189    return(1 || funcname || hash || result7 || libp) ;
08190 }
08191 
08192 static int G__G__MathMore_176_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08193 {
08194       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
08195    return(1 || funcname || hash || result7 || libp) ;
08196 }
08197 
08198 static int G__G__MathMore_176_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08199 {
08200       ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Dir2D(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
08201       G__setnull(result7);
08202    return(1 || funcname || hash || result7 || libp) ;
08203 }
08204 
08205 static int G__G__MathMore_176_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08206 {
08207       ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Dir3D(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
08208 , *(double*) G__Doubleref(&libp->para[2]));
08209       G__setnull(result7);
08210    return(1 || funcname || hash || result7 || libp) ;
08211 }
08212 
08213 static int G__G__MathMore_176_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08214 {
08215       G__letint(result7, 104, (long) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
08216    return(1 || funcname || hash || result7 || libp) ;
08217 }
08218 
08219 static int G__G__MathMore_176_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08220 {
08221       G__letint(result7, 104, (long) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Binomial((double) G__double(libp->para[0]), (unsigned int) G__int(libp->para[1])));
08222    return(1 || funcname || hash || result7 || libp) ;
08223 }
08224 
08225 static int G__G__MathMore_176_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08226 {
08227       G__letint(result7, 104, (long) ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
08228    return(1 || funcname || hash || result7 || libp) ;
08229 }
08230 
08231 static int G__G__MathMore_176_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08232 {
08233       {
08234          const vector<unsigned int>* pobj;
08235          const vector<unsigned int> xobj = ((const ROOT::Math::GSLRandomEngine*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
08236          pobj = new vector<unsigned int>(xobj);
08237          result7->obj.i = (long) ((void*) pobj);
08238          result7->ref = result7->obj.i;
08239          G__store_tempobject(*result7);
08240       }
08241    return(1 || funcname || hash || result7 || libp) ;
08242 }
08243 
08244 // automatic copy constructor
08245 static int G__G__MathMore_176_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08246 
08247 {
08248    ROOT::Math::GSLRandomEngine* p;
08249    void* tmp = (void*) G__int(libp->para[0]);
08250    p = new ROOT::Math::GSLRandomEngine(*(ROOT::Math::GSLRandomEngine*) tmp);
08251    result7->obj.i = (long) p;
08252    result7->ref = (long) p;
08253    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine));
08254    return(1 || funcname || hash || result7 || libp) ;
08255 }
08256 
08257 // automatic destructor
08258 typedef ROOT::Math::GSLRandomEngine G__TROOTcLcLMathcLcLGSLRandomEngine;
08259 static int G__G__MathMore_176_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08260 {
08261    char* gvp = (char*) G__getgvp();
08262    long soff = G__getstructoffset();
08263    int n = G__getaryconstruct();
08264    //
08265    //has_a_delete: 0
08266    //has_own_delete1arg: 0
08267    //has_own_delete2arg: 0
08268    //
08269    if (!soff) {
08270      return(1);
08271    }
08272    if (n) {
08273      if (gvp == (char*)G__PVOID) {
08274        delete[] (ROOT::Math::GSLRandomEngine*) soff;
08275      } else {
08276        G__setgvp((long) G__PVOID);
08277        for (int i = n - 1; i >= 0; --i) {
08278          ((ROOT::Math::GSLRandomEngine*) (soff+(sizeof(ROOT::Math::GSLRandomEngine)*i)))->~G__TROOTcLcLMathcLcLGSLRandomEngine();
08279        }
08280        G__setgvp((long)gvp);
08281      }
08282    } else {
08283      if (gvp == (char*)G__PVOID) {
08284        delete (ROOT::Math::GSLRandomEngine*) soff;
08285      } else {
08286        G__setgvp((long) G__PVOID);
08287        ((ROOT::Math::GSLRandomEngine*) (soff))->~G__TROOTcLcLMathcLcLGSLRandomEngine();
08288        G__setgvp((long)gvp);
08289      }
08290    }
08291    G__setnull(result7);
08292    return(1 || funcname || hash || result7 || libp) ;
08293 }
08294 
08295 // automatic assignment operator
08296 static int G__G__MathMore_176_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08297 {
08298    ROOT::Math::GSLRandomEngine* dest = (ROOT::Math::GSLRandomEngine*) G__getstructoffset();
08299    *dest = *(ROOT::Math::GSLRandomEngine*) libp->para[0].ref;
08300    const ROOT::Math::GSLRandomEngine& obj = *dest;
08301    result7->ref = (long) (&obj);
08302    result7->obj.i = (long) (&obj);
08303    return(1 || funcname || hash || result7 || libp) ;
08304 }
08305 
08306 
08307 /* ROOT::Math::GSLRngMT */
08308 static int G__G__MathMore_181_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08309 {
08310    ROOT::Math::GSLRngMT* p = NULL;
08311    char* gvp = (char*) G__getgvp();
08312    int n = G__getaryconstruct();
08313    if (n) {
08314      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08315        p = new ROOT::Math::GSLRngMT[n];
08316      } else {
08317        p = new((void*) gvp) ROOT::Math::GSLRngMT[n];
08318      }
08319    } else {
08320      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08321        p = new ROOT::Math::GSLRngMT;
08322      } else {
08323        p = new((void*) gvp) ROOT::Math::GSLRngMT;
08324      }
08325    }
08326    result7->obj.i = (long) p;
08327    result7->ref = (long) p;
08328    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT));
08329    return(1 || funcname || hash || result7 || libp) ;
08330 }
08331 
08332 // automatic copy constructor
08333 static int G__G__MathMore_181_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08334 
08335 {
08336    ROOT::Math::GSLRngMT* p;
08337    void* tmp = (void*) G__int(libp->para[0]);
08338    p = new ROOT::Math::GSLRngMT(*(ROOT::Math::GSLRngMT*) tmp);
08339    result7->obj.i = (long) p;
08340    result7->ref = (long) p;
08341    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT));
08342    return(1 || funcname || hash || result7 || libp) ;
08343 }
08344 
08345 // automatic destructor
08346 typedef ROOT::Math::GSLRngMT G__TROOTcLcLMathcLcLGSLRngMT;
08347 static int G__G__MathMore_181_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08348 {
08349    char* gvp = (char*) G__getgvp();
08350    long soff = G__getstructoffset();
08351    int n = G__getaryconstruct();
08352    //
08353    //has_a_delete: 0
08354    //has_own_delete1arg: 0
08355    //has_own_delete2arg: 0
08356    //
08357    if (!soff) {
08358      return(1);
08359    }
08360    if (n) {
08361      if (gvp == (char*)G__PVOID) {
08362        delete[] (ROOT::Math::GSLRngMT*) soff;
08363      } else {
08364        G__setgvp((long) G__PVOID);
08365        for (int i = n - 1; i >= 0; --i) {
08366          ((ROOT::Math::GSLRngMT*) (soff+(sizeof(ROOT::Math::GSLRngMT)*i)))->~G__TROOTcLcLMathcLcLGSLRngMT();
08367        }
08368        G__setgvp((long)gvp);
08369      }
08370    } else {
08371      if (gvp == (char*)G__PVOID) {
08372        delete (ROOT::Math::GSLRngMT*) soff;
08373      } else {
08374        G__setgvp((long) G__PVOID);
08375        ((ROOT::Math::GSLRngMT*) (soff))->~G__TROOTcLcLMathcLcLGSLRngMT();
08376        G__setgvp((long)gvp);
08377      }
08378    }
08379    G__setnull(result7);
08380    return(1 || funcname || hash || result7 || libp) ;
08381 }
08382 
08383 // automatic assignment operator
08384 static int G__G__MathMore_181_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08385 {
08386    ROOT::Math::GSLRngMT* dest = (ROOT::Math::GSLRngMT*) G__getstructoffset();
08387    *dest = *(ROOT::Math::GSLRngMT*) libp->para[0].ref;
08388    const ROOT::Math::GSLRngMT& obj = *dest;
08389    result7->ref = (long) (&obj);
08390    result7->obj.i = (long) (&obj);
08391    return(1 || funcname || hash || result7 || libp) ;
08392 }
08393 
08394 
08395 /* ROOT::Math::GSLRngRanLux */
08396 static int G__G__MathMore_182_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08397 {
08398    ROOT::Math::GSLRngRanLux* p = NULL;
08399    char* gvp = (char*) G__getgvp();
08400    int n = G__getaryconstruct();
08401    if (n) {
08402      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08403        p = new ROOT::Math::GSLRngRanLux[n];
08404      } else {
08405        p = new((void*) gvp) ROOT::Math::GSLRngRanLux[n];
08406      }
08407    } else {
08408      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08409        p = new ROOT::Math::GSLRngRanLux;
08410      } else {
08411        p = new((void*) gvp) ROOT::Math::GSLRngRanLux;
08412      }
08413    }
08414    result7->obj.i = (long) p;
08415    result7->ref = (long) p;
08416    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux));
08417    return(1 || funcname || hash || result7 || libp) ;
08418 }
08419 
08420 // automatic copy constructor
08421 static int G__G__MathMore_182_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08422 
08423 {
08424    ROOT::Math::GSLRngRanLux* p;
08425    void* tmp = (void*) G__int(libp->para[0]);
08426    p = new ROOT::Math::GSLRngRanLux(*(ROOT::Math::GSLRngRanLux*) tmp);
08427    result7->obj.i = (long) p;
08428    result7->ref = (long) p;
08429    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux));
08430    return(1 || funcname || hash || result7 || libp) ;
08431 }
08432 
08433 // automatic destructor
08434 typedef ROOT::Math::GSLRngRanLux G__TROOTcLcLMathcLcLGSLRngRanLux;
08435 static int G__G__MathMore_182_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08436 {
08437    char* gvp = (char*) G__getgvp();
08438    long soff = G__getstructoffset();
08439    int n = G__getaryconstruct();
08440    //
08441    //has_a_delete: 0
08442    //has_own_delete1arg: 0
08443    //has_own_delete2arg: 0
08444    //
08445    if (!soff) {
08446      return(1);
08447    }
08448    if (n) {
08449      if (gvp == (char*)G__PVOID) {
08450        delete[] (ROOT::Math::GSLRngRanLux*) soff;
08451      } else {
08452        G__setgvp((long) G__PVOID);
08453        for (int i = n - 1; i >= 0; --i) {
08454          ((ROOT::Math::GSLRngRanLux*) (soff+(sizeof(ROOT::Math::GSLRngRanLux)*i)))->~G__TROOTcLcLMathcLcLGSLRngRanLux();
08455        }
08456        G__setgvp((long)gvp);
08457      }
08458    } else {
08459      if (gvp == (char*)G__PVOID) {
08460        delete (ROOT::Math::GSLRngRanLux*) soff;
08461      } else {
08462        G__setgvp((long) G__PVOID);
08463        ((ROOT::Math::GSLRngRanLux*) (soff))->~G__TROOTcLcLMathcLcLGSLRngRanLux();
08464        G__setgvp((long)gvp);
08465      }
08466    }
08467    G__setnull(result7);
08468    return(1 || funcname || hash || result7 || libp) ;
08469 }
08470 
08471 // automatic assignment operator
08472 static int G__G__MathMore_182_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08473 {
08474    ROOT::Math::GSLRngRanLux* dest = (ROOT::Math::GSLRngRanLux*) G__getstructoffset();
08475    *dest = *(ROOT::Math::GSLRngRanLux*) libp->para[0].ref;
08476    const ROOT::Math::GSLRngRanLux& obj = *dest;
08477    result7->ref = (long) (&obj);
08478    result7->obj.i = (long) (&obj);
08479    return(1 || funcname || hash || result7 || libp) ;
08480 }
08481 
08482 
08483 /* ROOT::Math::GSLRngRanLuxS1 */
08484 static int G__G__MathMore_183_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08485 {
08486    ROOT::Math::GSLRngRanLuxS1* p = NULL;
08487    char* gvp = (char*) G__getgvp();
08488    int n = G__getaryconstruct();
08489    if (n) {
08490      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08491        p = new ROOT::Math::GSLRngRanLuxS1[n];
08492      } else {
08493        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxS1[n];
08494      }
08495    } else {
08496      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08497        p = new ROOT::Math::GSLRngRanLuxS1;
08498      } else {
08499        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxS1;
08500      }
08501    }
08502    result7->obj.i = (long) p;
08503    result7->ref = (long) p;
08504    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1));
08505    return(1 || funcname || hash || result7 || libp) ;
08506 }
08507 
08508 // automatic copy constructor
08509 static int G__G__MathMore_183_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08510 
08511 {
08512    ROOT::Math::GSLRngRanLuxS1* p;
08513    void* tmp = (void*) G__int(libp->para[0]);
08514    p = new ROOT::Math::GSLRngRanLuxS1(*(ROOT::Math::GSLRngRanLuxS1*) tmp);
08515    result7->obj.i = (long) p;
08516    result7->ref = (long) p;
08517    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1));
08518    return(1 || funcname || hash || result7 || libp) ;
08519 }
08520 
08521 // automatic destructor
08522 typedef ROOT::Math::GSLRngRanLuxS1 G__TROOTcLcLMathcLcLGSLRngRanLuxS1;
08523 static int G__G__MathMore_183_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08524 {
08525    char* gvp = (char*) G__getgvp();
08526    long soff = G__getstructoffset();
08527    int n = G__getaryconstruct();
08528    //
08529    //has_a_delete: 0
08530    //has_own_delete1arg: 0
08531    //has_own_delete2arg: 0
08532    //
08533    if (!soff) {
08534      return(1);
08535    }
08536    if (n) {
08537      if (gvp == (char*)G__PVOID) {
08538        delete[] (ROOT::Math::GSLRngRanLuxS1*) soff;
08539      } else {
08540        G__setgvp((long) G__PVOID);
08541        for (int i = n - 1; i >= 0; --i) {
08542          ((ROOT::Math::GSLRngRanLuxS1*) (soff+(sizeof(ROOT::Math::GSLRngRanLuxS1)*i)))->~G__TROOTcLcLMathcLcLGSLRngRanLuxS1();
08543        }
08544        G__setgvp((long)gvp);
08545      }
08546    } else {
08547      if (gvp == (char*)G__PVOID) {
08548        delete (ROOT::Math::GSLRngRanLuxS1*) soff;
08549      } else {
08550        G__setgvp((long) G__PVOID);
08551        ((ROOT::Math::GSLRngRanLuxS1*) (soff))->~G__TROOTcLcLMathcLcLGSLRngRanLuxS1();
08552        G__setgvp((long)gvp);
08553      }
08554    }
08555    G__setnull(result7);
08556    return(1 || funcname || hash || result7 || libp) ;
08557 }
08558 
08559 // automatic assignment operator
08560 static int G__G__MathMore_183_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08561 {
08562    ROOT::Math::GSLRngRanLuxS1* dest = (ROOT::Math::GSLRngRanLuxS1*) G__getstructoffset();
08563    *dest = *(ROOT::Math::GSLRngRanLuxS1*) libp->para[0].ref;
08564    const ROOT::Math::GSLRngRanLuxS1& obj = *dest;
08565    result7->ref = (long) (&obj);
08566    result7->obj.i = (long) (&obj);
08567    return(1 || funcname || hash || result7 || libp) ;
08568 }
08569 
08570 
08571 /* ROOT::Math::GSLRngRanLuxS2 */
08572 static int G__G__MathMore_184_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08573 {
08574    ROOT::Math::GSLRngRanLuxS2* p = NULL;
08575    char* gvp = (char*) G__getgvp();
08576    int n = G__getaryconstruct();
08577    if (n) {
08578      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08579        p = new ROOT::Math::GSLRngRanLuxS2[n];
08580      } else {
08581        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxS2[n];
08582      }
08583    } else {
08584      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08585        p = new ROOT::Math::GSLRngRanLuxS2;
08586      } else {
08587        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxS2;
08588      }
08589    }
08590    result7->obj.i = (long) p;
08591    result7->ref = (long) p;
08592    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2));
08593    return(1 || funcname || hash || result7 || libp) ;
08594 }
08595 
08596 // automatic copy constructor
08597 static int G__G__MathMore_184_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08598 
08599 {
08600    ROOT::Math::GSLRngRanLuxS2* p;
08601    void* tmp = (void*) G__int(libp->para[0]);
08602    p = new ROOT::Math::GSLRngRanLuxS2(*(ROOT::Math::GSLRngRanLuxS2*) tmp);
08603    result7->obj.i = (long) p;
08604    result7->ref = (long) p;
08605    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2));
08606    return(1 || funcname || hash || result7 || libp) ;
08607 }
08608 
08609 // automatic destructor
08610 typedef ROOT::Math::GSLRngRanLuxS2 G__TROOTcLcLMathcLcLGSLRngRanLuxS2;
08611 static int G__G__MathMore_184_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08612 {
08613    char* gvp = (char*) G__getgvp();
08614    long soff = G__getstructoffset();
08615    int n = G__getaryconstruct();
08616    //
08617    //has_a_delete: 0
08618    //has_own_delete1arg: 0
08619    //has_own_delete2arg: 0
08620    //
08621    if (!soff) {
08622      return(1);
08623    }
08624    if (n) {
08625      if (gvp == (char*)G__PVOID) {
08626        delete[] (ROOT::Math::GSLRngRanLuxS2*) soff;
08627      } else {
08628        G__setgvp((long) G__PVOID);
08629        for (int i = n - 1; i >= 0; --i) {
08630          ((ROOT::Math::GSLRngRanLuxS2*) (soff+(sizeof(ROOT::Math::GSLRngRanLuxS2)*i)))->~G__TROOTcLcLMathcLcLGSLRngRanLuxS2();
08631        }
08632        G__setgvp((long)gvp);
08633      }
08634    } else {
08635      if (gvp == (char*)G__PVOID) {
08636        delete (ROOT::Math::GSLRngRanLuxS2*) soff;
08637      } else {
08638        G__setgvp((long) G__PVOID);
08639        ((ROOT::Math::GSLRngRanLuxS2*) (soff))->~G__TROOTcLcLMathcLcLGSLRngRanLuxS2();
08640        G__setgvp((long)gvp);
08641      }
08642    }
08643    G__setnull(result7);
08644    return(1 || funcname || hash || result7 || libp) ;
08645 }
08646 
08647 // automatic assignment operator
08648 static int G__G__MathMore_184_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08649 {
08650    ROOT::Math::GSLRngRanLuxS2* dest = (ROOT::Math::GSLRngRanLuxS2*) G__getstructoffset();
08651    *dest = *(ROOT::Math::GSLRngRanLuxS2*) libp->para[0].ref;
08652    const ROOT::Math::GSLRngRanLuxS2& obj = *dest;
08653    result7->ref = (long) (&obj);
08654    result7->obj.i = (long) (&obj);
08655    return(1 || funcname || hash || result7 || libp) ;
08656 }
08657 
08658 
08659 /* ROOT::Math::GSLRngRanLuxD1 */
08660 static int G__G__MathMore_185_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08661 {
08662    ROOT::Math::GSLRngRanLuxD1* p = NULL;
08663    char* gvp = (char*) G__getgvp();
08664    int n = G__getaryconstruct();
08665    if (n) {
08666      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08667        p = new ROOT::Math::GSLRngRanLuxD1[n];
08668      } else {
08669        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxD1[n];
08670      }
08671    } else {
08672      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08673        p = new ROOT::Math::GSLRngRanLuxD1;
08674      } else {
08675        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxD1;
08676      }
08677    }
08678    result7->obj.i = (long) p;
08679    result7->ref = (long) p;
08680    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1));
08681    return(1 || funcname || hash || result7 || libp) ;
08682 }
08683 
08684 // automatic copy constructor
08685 static int G__G__MathMore_185_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08686 
08687 {
08688    ROOT::Math::GSLRngRanLuxD1* p;
08689    void* tmp = (void*) G__int(libp->para[0]);
08690    p = new ROOT::Math::GSLRngRanLuxD1(*(ROOT::Math::GSLRngRanLuxD1*) tmp);
08691    result7->obj.i = (long) p;
08692    result7->ref = (long) p;
08693    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1));
08694    return(1 || funcname || hash || result7 || libp) ;
08695 }
08696 
08697 // automatic destructor
08698 typedef ROOT::Math::GSLRngRanLuxD1 G__TROOTcLcLMathcLcLGSLRngRanLuxD1;
08699 static int G__G__MathMore_185_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08700 {
08701    char* gvp = (char*) G__getgvp();
08702    long soff = G__getstructoffset();
08703    int n = G__getaryconstruct();
08704    //
08705    //has_a_delete: 0
08706    //has_own_delete1arg: 0
08707    //has_own_delete2arg: 0
08708    //
08709    if (!soff) {
08710      return(1);
08711    }
08712    if (n) {
08713      if (gvp == (char*)G__PVOID) {
08714        delete[] (ROOT::Math::GSLRngRanLuxD1*) soff;
08715      } else {
08716        G__setgvp((long) G__PVOID);
08717        for (int i = n - 1; i >= 0; --i) {
08718          ((ROOT::Math::GSLRngRanLuxD1*) (soff+(sizeof(ROOT::Math::GSLRngRanLuxD1)*i)))->~G__TROOTcLcLMathcLcLGSLRngRanLuxD1();
08719        }
08720        G__setgvp((long)gvp);
08721      }
08722    } else {
08723      if (gvp == (char*)G__PVOID) {
08724        delete (ROOT::Math::GSLRngRanLuxD1*) soff;
08725      } else {
08726        G__setgvp((long) G__PVOID);
08727        ((ROOT::Math::GSLRngRanLuxD1*) (soff))->~G__TROOTcLcLMathcLcLGSLRngRanLuxD1();
08728        G__setgvp((long)gvp);
08729      }
08730    }
08731    G__setnull(result7);
08732    return(1 || funcname || hash || result7 || libp) ;
08733 }
08734 
08735 // automatic assignment operator
08736 static int G__G__MathMore_185_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08737 {
08738    ROOT::Math::GSLRngRanLuxD1* dest = (ROOT::Math::GSLRngRanLuxD1*) G__getstructoffset();
08739    *dest = *(ROOT::Math::GSLRngRanLuxD1*) libp->para[0].ref;
08740    const ROOT::Math::GSLRngRanLuxD1& obj = *dest;
08741    result7->ref = (long) (&obj);
08742    result7->obj.i = (long) (&obj);
08743    return(1 || funcname || hash || result7 || libp) ;
08744 }
08745 
08746 
08747 /* ROOT::Math::GSLRngRanLuxD2 */
08748 static int G__G__MathMore_186_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08749 {
08750    ROOT::Math::GSLRngRanLuxD2* p = NULL;
08751    char* gvp = (char*) G__getgvp();
08752    int n = G__getaryconstruct();
08753    if (n) {
08754      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08755        p = new ROOT::Math::GSLRngRanLuxD2[n];
08756      } else {
08757        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxD2[n];
08758      }
08759    } else {
08760      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08761        p = new ROOT::Math::GSLRngRanLuxD2;
08762      } else {
08763        p = new((void*) gvp) ROOT::Math::GSLRngRanLuxD2;
08764      }
08765    }
08766    result7->obj.i = (long) p;
08767    result7->ref = (long) p;
08768    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2));
08769    return(1 || funcname || hash || result7 || libp) ;
08770 }
08771 
08772 // automatic copy constructor
08773 static int G__G__MathMore_186_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08774 
08775 {
08776    ROOT::Math::GSLRngRanLuxD2* p;
08777    void* tmp = (void*) G__int(libp->para[0]);
08778    p = new ROOT::Math::GSLRngRanLuxD2(*(ROOT::Math::GSLRngRanLuxD2*) tmp);
08779    result7->obj.i = (long) p;
08780    result7->ref = (long) p;
08781    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2));
08782    return(1 || funcname || hash || result7 || libp) ;
08783 }
08784 
08785 // automatic destructor
08786 typedef ROOT::Math::GSLRngRanLuxD2 G__TROOTcLcLMathcLcLGSLRngRanLuxD2;
08787 static int G__G__MathMore_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08788 {
08789    char* gvp = (char*) G__getgvp();
08790    long soff = G__getstructoffset();
08791    int n = G__getaryconstruct();
08792    //
08793    //has_a_delete: 0
08794    //has_own_delete1arg: 0
08795    //has_own_delete2arg: 0
08796    //
08797    if (!soff) {
08798      return(1);
08799    }
08800    if (n) {
08801      if (gvp == (char*)G__PVOID) {
08802        delete[] (ROOT::Math::GSLRngRanLuxD2*) soff;
08803      } else {
08804        G__setgvp((long) G__PVOID);
08805        for (int i = n - 1; i >= 0; --i) {
08806          ((ROOT::Math::GSLRngRanLuxD2*) (soff+(sizeof(ROOT::Math::GSLRngRanLuxD2)*i)))->~G__TROOTcLcLMathcLcLGSLRngRanLuxD2();
08807        }
08808        G__setgvp((long)gvp);
08809      }
08810    } else {
08811      if (gvp == (char*)G__PVOID) {
08812        delete (ROOT::Math::GSLRngRanLuxD2*) soff;
08813      } else {
08814        G__setgvp((long) G__PVOID);
08815        ((ROOT::Math::GSLRngRanLuxD2*) (soff))->~G__TROOTcLcLMathcLcLGSLRngRanLuxD2();
08816        G__setgvp((long)gvp);
08817      }
08818    }
08819    G__setnull(result7);
08820    return(1 || funcname || hash || result7 || libp) ;
08821 }
08822 
08823 // automatic assignment operator
08824 static int G__G__MathMore_186_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08825 {
08826    ROOT::Math::GSLRngRanLuxD2* dest = (ROOT::Math::GSLRngRanLuxD2*) G__getstructoffset();
08827    *dest = *(ROOT::Math::GSLRngRanLuxD2*) libp->para[0].ref;
08828    const ROOT::Math::GSLRngRanLuxD2& obj = *dest;
08829    result7->ref = (long) (&obj);
08830    result7->obj.i = (long) (&obj);
08831    return(1 || funcname || hash || result7 || libp) ;
08832 }
08833 
08834 
08835 /* ROOT::Math::GSLRngTaus */
08836 static int G__G__MathMore_187_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08837 {
08838    ROOT::Math::GSLRngTaus* p = NULL;
08839    char* gvp = (char*) G__getgvp();
08840    int n = G__getaryconstruct();
08841    if (n) {
08842      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08843        p = new ROOT::Math::GSLRngTaus[n];
08844      } else {
08845        p = new((void*) gvp) ROOT::Math::GSLRngTaus[n];
08846      }
08847    } else {
08848      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08849        p = new ROOT::Math::GSLRngTaus;
08850      } else {
08851        p = new((void*) gvp) ROOT::Math::GSLRngTaus;
08852      }
08853    }
08854    result7->obj.i = (long) p;
08855    result7->ref = (long) p;
08856    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus));
08857    return(1 || funcname || hash || result7 || libp) ;
08858 }
08859 
08860 // automatic copy constructor
08861 static int G__G__MathMore_187_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08862 
08863 {
08864    ROOT::Math::GSLRngTaus* p;
08865    void* tmp = (void*) G__int(libp->para[0]);
08866    p = new ROOT::Math::GSLRngTaus(*(ROOT::Math::GSLRngTaus*) tmp);
08867    result7->obj.i = (long) p;
08868    result7->ref = (long) p;
08869    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus));
08870    return(1 || funcname || hash || result7 || libp) ;
08871 }
08872 
08873 // automatic destructor
08874 typedef ROOT::Math::GSLRngTaus G__TROOTcLcLMathcLcLGSLRngTaus;
08875 static int G__G__MathMore_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08876 {
08877    char* gvp = (char*) G__getgvp();
08878    long soff = G__getstructoffset();
08879    int n = G__getaryconstruct();
08880    //
08881    //has_a_delete: 0
08882    //has_own_delete1arg: 0
08883    //has_own_delete2arg: 0
08884    //
08885    if (!soff) {
08886      return(1);
08887    }
08888    if (n) {
08889      if (gvp == (char*)G__PVOID) {
08890        delete[] (ROOT::Math::GSLRngTaus*) soff;
08891      } else {
08892        G__setgvp((long) G__PVOID);
08893        for (int i = n - 1; i >= 0; --i) {
08894          ((ROOT::Math::GSLRngTaus*) (soff+(sizeof(ROOT::Math::GSLRngTaus)*i)))->~G__TROOTcLcLMathcLcLGSLRngTaus();
08895        }
08896        G__setgvp((long)gvp);
08897      }
08898    } else {
08899      if (gvp == (char*)G__PVOID) {
08900        delete (ROOT::Math::GSLRngTaus*) soff;
08901      } else {
08902        G__setgvp((long) G__PVOID);
08903        ((ROOT::Math::GSLRngTaus*) (soff))->~G__TROOTcLcLMathcLcLGSLRngTaus();
08904        G__setgvp((long)gvp);
08905      }
08906    }
08907    G__setnull(result7);
08908    return(1 || funcname || hash || result7 || libp) ;
08909 }
08910 
08911 // automatic assignment operator
08912 static int G__G__MathMore_187_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08913 {
08914    ROOT::Math::GSLRngTaus* dest = (ROOT::Math::GSLRngTaus*) G__getstructoffset();
08915    *dest = *(ROOT::Math::GSLRngTaus*) libp->para[0].ref;
08916    const ROOT::Math::GSLRngTaus& obj = *dest;
08917    result7->ref = (long) (&obj);
08918    result7->obj.i = (long) (&obj);
08919    return(1 || funcname || hash || result7 || libp) ;
08920 }
08921 
08922 
08923 /* ROOT::Math::GSLRngGFSR4 */
08924 static int G__G__MathMore_188_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08925 {
08926    ROOT::Math::GSLRngGFSR4* p = NULL;
08927    char* gvp = (char*) G__getgvp();
08928    int n = G__getaryconstruct();
08929    if (n) {
08930      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08931        p = new ROOT::Math::GSLRngGFSR4[n];
08932      } else {
08933        p = new((void*) gvp) ROOT::Math::GSLRngGFSR4[n];
08934      }
08935    } else {
08936      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08937        p = new ROOT::Math::GSLRngGFSR4;
08938      } else {
08939        p = new((void*) gvp) ROOT::Math::GSLRngGFSR4;
08940      }
08941    }
08942    result7->obj.i = (long) p;
08943    result7->ref = (long) p;
08944    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4));
08945    return(1 || funcname || hash || result7 || libp) ;
08946 }
08947 
08948 // automatic copy constructor
08949 static int G__G__MathMore_188_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08950 
08951 {
08952    ROOT::Math::GSLRngGFSR4* p;
08953    void* tmp = (void*) G__int(libp->para[0]);
08954    p = new ROOT::Math::GSLRngGFSR4(*(ROOT::Math::GSLRngGFSR4*) tmp);
08955    result7->obj.i = (long) p;
08956    result7->ref = (long) p;
08957    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4));
08958    return(1 || funcname || hash || result7 || libp) ;
08959 }
08960 
08961 // automatic destructor
08962 typedef ROOT::Math::GSLRngGFSR4 G__TROOTcLcLMathcLcLGSLRngGFSR4;
08963 static int G__G__MathMore_188_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08964 {
08965    char* gvp = (char*) G__getgvp();
08966    long soff = G__getstructoffset();
08967    int n = G__getaryconstruct();
08968    //
08969    //has_a_delete: 0
08970    //has_own_delete1arg: 0
08971    //has_own_delete2arg: 0
08972    //
08973    if (!soff) {
08974      return(1);
08975    }
08976    if (n) {
08977      if (gvp == (char*)G__PVOID) {
08978        delete[] (ROOT::Math::GSLRngGFSR4*) soff;
08979      } else {
08980        G__setgvp((long) G__PVOID);
08981        for (int i = n - 1; i >= 0; --i) {
08982          ((ROOT::Math::GSLRngGFSR4*) (soff+(sizeof(ROOT::Math::GSLRngGFSR4)*i)))->~G__TROOTcLcLMathcLcLGSLRngGFSR4();
08983        }
08984        G__setgvp((long)gvp);
08985      }
08986    } else {
08987      if (gvp == (char*)G__PVOID) {
08988        delete (ROOT::Math::GSLRngGFSR4*) soff;
08989      } else {
08990        G__setgvp((long) G__PVOID);
08991        ((ROOT::Math::GSLRngGFSR4*) (soff))->~G__TROOTcLcLMathcLcLGSLRngGFSR4();
08992        G__setgvp((long)gvp);
08993      }
08994    }
08995    G__setnull(result7);
08996    return(1 || funcname || hash || result7 || libp) ;
08997 }
08998 
08999 // automatic assignment operator
09000 static int G__G__MathMore_188_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09001 {
09002    ROOT::Math::GSLRngGFSR4* dest = (ROOT::Math::GSLRngGFSR4*) G__getstructoffset();
09003    *dest = *(ROOT::Math::GSLRngGFSR4*) libp->para[0].ref;
09004    const ROOT::Math::GSLRngGFSR4& obj = *dest;
09005    result7->ref = (long) (&obj);
09006    result7->obj.i = (long) (&obj);
09007    return(1 || funcname || hash || result7 || libp) ;
09008 }
09009 
09010 
09011 /* ROOT::Math::KelvinFunctions */
09012 static int G__G__MathMore_194_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09013 {
09014       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::Ber((double) G__double(libp->para[0])));
09015    return(1 || funcname || hash || result7 || libp) ;
09016 }
09017 
09018 static int G__G__MathMore_194_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09019 {
09020       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::Bei((double) G__double(libp->para[0])));
09021    return(1 || funcname || hash || result7 || libp) ;
09022 }
09023 
09024 static int G__G__MathMore_194_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09025 {
09026       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::Ker((double) G__double(libp->para[0])));
09027    return(1 || funcname || hash || result7 || libp) ;
09028 }
09029 
09030 static int G__G__MathMore_194_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09031 {
09032       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::Kei((double) G__double(libp->para[0])));
09033    return(1 || funcname || hash || result7 || libp) ;
09034 }
09035 
09036 static int G__G__MathMore_194_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09037 {
09038       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::DBer((double) G__double(libp->para[0])));
09039    return(1 || funcname || hash || result7 || libp) ;
09040 }
09041 
09042 static int G__G__MathMore_194_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09043 {
09044       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::DBei((double) G__double(libp->para[0])));
09045    return(1 || funcname || hash || result7 || libp) ;
09046 }
09047 
09048 static int G__G__MathMore_194_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09049 {
09050       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::DKer((double) G__double(libp->para[0])));
09051    return(1 || funcname || hash || result7 || libp) ;
09052 }
09053 
09054 static int G__G__MathMore_194_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09055 {
09056       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::DKei((double) G__double(libp->para[0])));
09057    return(1 || funcname || hash || result7 || libp) ;
09058 }
09059 
09060 static int G__G__MathMore_194_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09061 {
09062       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::F1((double) G__double(libp->para[0])));
09063    return(1 || funcname || hash || result7 || libp) ;
09064 }
09065 
09066 static int G__G__MathMore_194_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09067 {
09068       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::F2((double) G__double(libp->para[0])));
09069    return(1 || funcname || hash || result7 || libp) ;
09070 }
09071 
09072 static int G__G__MathMore_194_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09073 {
09074       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::G1((double) G__double(libp->para[0])));
09075    return(1 || funcname || hash || result7 || libp) ;
09076 }
09077 
09078 static int G__G__MathMore_194_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09079 {
09080       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::G2((double) G__double(libp->para[0])));
09081    return(1 || funcname || hash || result7 || libp) ;
09082 }
09083 
09084 static int G__G__MathMore_194_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09085 {
09086       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::M((double) G__double(libp->para[0])));
09087    return(1 || funcname || hash || result7 || libp) ;
09088 }
09089 
09090 static int G__G__MathMore_194_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09091 {
09092       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::Theta((double) G__double(libp->para[0])));
09093    return(1 || funcname || hash || result7 || libp) ;
09094 }
09095 
09096 static int G__G__MathMore_194_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09097 {
09098       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::N((double) G__double(libp->para[0])));
09099    return(1 || funcname || hash || result7 || libp) ;
09100 }
09101 
09102 static int G__G__MathMore_194_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09103 {
09104       G__letdouble(result7, 100, (double) ROOT::Math::KelvinFunctions::Phi((double) G__double(libp->para[0])));
09105    return(1 || funcname || hash || result7 || libp) ;
09106 }
09107 
09108 // automatic default constructor
09109 static int G__G__MathMore_194_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09110 {
09111    ROOT::Math::KelvinFunctions *p;
09112    char* gvp = (char*) G__getgvp();
09113    int n = G__getaryconstruct();
09114    if (n) {
09115      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09116        p = new ROOT::Math::KelvinFunctions[n];
09117      } else {
09118        p = new((void*) gvp) ROOT::Math::KelvinFunctions[n];
09119      }
09120    } else {
09121      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09122        p = new ROOT::Math::KelvinFunctions;
09123      } else {
09124        p = new((void*) gvp) ROOT::Math::KelvinFunctions;
09125      }
09126    }
09127    result7->obj.i = (long) p;
09128    result7->ref = (long) p;
09129    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions));
09130    return(1 || funcname || hash || result7 || libp) ;
09131 }
09132 
09133 // automatic copy constructor
09134 static int G__G__MathMore_194_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09135 
09136 {
09137    ROOT::Math::KelvinFunctions* p;
09138    void* tmp = (void*) G__int(libp->para[0]);
09139    p = new ROOT::Math::KelvinFunctions(*(ROOT::Math::KelvinFunctions*) tmp);
09140    result7->obj.i = (long) p;
09141    result7->ref = (long) p;
09142    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions));
09143    return(1 || funcname || hash || result7 || libp) ;
09144 }
09145 
09146 // automatic destructor
09147 typedef ROOT::Math::KelvinFunctions G__TROOTcLcLMathcLcLKelvinFunctions;
09148 static int G__G__MathMore_194_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09149 {
09150    char* gvp = (char*) G__getgvp();
09151    long soff = G__getstructoffset();
09152    int n = G__getaryconstruct();
09153    //
09154    //has_a_delete: 0
09155    //has_own_delete1arg: 0
09156    //has_own_delete2arg: 0
09157    //
09158    if (!soff) {
09159      return(1);
09160    }
09161    if (n) {
09162      if (gvp == (char*)G__PVOID) {
09163        delete[] (ROOT::Math::KelvinFunctions*) soff;
09164      } else {
09165        G__setgvp((long) G__PVOID);
09166        for (int i = n - 1; i >= 0; --i) {
09167          ((ROOT::Math::KelvinFunctions*) (soff+(sizeof(ROOT::Math::KelvinFunctions)*i)))->~G__TROOTcLcLMathcLcLKelvinFunctions();
09168        }
09169        G__setgvp((long)gvp);
09170      }
09171    } else {
09172      if (gvp == (char*)G__PVOID) {
09173        delete (ROOT::Math::KelvinFunctions*) soff;
09174      } else {
09175        G__setgvp((long) G__PVOID);
09176        ((ROOT::Math::KelvinFunctions*) (soff))->~G__TROOTcLcLMathcLcLKelvinFunctions();
09177        G__setgvp((long)gvp);
09178      }
09179    }
09180    G__setnull(result7);
09181    return(1 || funcname || hash || result7 || libp) ;
09182 }
09183 
09184 // automatic assignment operator
09185 static int G__G__MathMore_194_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09186 {
09187    ROOT::Math::KelvinFunctions* dest = (ROOT::Math::KelvinFunctions*) G__getstructoffset();
09188    *dest = *(ROOT::Math::KelvinFunctions*) libp->para[0].ref;
09189    const ROOT::Math::KelvinFunctions& obj = *dest;
09190    result7->ref = (long) (&obj);
09191    result7->obj.i = (long) (&obj);
09192    return(1 || funcname || hash || result7 || libp) ;
09193 }
09194 
09195 
09196 /* ROOT::Math::GSLMinimizer */
09197 static int G__G__MathMore_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09198 {
09199    ROOT::Math::GSLMinimizer* p = NULL;
09200    char* gvp = (char*) G__getgvp();
09201    switch (libp->paran) {
09202    case 1:
09203      //m: 1
09204      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09205        p = new ROOT::Math::GSLMinimizer((ROOT::Math::EGSLMinimizerType) G__int(libp->para[0]));
09206      } else {
09207        p = new((void*) gvp) ROOT::Math::GSLMinimizer((ROOT::Math::EGSLMinimizerType) G__int(libp->para[0]));
09208      }
09209      break;
09210    case 0:
09211      int n = G__getaryconstruct();
09212      if (n) {
09213        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09214          p = new ROOT::Math::GSLMinimizer[n];
09215        } else {
09216          p = new((void*) gvp) ROOT::Math::GSLMinimizer[n];
09217        }
09218      } else {
09219        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09220          p = new ROOT::Math::GSLMinimizer;
09221        } else {
09222          p = new((void*) gvp) ROOT::Math::GSLMinimizer;
09223        }
09224      }
09225      break;
09226    }
09227    result7->obj.i = (long) p;
09228    result7->ref = (long) p;
09229    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer));
09230    return(1 || funcname || hash || result7 || libp) ;
09231 }
09232 
09233 static int G__G__MathMore_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09234 {
09235    ROOT::Math::GSLMinimizer* p = NULL;
09236    char* gvp = (char*) G__getgvp();
09237    //m: 1
09238    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09239      p = new ROOT::Math::GSLMinimizer((const char*) G__int(libp->para[0]));
09240    } else {
09241      p = new((void*) gvp) ROOT::Math::GSLMinimizer((const char*) G__int(libp->para[0]));
09242    }
09243    result7->obj.i = (long) p;
09244    result7->ref = (long) p;
09245    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer));
09246    return(1 || funcname || hash || result7 || libp) ;
09247 }
09248 
09249 static int G__G__MathMore_207_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09250 {
09251       G__letint(result7, 85, (long) ((const ROOT::Math::GSLMinimizer*) G__getstructoffset())->ObjFunction());
09252    return(1 || funcname || hash || result7 || libp) ;
09253 }
09254 
09255 static int G__G__MathMore_207_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09256 {
09257       G__letint(result7, 85, (long) ((const ROOT::Math::GSLMinimizer*) G__getstructoffset())->TransformFunction());
09258    return(1 || funcname || hash || result7 || libp) ;
09259 }
09260 
09261 // automatic destructor
09262 typedef ROOT::Math::GSLMinimizer G__TROOTcLcLMathcLcLGSLMinimizer;
09263 static int G__G__MathMore_207_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09264 {
09265    char* gvp = (char*) G__getgvp();
09266    long soff = G__getstructoffset();
09267    int n = G__getaryconstruct();
09268    //
09269    //has_a_delete: 0
09270    //has_own_delete1arg: 0
09271    //has_own_delete2arg: 0
09272    //
09273    if (!soff) {
09274      return(1);
09275    }
09276    if (n) {
09277      if (gvp == (char*)G__PVOID) {
09278        delete[] (ROOT::Math::GSLMinimizer*) soff;
09279      } else {
09280        G__setgvp((long) G__PVOID);
09281        for (int i = n - 1; i >= 0; --i) {
09282          ((ROOT::Math::GSLMinimizer*) (soff+(sizeof(ROOT::Math::GSLMinimizer)*i)))->~G__TROOTcLcLMathcLcLGSLMinimizer();
09283        }
09284        G__setgvp((long)gvp);
09285      }
09286    } else {
09287      if (gvp == (char*)G__PVOID) {
09288        delete (ROOT::Math::GSLMinimizer*) soff;
09289      } else {
09290        G__setgvp((long) G__PVOID);
09291        ((ROOT::Math::GSLMinimizer*) (soff))->~G__TROOTcLcLMathcLcLGSLMinimizer();
09292        G__setgvp((long)gvp);
09293      }
09294    }
09295    G__setnull(result7);
09296    return(1 || funcname || hash || result7 || libp) ;
09297 }
09298 
09299 
09300 /* ROOT::Math::LSResidualFunc */
09301 static int G__G__MathMore_230_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09302 {
09303    ROOT::Math::LSResidualFunc* p = NULL;
09304    char* gvp = (char*) G__getgvp();
09305    int n = G__getaryconstruct();
09306    if (n) {
09307      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09308        p = new ROOT::Math::LSResidualFunc[n];
09309      } else {
09310        p = new((void*) gvp) ROOT::Math::LSResidualFunc[n];
09311      }
09312    } else {
09313      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09314        p = new ROOT::Math::LSResidualFunc;
09315      } else {
09316        p = new((void*) gvp) ROOT::Math::LSResidualFunc;
09317      }
09318    }
09319    result7->obj.i = (long) p;
09320    result7->ref = (long) p;
09321    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc));
09322    return(1 || funcname || hash || result7 || libp) ;
09323 }
09324 
09325 static int G__G__MathMore_230_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09326 {
09327    ROOT::Math::LSResidualFunc* p = NULL;
09328    char* gvp = (char*) G__getgvp();
09329    //m: 2
09330    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09331      p = new ROOT::Math::LSResidualFunc(*(ROOT::Math::FitMethodFunction*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
09332    } else {
09333      p = new((void*) gvp) ROOT::Math::LSResidualFunc(*(ROOT::Math::FitMethodFunction*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
09334    }
09335    result7->obj.i = (long) p;
09336    result7->ref = (long) p;
09337    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc));
09338    return(1 || funcname || hash || result7 || libp) ;
09339 }
09340 
09341 static int G__G__MathMore_230_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09342 {
09343    ROOT::Math::LSResidualFunc* p = NULL;
09344    char* gvp = (char*) G__getgvp();
09345    //m: 1
09346    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09347      p = new ROOT::Math::LSResidualFunc(*(ROOT::Math::LSResidualFunc*) libp->para[0].ref);
09348    } else {
09349      p = new((void*) gvp) ROOT::Math::LSResidualFunc(*(ROOT::Math::LSResidualFunc*) libp->para[0].ref);
09350    }
09351    result7->obj.i = (long) p;
09352    result7->ref = (long) p;
09353    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc));
09354    return(1 || funcname || hash || result7 || libp) ;
09355 }
09356 
09357 static int G__G__MathMore_230_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09358 {
09359       {
09360          const ROOT::Math::LSResidualFunc& obj = ((ROOT::Math::LSResidualFunc*) G__getstructoffset())->operator=(*(ROOT::Math::LSResidualFunc*) libp->para[0].ref);
09361          result7->ref = (long) (&obj);
09362          result7->obj.i = (long) (&obj);
09363       }
09364    return(1 || funcname || hash || result7 || libp) ;
09365 }
09366 
09367 // automatic destructor
09368 typedef ROOT::Math::LSResidualFunc G__TROOTcLcLMathcLcLLSResidualFunc;
09369 static int G__G__MathMore_230_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09370 {
09371    char* gvp = (char*) G__getgvp();
09372    long soff = G__getstructoffset();
09373    int n = G__getaryconstruct();
09374    //
09375    //has_a_delete: 0
09376    //has_own_delete1arg: 0
09377    //has_own_delete2arg: 0
09378    //
09379    if (!soff) {
09380      return(1);
09381    }
09382    if (n) {
09383      if (gvp == (char*)G__PVOID) {
09384        delete[] (ROOT::Math::LSResidualFunc*) soff;
09385      } else {
09386        G__setgvp((long) G__PVOID);
09387        for (int i = n - 1; i >= 0; --i) {
09388          ((ROOT::Math::LSResidualFunc*) (soff+(sizeof(ROOT::Math::LSResidualFunc)*i)))->~G__TROOTcLcLMathcLcLLSResidualFunc();
09389        }
09390        G__setgvp((long)gvp);
09391      }
09392    } else {
09393      if (gvp == (char*)G__PVOID) {
09394        delete (ROOT::Math::LSResidualFunc*) soff;
09395      } else {
09396        G__setgvp((long) G__PVOID);
09397        ((ROOT::Math::LSResidualFunc*) (soff))->~G__TROOTcLcLMathcLcLLSResidualFunc();
09398        G__setgvp((long)gvp);
09399      }
09400    }
09401    G__setnull(result7);
09402    return(1 || funcname || hash || result7 || libp) ;
09403 }
09404 
09405 
09406 /* ROOT::Math::GSLNLSMinimizer */
09407 static int G__G__MathMore_231_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09408 {
09409    ROOT::Math::GSLNLSMinimizer* p = NULL;
09410    char* gvp = (char*) G__getgvp();
09411    switch (libp->paran) {
09412    case 1:
09413      //m: 1
09414      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09415        p = new ROOT::Math::GSLNLSMinimizer((int) G__int(libp->para[0]));
09416      } else {
09417        p = new((void*) gvp) ROOT::Math::GSLNLSMinimizer((int) G__int(libp->para[0]));
09418      }
09419      break;
09420    case 0:
09421      int n = G__getaryconstruct();
09422      if (n) {
09423        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09424          p = new ROOT::Math::GSLNLSMinimizer[n];
09425        } else {
09426          p = new((void*) gvp) ROOT::Math::GSLNLSMinimizer[n];
09427        }
09428      } else {
09429        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09430          p = new ROOT::Math::GSLNLSMinimizer;
09431        } else {
09432          p = new((void*) gvp) ROOT::Math::GSLNLSMinimizer;
09433        }
09434      }
09435      break;
09436    }
09437    result7->obj.i = (long) p;
09438    result7->ref = (long) p;
09439    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer));
09440    return(1 || funcname || hash || result7 || libp) ;
09441 }
09442 
09443 // automatic destructor
09444 typedef ROOT::Math::GSLNLSMinimizer G__TROOTcLcLMathcLcLGSLNLSMinimizer;
09445 static int G__G__MathMore_231_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09446 {
09447    char* gvp = (char*) G__getgvp();
09448    long soff = G__getstructoffset();
09449    int n = G__getaryconstruct();
09450    //
09451    //has_a_delete: 0
09452    //has_own_delete1arg: 0
09453    //has_own_delete2arg: 0
09454    //
09455    if (!soff) {
09456      return(1);
09457    }
09458    if (n) {
09459      if (gvp == (char*)G__PVOID) {
09460        delete[] (ROOT::Math::GSLNLSMinimizer*) soff;
09461      } else {
09462        G__setgvp((long) G__PVOID);
09463        for (int i = n - 1; i >= 0; --i) {
09464          ((ROOT::Math::GSLNLSMinimizer*) (soff+(sizeof(ROOT::Math::GSLNLSMinimizer)*i)))->~G__TROOTcLcLMathcLcLGSLNLSMinimizer();
09465        }
09466        G__setgvp((long)gvp);
09467      }
09468    } else {
09469      if (gvp == (char*)G__PVOID) {
09470        delete (ROOT::Math::GSLNLSMinimizer*) soff;
09471      } else {
09472        G__setgvp((long) G__PVOID);
09473        ((ROOT::Math::GSLNLSMinimizer*) (soff))->~G__TROOTcLcLMathcLcLGSLNLSMinimizer();
09474        G__setgvp((long)gvp);
09475      }
09476    }
09477    G__setnull(result7);
09478    return(1 || funcname || hash || result7 || libp) ;
09479 }
09480 
09481 
09482 /* ROOT::Math::GSLSimAnFunc */
09483 static int G__G__MathMore_236_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09484 {
09485    ROOT::Math::GSLSimAnFunc* p = NULL;
09486    char* gvp = (char*) G__getgvp();
09487    //m: 2
09488    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09489      p = new ROOT::Math::GSLSimAnFunc(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1]));
09490    } else {
09491      p = new((void*) gvp) ROOT::Math::GSLSimAnFunc(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1]));
09492    }
09493    result7->obj.i = (long) p;
09494    result7->ref = (long) p;
09495    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc));
09496    return(1 || funcname || hash || result7 || libp) ;
09497 }
09498 
09499 static int G__G__MathMore_236_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09500 {
09501    ROOT::Math::GSLSimAnFunc* p = NULL;
09502    char* gvp = (char*) G__getgvp();
09503    //m: 3
09504    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09505      p = new ROOT::Math::GSLSimAnFunc(
09506 *(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
09507 , (double*) G__int(libp->para[2]));
09508    } else {
09509      p = new((void*) gvp) ROOT::Math::GSLSimAnFunc(
09510 *(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
09511 , (double*) G__int(libp->para[2]));
09512    }
09513    result7->obj.i = (long) p;
09514    result7->ref = (long) p;
09515    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc));
09516    return(1 || funcname || hash || result7 || libp) ;
09517 }
09518 
09519 static int G__G__MathMore_236_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09520 {
09521       {
09522          const ROOT::Math::GSLSimAnFunc& obj = ((ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->FastCopy(*(ROOT::Math::GSLSimAnFunc*) libp->para[0].ref);
09523          result7->ref = (long) (&obj);
09524          result7->obj.i = (long) (&obj);
09525       }
09526    return(1 || funcname || hash || result7 || libp) ;
09527 }
09528 
09529 static int G__G__MathMore_236_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09530 {
09531       G__letint(result7, 85, (long) ((const ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->Clone());
09532    return(1 || funcname || hash || result7 || libp) ;
09533 }
09534 
09535 static int G__G__MathMore_236_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09536 {
09537       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->Energy());
09538    return(1 || funcname || hash || result7 || libp) ;
09539 }
09540 
09541 static int G__G__MathMore_236_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09542 {
09543       ((ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->Step(*(ROOT::Math::GSLRandomEngine*) libp->para[0].ref, (double) G__double(libp->para[1]));
09544       G__setnull(result7);
09545    return(1 || funcname || hash || result7 || libp) ;
09546 }
09547 
09548 static int G__G__MathMore_236_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09549 {
09550       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->Distance(*(ROOT::Math::GSLSimAnFunc*) libp->para[0].ref));
09551    return(1 || funcname || hash || result7 || libp) ;
09552 }
09553 
09554 static int G__G__MathMore_236_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09555 {
09556       ((ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->Print();
09557       G__setnull(result7);
09558    return(1 || funcname || hash || result7 || libp) ;
09559 }
09560 
09561 static int G__G__MathMore_236_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09562 {
09563       ((ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->SetX((double*) G__int(libp->para[0]));
09564       G__setnull(result7);
09565    return(1 || funcname || hash || result7 || libp) ;
09566 }
09567 
09568 static int G__G__MathMore_236_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09569 {
09570       G__letint(result7, 104, (long) ((const ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->NDim());
09571    return(1 || funcname || hash || result7 || libp) ;
09572 }
09573 
09574 static int G__G__MathMore_236_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09575 {
09576       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->X((unsigned int) G__int(libp->para[0])));
09577    return(1 || funcname || hash || result7 || libp) ;
09578 }
09579 
09580 static int G__G__MathMore_236_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09581 {
09582       {
09583          const vector<double>& obj = ((const ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->X();
09584          result7->ref = (long) (&obj);
09585          result7->obj.i = (long) (&obj);
09586       }
09587    return(1 || funcname || hash || result7 || libp) ;
09588 }
09589 
09590 static int G__G__MathMore_236_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09591 {
09592       G__letdouble(result7, 100, (double) ((const ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->Scale((unsigned int) G__int(libp->para[0])));
09593    return(1 || funcname || hash || result7 || libp) ;
09594 }
09595 
09596 static int G__G__MathMore_236_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09597 {
09598       ((ROOT::Math::GSLSimAnFunc*) G__getstructoffset())->SetX((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
09599       G__setnull(result7);
09600    return(1 || funcname || hash || result7 || libp) ;
09601 }
09602 
09603 // automatic copy constructor
09604 static int G__G__MathMore_236_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09605 
09606 {
09607    ROOT::Math::GSLSimAnFunc* p;
09608    void* tmp = (void*) G__int(libp->para[0]);
09609    p = new ROOT::Math::GSLSimAnFunc(*(ROOT::Math::GSLSimAnFunc*) tmp);
09610    result7->obj.i = (long) p;
09611    result7->ref = (long) p;
09612    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc));
09613    return(1 || funcname || hash || result7 || libp) ;
09614 }
09615 
09616 // automatic destructor
09617 typedef ROOT::Math::GSLSimAnFunc G__TROOTcLcLMathcLcLGSLSimAnFunc;
09618 static int G__G__MathMore_236_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09619 {
09620    char* gvp = (char*) G__getgvp();
09621    long soff = G__getstructoffset();
09622    int n = G__getaryconstruct();
09623    //
09624    //has_a_delete: 0
09625    //has_own_delete1arg: 0
09626    //has_own_delete2arg: 0
09627    //
09628    if (!soff) {
09629      return(1);
09630    }
09631    if (n) {
09632      if (gvp == (char*)G__PVOID) {
09633        delete[] (ROOT::Math::GSLSimAnFunc*) soff;
09634      } else {
09635        G__setgvp((long) G__PVOID);
09636        for (int i = n - 1; i >= 0; --i) {
09637          ((ROOT::Math::GSLSimAnFunc*) (soff+(sizeof(ROOT::Math::GSLSimAnFunc)*i)))->~G__TROOTcLcLMathcLcLGSLSimAnFunc();
09638        }
09639        G__setgvp((long)gvp);
09640      }
09641    } else {
09642      if (gvp == (char*)G__PVOID) {
09643        delete (ROOT::Math::GSLSimAnFunc*) soff;
09644      } else {
09645        G__setgvp((long) G__PVOID);
09646        ((ROOT::Math::GSLSimAnFunc*) (soff))->~G__TROOTcLcLMathcLcLGSLSimAnFunc();
09647        G__setgvp((long)gvp);
09648      }
09649    }
09650    G__setnull(result7);
09651    return(1 || funcname || hash || result7 || libp) ;
09652 }
09653 
09654 
09655 /* ROOT::Math::GSLSimAnParams */
09656 static int G__G__MathMore_237_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09657 {
09658    ROOT::Math::GSLSimAnParams* p = NULL;
09659    char* gvp = (char*) G__getgvp();
09660    int n = G__getaryconstruct();
09661    if (n) {
09662      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09663        p = new ROOT::Math::GSLSimAnParams[n];
09664      } else {
09665        p = new((void*) gvp) ROOT::Math::GSLSimAnParams[n];
09666      }
09667    } else {
09668      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09669        p = new ROOT::Math::GSLSimAnParams;
09670      } else {
09671        p = new((void*) gvp) ROOT::Math::GSLSimAnParams;
09672      }
09673    }
09674    result7->obj.i = (long) p;
09675    result7->ref = (long) p;
09676    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams));
09677    return(1 || funcname || hash || result7 || libp) ;
09678 }
09679 
09680 // automatic copy constructor
09681 static int G__G__MathMore_237_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09682 
09683 {
09684    ROOT::Math::GSLSimAnParams* p;
09685    void* tmp = (void*) G__int(libp->para[0]);
09686    p = new ROOT::Math::GSLSimAnParams(*(ROOT::Math::GSLSimAnParams*) tmp);
09687    result7->obj.i = (long) p;
09688    result7->ref = (long) p;
09689    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams));
09690    return(1 || funcname || hash || result7 || libp) ;
09691 }
09692 
09693 // automatic destructor
09694 typedef ROOT::Math::GSLSimAnParams G__TROOTcLcLMathcLcLGSLSimAnParams;
09695 static int G__G__MathMore_237_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09696 {
09697    char* gvp = (char*) G__getgvp();
09698    long soff = G__getstructoffset();
09699    int n = G__getaryconstruct();
09700    //
09701    //has_a_delete: 0
09702    //has_own_delete1arg: 0
09703    //has_own_delete2arg: 0
09704    //
09705    if (!soff) {
09706      return(1);
09707    }
09708    if (n) {
09709      if (gvp == (char*)G__PVOID) {
09710        delete[] (ROOT::Math::GSLSimAnParams*) soff;
09711      } else {
09712        G__setgvp((long) G__PVOID);
09713        for (int i = n - 1; i >= 0; --i) {
09714          ((ROOT::Math::GSLSimAnParams*) (soff+(sizeof(ROOT::Math::GSLSimAnParams)*i)))->~G__TROOTcLcLMathcLcLGSLSimAnParams();
09715        }
09716        G__setgvp((long)gvp);
09717      }
09718    } else {
09719      if (gvp == (char*)G__PVOID) {
09720        delete (ROOT::Math::GSLSimAnParams*) soff;
09721      } else {
09722        G__setgvp((long) G__PVOID);
09723        ((ROOT::Math::GSLSimAnParams*) (soff))->~G__TROOTcLcLMathcLcLGSLSimAnParams();
09724        G__setgvp((long)gvp);
09725      }
09726    }
09727    G__setnull(result7);
09728    return(1 || funcname || hash || result7 || libp) ;
09729 }
09730 
09731 // automatic assignment operator
09732 static int G__G__MathMore_237_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09733 {
09734    ROOT::Math::GSLSimAnParams* dest = (ROOT::Math::GSLSimAnParams*) G__getstructoffset();
09735    *dest = *(ROOT::Math::GSLSimAnParams*) libp->para[0].ref;
09736    const ROOT::Math::GSLSimAnParams& obj = *dest;
09737    result7->ref = (long) (&obj);
09738    result7->obj.i = (long) (&obj);
09739    return(1 || funcname || hash || result7 || libp) ;
09740 }
09741 
09742 
09743 /* ROOT::Math::GSLSimAnnealing */
09744 static int G__G__MathMore_238_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09745 {
09746    ROOT::Math::GSLSimAnnealing* p = NULL;
09747    char* gvp = (char*) G__getgvp();
09748    int n = G__getaryconstruct();
09749    if (n) {
09750      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09751        p = new ROOT::Math::GSLSimAnnealing[n];
09752      } else {
09753        p = new((void*) gvp) ROOT::Math::GSLSimAnnealing[n];
09754      }
09755    } else {
09756      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09757        p = new ROOT::Math::GSLSimAnnealing;
09758      } else {
09759        p = new((void*) gvp) ROOT::Math::GSLSimAnnealing;
09760      }
09761    }
09762    result7->obj.i = (long) p;
09763    result7->ref = (long) p;
09764    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing));
09765    return(1 || funcname || hash || result7 || libp) ;
09766 }
09767 
09768 static int G__G__MathMore_238_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09769 {
09770    switch (libp->paran) {
09771    case 5:
09772       G__letint(result7, 105, (long) ((ROOT::Math::GSLSimAnnealing*) G__getstructoffset())->Solve(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
09773 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
09774 , (bool) G__int(libp->para[4])));
09775       break;
09776    case 4:
09777       G__letint(result7, 105, (long) ((ROOT::Math::GSLSimAnnealing*) G__getstructoffset())->Solve(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
09778 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])));
09779       break;
09780    }
09781    return(1 || funcname || hash || result7 || libp) ;
09782 }
09783 
09784 static int G__G__MathMore_238_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09785 {
09786    switch (libp->paran) {
09787    case 2:
09788       G__letint(result7, 105, (long) ((ROOT::Math::GSLSimAnnealing*) G__getstructoffset())->Solve(*(ROOT::Math::GSLSimAnFunc*) libp->para[0].ref, (bool) G__int(libp->para[1])));
09789       break;
09790    case 1:
09791       G__letint(result7, 105, (long) ((ROOT::Math::GSLSimAnnealing*) G__getstructoffset())->Solve(*(ROOT::Math::GSLSimAnFunc*) libp->para[0].ref));
09792       break;
09793    }
09794    return(1 || funcname || hash || result7 || libp) ;
09795 }
09796 
09797 static int G__G__MathMore_238_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09798 {
09799       {
09800          const ROOT::Math::GSLSimAnParams& obj = ((ROOT::Math::GSLSimAnnealing*) G__getstructoffset())->Params();
09801          result7->ref = (long) (&obj);
09802          result7->obj.i = (long) (&obj);
09803       }
09804    return(1 || funcname || hash || result7 || libp) ;
09805 }
09806 
09807 static int G__G__MathMore_238_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09808 {
09809       {
09810          const ROOT::Math::GSLSimAnParams& obj = ((const ROOT::Math::GSLSimAnnealing*) G__getstructoffset())->Params();
09811          result7->ref = (long) (&obj);
09812          result7->obj.i = (long) (&obj);
09813       }
09814    return(1 || funcname || hash || result7 || libp) ;
09815 }
09816 
09817 // automatic destructor
09818 typedef ROOT::Math::GSLSimAnnealing G__TROOTcLcLMathcLcLGSLSimAnnealing;
09819 static int G__G__MathMore_238_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09820 {
09821    char* gvp = (char*) G__getgvp();
09822    long soff = G__getstructoffset();
09823    int n = G__getaryconstruct();
09824    //
09825    //has_a_delete: 0
09826    //has_own_delete1arg: 0
09827    //has_own_delete2arg: 0
09828    //
09829    if (!soff) {
09830      return(1);
09831    }
09832    if (n) {
09833      if (gvp == (char*)G__PVOID) {
09834        delete[] (ROOT::Math::GSLSimAnnealing*) soff;
09835      } else {
09836        G__setgvp((long) G__PVOID);
09837        for (int i = n - 1; i >= 0; --i) {
09838          ((ROOT::Math::GSLSimAnnealing*) (soff+(sizeof(ROOT::Math::GSLSimAnnealing)*i)))->~G__TROOTcLcLMathcLcLGSLSimAnnealing();
09839        }
09840        G__setgvp((long)gvp);
09841      }
09842    } else {
09843      if (gvp == (char*)G__PVOID) {
09844        delete (ROOT::Math::GSLSimAnnealing*) soff;
09845      } else {
09846        G__setgvp((long) G__PVOID);
09847        ((ROOT::Math::GSLSimAnnealing*) (soff))->~G__TROOTcLcLMathcLcLGSLSimAnnealing();
09848        G__setgvp((long)gvp);
09849      }
09850    }
09851    G__setnull(result7);
09852    return(1 || funcname || hash || result7 || libp) ;
09853 }
09854 
09855 
09856 /* ROOT::Math::GSLSimAnMinimizer */
09857 static int G__G__MathMore_239_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09858 {
09859    ROOT::Math::GSLSimAnMinimizer* p = NULL;
09860    char* gvp = (char*) G__getgvp();
09861    switch (libp->paran) {
09862    case 1:
09863      //m: 1
09864      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09865        p = new ROOT::Math::GSLSimAnMinimizer((int) G__int(libp->para[0]));
09866      } else {
09867        p = new((void*) gvp) ROOT::Math::GSLSimAnMinimizer((int) G__int(libp->para[0]));
09868      }
09869      break;
09870    case 0:
09871      int n = G__getaryconstruct();
09872      if (n) {
09873        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09874          p = new ROOT::Math::GSLSimAnMinimizer[n];
09875        } else {
09876          p = new((void*) gvp) ROOT::Math::GSLSimAnMinimizer[n];
09877        }
09878      } else {
09879        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09880          p = new ROOT::Math::GSLSimAnMinimizer;
09881        } else {
09882          p = new((void*) gvp) ROOT::Math::GSLSimAnMinimizer;
09883        }
09884      }
09885      break;
09886    }
09887    result7->obj.i = (long) p;
09888    result7->ref = (long) p;
09889    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer));
09890    return(1 || funcname || hash || result7 || libp) ;
09891 }
09892 
09893 // automatic destructor
09894 typedef ROOT::Math::GSLSimAnMinimizer G__TROOTcLcLMathcLcLGSLSimAnMinimizer;
09895 static int G__G__MathMore_239_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09896 {
09897    char* gvp = (char*) G__getgvp();
09898    long soff = G__getstructoffset();
09899    int n = G__getaryconstruct();
09900    //
09901    //has_a_delete: 0
09902    //has_own_delete1arg: 0
09903    //has_own_delete2arg: 0
09904    //
09905    if (!soff) {
09906      return(1);
09907    }
09908    if (n) {
09909      if (gvp == (char*)G__PVOID) {
09910        delete[] (ROOT::Math::GSLSimAnMinimizer*) soff;
09911      } else {
09912        G__setgvp((long) G__PVOID);
09913        for (int i = n - 1; i >= 0; --i) {
09914          ((ROOT::Math::GSLSimAnMinimizer*) (soff+(sizeof(ROOT::Math::GSLSimAnMinimizer)*i)))->~G__TROOTcLcLMathcLcLGSLSimAnMinimizer();
09915        }
09916        G__setgvp((long)gvp);
09917      }
09918    } else {
09919      if (gvp == (char*)G__PVOID) {
09920        delete (ROOT::Math::GSLSimAnMinimizer*) soff;
09921      } else {
09922        G__setgvp((long) G__PVOID);
09923        ((ROOT::Math::GSLSimAnMinimizer*) (soff))->~G__TROOTcLcLMathcLcLGSLSimAnMinimizer();
09924        G__setgvp((long)gvp);
09925      }
09926    }
09927    G__setnull(result7);
09928    return(1 || funcname || hash || result7 || libp) ;
09929 }
09930 
09931 
09932 /* ROOT::Math::Vavilov */
09933 static int G__G__MathMore_240_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09934 {
09935       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Pdf((double) G__double(libp->para[0])));
09936    return(1 || funcname || hash || result7 || libp) ;
09937 }
09938 
09939 static int G__G__MathMore_240_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09940 {
09941       G__letdouble(result7, 100, (double) ((ROOT::Math::Vavilov*) G__getstructoffset())->Pdf((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
09942 , (double) G__double(libp->para[2])));
09943    return(1 || funcname || hash || result7 || libp) ;
09944 }
09945 
09946 static int G__G__MathMore_240_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09947 {
09948       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Cdf((double) G__double(libp->para[0])));
09949    return(1 || funcname || hash || result7 || libp) ;
09950 }
09951 
09952 static int G__G__MathMore_240_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09953 {
09954       G__letdouble(result7, 100, (double) ((ROOT::Math::Vavilov*) G__getstructoffset())->Cdf((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
09955 , (double) G__double(libp->para[2])));
09956    return(1 || funcname || hash || result7 || libp) ;
09957 }
09958 
09959 static int G__G__MathMore_240_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09960 {
09961       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Cdf_c((double) G__double(libp->para[0])));
09962    return(1 || funcname || hash || result7 || libp) ;
09963 }
09964 
09965 static int G__G__MathMore_240_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09966 {
09967       G__letdouble(result7, 100, (double) ((ROOT::Math::Vavilov*) G__getstructoffset())->Cdf_c((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
09968 , (double) G__double(libp->para[2])));
09969    return(1 || funcname || hash || result7 || libp) ;
09970 }
09971 
09972 static int G__G__MathMore_240_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09973 {
09974       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Quantile((double) G__double(libp->para[0])));
09975    return(1 || funcname || hash || result7 || libp) ;
09976 }
09977 
09978 static int G__G__MathMore_240_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09979 {
09980       G__letdouble(result7, 100, (double) ((ROOT::Math::Vavilov*) G__getstructoffset())->Quantile((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
09981 , (double) G__double(libp->para[2])));
09982    return(1 || funcname || hash || result7 || libp) ;
09983 }
09984 
09985 static int G__G__MathMore_240_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09986 {
09987       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Quantile_c((double) G__double(libp->para[0])));
09988    return(1 || funcname || hash || result7 || libp) ;
09989 }
09990 
09991 static int G__G__MathMore_240_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09992 {
09993       G__letdouble(result7, 100, (double) ((ROOT::Math::Vavilov*) G__getstructoffset())->Quantile_c((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
09994 , (double) G__double(libp->para[2])));
09995    return(1 || funcname || hash || result7 || libp) ;
09996 }
09997 
09998 static int G__G__MathMore_240_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09999 {
10000       ((ROOT::Math::Vavilov*) G__getstructoffset())->SetKappaBeta2((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
10001       G__setnull(result7);
10002    return(1 || funcname || hash || result7 || libp) ;
10003 }
10004 
10005 static int G__G__MathMore_240_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10006 {
10007       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->GetLambdaMin());
10008    return(1 || funcname || hash || result7 || libp) ;
10009 }
10010 
10011 static int G__G__MathMore_240_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10012 {
10013       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->GetLambdaMax());
10014    return(1 || funcname || hash || result7 || libp) ;
10015 }
10016 
10017 static int G__G__MathMore_240_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10018 {
10019       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->GetKappa());
10020    return(1 || funcname || hash || result7 || libp) ;
10021 }
10022 
10023 static int G__G__MathMore_240_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10024 {
10025       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->GetBeta2());
10026    return(1 || funcname || hash || result7 || libp) ;
10027 }
10028 
10029 static int G__G__MathMore_240_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10030 {
10031       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Mode());
10032    return(1 || funcname || hash || result7 || libp) ;
10033 }
10034 
10035 static int G__G__MathMore_240_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10036 {
10037       G__letdouble(result7, 100, (double) ((ROOT::Math::Vavilov*) G__getstructoffset())->Mode((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10038    return(1 || funcname || hash || result7 || libp) ;
10039 }
10040 
10041 static int G__G__MathMore_240_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10042 {
10043       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Mean());
10044    return(1 || funcname || hash || result7 || libp) ;
10045 }
10046 
10047 static int G__G__MathMore_240_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10048 {
10049       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Variance());
10050    return(1 || funcname || hash || result7 || libp) ;
10051 }
10052 
10053 static int G__G__MathMore_240_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10054 {
10055       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Skewness());
10056    return(1 || funcname || hash || result7 || libp) ;
10057 }
10058 
10059 static int G__G__MathMore_240_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10060 {
10061       G__letdouble(result7, 100, (double) ((const ROOT::Math::Vavilov*) G__getstructoffset())->Kurtosis());
10062    return(1 || funcname || hash || result7 || libp) ;
10063 }
10064 
10065 static int G__G__MathMore_240_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10066 {
10067       G__letdouble(result7, 100, (double) ROOT::Math::Vavilov::Mean((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10068    return(1 || funcname || hash || result7 || libp) ;
10069 }
10070 
10071 static int G__G__MathMore_240_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10072 {
10073       G__letdouble(result7, 100, (double) ROOT::Math::Vavilov::Variance((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10074    return(1 || funcname || hash || result7 || libp) ;
10075 }
10076 
10077 static int G__G__MathMore_240_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10078 {
10079       G__letdouble(result7, 100, (double) ROOT::Math::Vavilov::Skewness((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10080    return(1 || funcname || hash || result7 || libp) ;
10081 }
10082 
10083 static int G__G__MathMore_240_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10084 {
10085       G__letdouble(result7, 100, (double) ROOT::Math::Vavilov::Kurtosis((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10086    return(1 || funcname || hash || result7 || libp) ;
10087 }
10088 
10089 // automatic destructor
10090 typedef ROOT::Math::Vavilov G__TROOTcLcLMathcLcLVavilov;
10091 static int G__G__MathMore_240_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10092 {
10093    char* gvp = (char*) G__getgvp();
10094    long soff = G__getstructoffset();
10095    int n = G__getaryconstruct();
10096    //
10097    //has_a_delete: 0
10098    //has_own_delete1arg: 0
10099    //has_own_delete2arg: 0
10100    //
10101    if (!soff) {
10102      return(1);
10103    }
10104    if (n) {
10105      if (gvp == (char*)G__PVOID) {
10106        delete[] (ROOT::Math::Vavilov*) soff;
10107      } else {
10108        G__setgvp((long) G__PVOID);
10109        for (int i = n - 1; i >= 0; --i) {
10110          ((ROOT::Math::Vavilov*) (soff+(sizeof(ROOT::Math::Vavilov)*i)))->~G__TROOTcLcLMathcLcLVavilov();
10111        }
10112        G__setgvp((long)gvp);
10113      }
10114    } else {
10115      if (gvp == (char*)G__PVOID) {
10116        delete (ROOT::Math::Vavilov*) soff;
10117      } else {
10118        G__setgvp((long) G__PVOID);
10119        ((ROOT::Math::Vavilov*) (soff))->~G__TROOTcLcLMathcLcLVavilov();
10120        G__setgvp((long)gvp);
10121      }
10122    }
10123    G__setnull(result7);
10124    return(1 || funcname || hash || result7 || libp) ;
10125 }
10126 
10127 // automatic assignment operator
10128 static int G__G__MathMore_240_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10129 {
10130    ROOT::Math::Vavilov* dest = (ROOT::Math::Vavilov*) G__getstructoffset();
10131    *dest = *(ROOT::Math::Vavilov*) libp->para[0].ref;
10132    const ROOT::Math::Vavilov& obj = *dest;
10133    result7->ref = (long) (&obj);
10134    result7->obj.i = (long) (&obj);
10135    return(1 || funcname || hash || result7 || libp) ;
10136 }
10137 
10138 
10139 /* ROOT::Math::VavilovAccurate */
10140 static int G__G__MathMore_241_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10141 {
10142    ROOT::Math::VavilovAccurate* p = NULL;
10143    char* gvp = (char*) G__getgvp();
10144    switch (libp->paran) {
10145    case 4:
10146      //m: 4
10147      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10148        p = new ROOT::Math::VavilovAccurate(
10149 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
10150 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
10151      } else {
10152        p = new((void*) gvp) ROOT::Math::VavilovAccurate(
10153 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
10154 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
10155      }
10156      break;
10157    case 3:
10158      //m: 3
10159      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10160        p = new ROOT::Math::VavilovAccurate(
10161 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
10162 , (double) G__double(libp->para[2]));
10163      } else {
10164        p = new((void*) gvp) ROOT::Math::VavilovAccurate(
10165 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
10166 , (double) G__double(libp->para[2]));
10167      }
10168      break;
10169    case 2:
10170      //m: 2
10171      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10172        p = new ROOT::Math::VavilovAccurate((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
10173      } else {
10174        p = new((void*) gvp) ROOT::Math::VavilovAccurate((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
10175      }
10176      break;
10177    case 1:
10178      //m: 1
10179      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10180        p = new ROOT::Math::VavilovAccurate((double) G__double(libp->para[0]));
10181      } else {
10182        p = new((void*) gvp) ROOT::Math::VavilovAccurate((double) G__double(libp->para[0]));
10183      }
10184      break;
10185    case 0:
10186      int n = G__getaryconstruct();
10187      if (n) {
10188        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10189          p = new ROOT::Math::VavilovAccurate[n];
10190        } else {
10191          p = new((void*) gvp) ROOT::Math::VavilovAccurate[n];
10192        }
10193      } else {
10194        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10195          p = new ROOT::Math::VavilovAccurate;
10196        } else {
10197          p = new((void*) gvp) ROOT::Math::VavilovAccurate;
10198        }
10199      }
10200      break;
10201    }
10202    result7->obj.i = (long) p;
10203    result7->ref = (long) p;
10204    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate));
10205    return(1 || funcname || hash || result7 || libp) ;
10206 }
10207 
10208 static int G__G__MathMore_241_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10209 {
10210    switch (libp->paran) {
10211    case 4:
10212       ((ROOT::Math::VavilovAccurate*) G__getstructoffset())->Set((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
10213 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
10214       G__setnull(result7);
10215       break;
10216    case 3:
10217       ((ROOT::Math::VavilovAccurate*) G__getstructoffset())->Set((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
10218 , (double) G__double(libp->para[2]));
10219       G__setnull(result7);
10220       break;
10221    case 2:
10222       ((ROOT::Math::VavilovAccurate*) G__getstructoffset())->Set((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
10223       G__setnull(result7);
10224       break;
10225    }
10226    return(1 || funcname || hash || result7 || libp) ;
10227 }
10228 
10229 static int G__G__MathMore_241_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10230 {
10231       G__letdouble(result7, 100, (double) ((const ROOT::Math::VavilovAccurate*) G__getstructoffset())->GetEpsilonPM());
10232    return(1 || funcname || hash || result7 || libp) ;
10233 }
10234 
10235 static int G__G__MathMore_241_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10236 {
10237       G__letdouble(result7, 100, (double) ((const ROOT::Math::VavilovAccurate*) G__getstructoffset())->GetEpsilon());
10238    return(1 || funcname || hash || result7 || libp) ;
10239 }
10240 
10241 static int G__G__MathMore_241_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10242 {
10243       G__letdouble(result7, 100, (double) ((const ROOT::Math::VavilovAccurate*) G__getstructoffset())->GetNTerms());
10244    return(1 || funcname || hash || result7 || libp) ;
10245 }
10246 
10247 static int G__G__MathMore_241_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10248 {
10249       G__letint(result7, 85, (long) ROOT::Math::VavilovAccurate::GetInstance());
10250    return(1 || funcname || hash || result7 || libp) ;
10251 }
10252 
10253 static int G__G__MathMore_241_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10254 {
10255       G__letint(result7, 85, (long) ROOT::Math::VavilovAccurate::GetInstance((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10256    return(1 || funcname || hash || result7 || libp) ;
10257 }
10258 
10259 // automatic copy constructor
10260 static int G__G__MathMore_241_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10261 
10262 {
10263    ROOT::Math::VavilovAccurate* p;
10264    void* tmp = (void*) G__int(libp->para[0]);
10265    p = new ROOT::Math::VavilovAccurate(*(ROOT::Math::VavilovAccurate*) tmp);
10266    result7->obj.i = (long) p;
10267    result7->ref = (long) p;
10268    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate));
10269    return(1 || funcname || hash || result7 || libp) ;
10270 }
10271 
10272 // automatic destructor
10273 typedef ROOT::Math::VavilovAccurate G__TROOTcLcLMathcLcLVavilovAccurate;
10274 static int G__G__MathMore_241_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10275 {
10276    char* gvp = (char*) G__getgvp();
10277    long soff = G__getstructoffset();
10278    int n = G__getaryconstruct();
10279    //
10280    //has_a_delete: 0
10281    //has_own_delete1arg: 0
10282    //has_own_delete2arg: 0
10283    //
10284    if (!soff) {
10285      return(1);
10286    }
10287    if (n) {
10288      if (gvp == (char*)G__PVOID) {
10289        delete[] (ROOT::Math::VavilovAccurate*) soff;
10290      } else {
10291        G__setgvp((long) G__PVOID);
10292        for (int i = n - 1; i >= 0; --i) {
10293          ((ROOT::Math::VavilovAccurate*) (soff+(sizeof(ROOT::Math::VavilovAccurate)*i)))->~G__TROOTcLcLMathcLcLVavilovAccurate();
10294        }
10295        G__setgvp((long)gvp);
10296      }
10297    } else {
10298      if (gvp == (char*)G__PVOID) {
10299        delete (ROOT::Math::VavilovAccurate*) soff;
10300      } else {
10301        G__setgvp((long) G__PVOID);
10302        ((ROOT::Math::VavilovAccurate*) (soff))->~G__TROOTcLcLMathcLcLVavilovAccurate();
10303        G__setgvp((long)gvp);
10304      }
10305    }
10306    G__setnull(result7);
10307    return(1 || funcname || hash || result7 || libp) ;
10308 }
10309 
10310 // automatic assignment operator
10311 static int G__G__MathMore_241_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10312 {
10313    ROOT::Math::VavilovAccurate* dest = (ROOT::Math::VavilovAccurate*) G__getstructoffset();
10314    *dest = *(ROOT::Math::VavilovAccurate*) libp->para[0].ref;
10315    const ROOT::Math::VavilovAccurate& obj = *dest;
10316    result7->ref = (long) (&obj);
10317    result7->obj.i = (long) (&obj);
10318    return(1 || funcname || hash || result7 || libp) ;
10319 }
10320 
10321 
10322 /* ROOT::Math::VavilovAccuratePdf */
10323 static int G__G__MathMore_243_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10324 {
10325    ROOT::Math::VavilovAccuratePdf* p = NULL;
10326    char* gvp = (char*) G__getgvp();
10327    int n = G__getaryconstruct();
10328    if (n) {
10329      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10330        p = new ROOT::Math::VavilovAccuratePdf[n];
10331      } else {
10332        p = new((void*) gvp) ROOT::Math::VavilovAccuratePdf[n];
10333      }
10334    } else {
10335      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10336        p = new ROOT::Math::VavilovAccuratePdf;
10337      } else {
10338        p = new((void*) gvp) ROOT::Math::VavilovAccuratePdf;
10339      }
10340    }
10341    result7->obj.i = (long) p;
10342    result7->ref = (long) p;
10343    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf));
10344    return(1 || funcname || hash || result7 || libp) ;
10345 }
10346 
10347 static int G__G__MathMore_243_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10348 {
10349    ROOT::Math::VavilovAccuratePdf* p = NULL;
10350    char* gvp = (char*) G__getgvp();
10351    //m: 1
10352    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10353      p = new ROOT::Math::VavilovAccuratePdf((double*) G__int(libp->para[0]));
10354    } else {
10355      p = new((void*) gvp) ROOT::Math::VavilovAccuratePdf((double*) G__int(libp->para[0]));
10356    }
10357    result7->obj.i = (long) p;
10358    result7->ref = (long) p;
10359    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf));
10360    return(1 || funcname || hash || result7 || libp) ;
10361 }
10362 
10363 // automatic copy constructor
10364 static int G__G__MathMore_243_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10365 
10366 {
10367    ROOT::Math::VavilovAccuratePdf* p;
10368    void* tmp = (void*) G__int(libp->para[0]);
10369    p = new ROOT::Math::VavilovAccuratePdf(*(ROOT::Math::VavilovAccuratePdf*) tmp);
10370    result7->obj.i = (long) p;
10371    result7->ref = (long) p;
10372    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf));
10373    return(1 || funcname || hash || result7 || libp) ;
10374 }
10375 
10376 // automatic destructor
10377 typedef ROOT::Math::VavilovAccuratePdf G__TROOTcLcLMathcLcLVavilovAccuratePdf;
10378 static int G__G__MathMore_243_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10379 {
10380    char* gvp = (char*) G__getgvp();
10381    long soff = G__getstructoffset();
10382    int n = G__getaryconstruct();
10383    //
10384    //has_a_delete: 0
10385    //has_own_delete1arg: 0
10386    //has_own_delete2arg: 0
10387    //
10388    if (!soff) {
10389      return(1);
10390    }
10391    if (n) {
10392      if (gvp == (char*)G__PVOID) {
10393        delete[] (ROOT::Math::VavilovAccuratePdf*) soff;
10394      } else {
10395        G__setgvp((long) G__PVOID);
10396        for (int i = n - 1; i >= 0; --i) {
10397          ((ROOT::Math::VavilovAccuratePdf*) (soff+(sizeof(ROOT::Math::VavilovAccuratePdf)*i)))->~G__TROOTcLcLMathcLcLVavilovAccuratePdf();
10398        }
10399        G__setgvp((long)gvp);
10400      }
10401    } else {
10402      if (gvp == (char*)G__PVOID) {
10403        delete (ROOT::Math::VavilovAccuratePdf*) soff;
10404      } else {
10405        G__setgvp((long) G__PVOID);
10406        ((ROOT::Math::VavilovAccuratePdf*) (soff))->~G__TROOTcLcLMathcLcLVavilovAccuratePdf();
10407        G__setgvp((long)gvp);
10408      }
10409    }
10410    G__setnull(result7);
10411    return(1 || funcname || hash || result7 || libp) ;
10412 }
10413 
10414 // automatic assignment operator
10415 static int G__G__MathMore_243_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10416 {
10417    ROOT::Math::VavilovAccuratePdf* dest = (ROOT::Math::VavilovAccuratePdf*) G__getstructoffset();
10418    *dest = *(ROOT::Math::VavilovAccuratePdf*) libp->para[0].ref;
10419    const ROOT::Math::VavilovAccuratePdf& obj = *dest;
10420    result7->ref = (long) (&obj);
10421    result7->obj.i = (long) (&obj);
10422    return(1 || funcname || hash || result7 || libp) ;
10423 }
10424 
10425 
10426 /* ROOT::Math::VavilovAccurateCdf */
10427 static int G__G__MathMore_244_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10428 {
10429    ROOT::Math::VavilovAccurateCdf* p = NULL;
10430    char* gvp = (char*) G__getgvp();
10431    int n = G__getaryconstruct();
10432    if (n) {
10433      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10434        p = new ROOT::Math::VavilovAccurateCdf[n];
10435      } else {
10436        p = new((void*) gvp) ROOT::Math::VavilovAccurateCdf[n];
10437      }
10438    } else {
10439      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10440        p = new ROOT::Math::VavilovAccurateCdf;
10441      } else {
10442        p = new((void*) gvp) ROOT::Math::VavilovAccurateCdf;
10443      }
10444    }
10445    result7->obj.i = (long) p;
10446    result7->ref = (long) p;
10447    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf));
10448    return(1 || funcname || hash || result7 || libp) ;
10449 }
10450 
10451 static int G__G__MathMore_244_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10452 {
10453    ROOT::Math::VavilovAccurateCdf* p = NULL;
10454    char* gvp = (char*) G__getgvp();
10455    //m: 1
10456    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10457      p = new ROOT::Math::VavilovAccurateCdf((double*) G__int(libp->para[0]));
10458    } else {
10459      p = new((void*) gvp) ROOT::Math::VavilovAccurateCdf((double*) G__int(libp->para[0]));
10460    }
10461    result7->obj.i = (long) p;
10462    result7->ref = (long) p;
10463    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf));
10464    return(1 || funcname || hash || result7 || libp) ;
10465 }
10466 
10467 // automatic copy constructor
10468 static int G__G__MathMore_244_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10469 
10470 {
10471    ROOT::Math::VavilovAccurateCdf* p;
10472    void* tmp = (void*) G__int(libp->para[0]);
10473    p = new ROOT::Math::VavilovAccurateCdf(*(ROOT::Math::VavilovAccurateCdf*) tmp);
10474    result7->obj.i = (long) p;
10475    result7->ref = (long) p;
10476    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf));
10477    return(1 || funcname || hash || result7 || libp) ;
10478 }
10479 
10480 // automatic destructor
10481 typedef ROOT::Math::VavilovAccurateCdf G__TROOTcLcLMathcLcLVavilovAccurateCdf;
10482 static int G__G__MathMore_244_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10483 {
10484    char* gvp = (char*) G__getgvp();
10485    long soff = G__getstructoffset();
10486    int n = G__getaryconstruct();
10487    //
10488    //has_a_delete: 0
10489    //has_own_delete1arg: 0
10490    //has_own_delete2arg: 0
10491    //
10492    if (!soff) {
10493      return(1);
10494    }
10495    if (n) {
10496      if (gvp == (char*)G__PVOID) {
10497        delete[] (ROOT::Math::VavilovAccurateCdf*) soff;
10498      } else {
10499        G__setgvp((long) G__PVOID);
10500        for (int i = n - 1; i >= 0; --i) {
10501          ((ROOT::Math::VavilovAccurateCdf*) (soff+(sizeof(ROOT::Math::VavilovAccurateCdf)*i)))->~G__TROOTcLcLMathcLcLVavilovAccurateCdf();
10502        }
10503        G__setgvp((long)gvp);
10504      }
10505    } else {
10506      if (gvp == (char*)G__PVOID) {
10507        delete (ROOT::Math::VavilovAccurateCdf*) soff;
10508      } else {
10509        G__setgvp((long) G__PVOID);
10510        ((ROOT::Math::VavilovAccurateCdf*) (soff))->~G__TROOTcLcLMathcLcLVavilovAccurateCdf();
10511        G__setgvp((long)gvp);
10512      }
10513    }
10514    G__setnull(result7);
10515    return(1 || funcname || hash || result7 || libp) ;
10516 }
10517 
10518 // automatic assignment operator
10519 static int G__G__MathMore_244_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10520 {
10521    ROOT::Math::VavilovAccurateCdf* dest = (ROOT::Math::VavilovAccurateCdf*) G__getstructoffset();
10522    *dest = *(ROOT::Math::VavilovAccurateCdf*) libp->para[0].ref;
10523    const ROOT::Math::VavilovAccurateCdf& obj = *dest;
10524    result7->ref = (long) (&obj);
10525    result7->obj.i = (long) (&obj);
10526    return(1 || funcname || hash || result7 || libp) ;
10527 }
10528 
10529 
10530 /* ROOT::Math::VavilovAccurateQuantile */
10531 static int G__G__MathMore_245_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10532 {
10533    ROOT::Math::VavilovAccurateQuantile* p = NULL;
10534    char* gvp = (char*) G__getgvp();
10535    int n = G__getaryconstruct();
10536    if (n) {
10537      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10538        p = new ROOT::Math::VavilovAccurateQuantile[n];
10539      } else {
10540        p = new((void*) gvp) ROOT::Math::VavilovAccurateQuantile[n];
10541      }
10542    } else {
10543      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10544        p = new ROOT::Math::VavilovAccurateQuantile;
10545      } else {
10546        p = new((void*) gvp) ROOT::Math::VavilovAccurateQuantile;
10547      }
10548    }
10549    result7->obj.i = (long) p;
10550    result7->ref = (long) p;
10551    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile));
10552    return(1 || funcname || hash || result7 || libp) ;
10553 }
10554 
10555 static int G__G__MathMore_245_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10556 {
10557    ROOT::Math::VavilovAccurateQuantile* p = NULL;
10558    char* gvp = (char*) G__getgvp();
10559    //m: 1
10560    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10561      p = new ROOT::Math::VavilovAccurateQuantile((double*) G__int(libp->para[0]));
10562    } else {
10563      p = new((void*) gvp) ROOT::Math::VavilovAccurateQuantile((double*) G__int(libp->para[0]));
10564    }
10565    result7->obj.i = (long) p;
10566    result7->ref = (long) p;
10567    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile));
10568    return(1 || funcname || hash || result7 || libp) ;
10569 }
10570 
10571 // automatic copy constructor
10572 static int G__G__MathMore_245_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10573 
10574 {
10575    ROOT::Math::VavilovAccurateQuantile* p;
10576    void* tmp = (void*) G__int(libp->para[0]);
10577    p = new ROOT::Math::VavilovAccurateQuantile(*(ROOT::Math::VavilovAccurateQuantile*) tmp);
10578    result7->obj.i = (long) p;
10579    result7->ref = (long) p;
10580    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile));
10581    return(1 || funcname || hash || result7 || libp) ;
10582 }
10583 
10584 // automatic destructor
10585 typedef ROOT::Math::VavilovAccurateQuantile G__TROOTcLcLMathcLcLVavilovAccurateQuantile;
10586 static int G__G__MathMore_245_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10587 {
10588    char* gvp = (char*) G__getgvp();
10589    long soff = G__getstructoffset();
10590    int n = G__getaryconstruct();
10591    //
10592    //has_a_delete: 0
10593    //has_own_delete1arg: 0
10594    //has_own_delete2arg: 0
10595    //
10596    if (!soff) {
10597      return(1);
10598    }
10599    if (n) {
10600      if (gvp == (char*)G__PVOID) {
10601        delete[] (ROOT::Math::VavilovAccurateQuantile*) soff;
10602      } else {
10603        G__setgvp((long) G__PVOID);
10604        for (int i = n - 1; i >= 0; --i) {
10605          ((ROOT::Math::VavilovAccurateQuantile*) (soff+(sizeof(ROOT::Math::VavilovAccurateQuantile)*i)))->~G__TROOTcLcLMathcLcLVavilovAccurateQuantile();
10606        }
10607        G__setgvp((long)gvp);
10608      }
10609    } else {
10610      if (gvp == (char*)G__PVOID) {
10611        delete (ROOT::Math::VavilovAccurateQuantile*) soff;
10612      } else {
10613        G__setgvp((long) G__PVOID);
10614        ((ROOT::Math::VavilovAccurateQuantile*) (soff))->~G__TROOTcLcLMathcLcLVavilovAccurateQuantile();
10615        G__setgvp((long)gvp);
10616      }
10617    }
10618    G__setnull(result7);
10619    return(1 || funcname || hash || result7 || libp) ;
10620 }
10621 
10622 // automatic assignment operator
10623 static int G__G__MathMore_245_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10624 {
10625    ROOT::Math::VavilovAccurateQuantile* dest = (ROOT::Math::VavilovAccurateQuantile*) G__getstructoffset();
10626    *dest = *(ROOT::Math::VavilovAccurateQuantile*) libp->para[0].ref;
10627    const ROOT::Math::VavilovAccurateQuantile& obj = *dest;
10628    result7->ref = (long) (&obj);
10629    result7->obj.i = (long) (&obj);
10630    return(1 || funcname || hash || result7 || libp) ;
10631 }
10632 
10633 
10634 /* ROOT::Math::VavilovFast */
10635 static int G__G__MathMore_246_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10636 {
10637    ROOT::Math::VavilovFast* p = NULL;
10638    char* gvp = (char*) G__getgvp();
10639    switch (libp->paran) {
10640    case 2:
10641      //m: 2
10642      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10643        p = new ROOT::Math::VavilovFast((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
10644      } else {
10645        p = new((void*) gvp) ROOT::Math::VavilovFast((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
10646      }
10647      break;
10648    case 1:
10649      //m: 1
10650      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10651        p = new ROOT::Math::VavilovFast((double) G__double(libp->para[0]));
10652      } else {
10653        p = new((void*) gvp) ROOT::Math::VavilovFast((double) G__double(libp->para[0]));
10654      }
10655      break;
10656    case 0:
10657      int n = G__getaryconstruct();
10658      if (n) {
10659        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10660          p = new ROOT::Math::VavilovFast[n];
10661        } else {
10662          p = new((void*) gvp) ROOT::Math::VavilovFast[n];
10663        }
10664      } else {
10665        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10666          p = new ROOT::Math::VavilovFast;
10667        } else {
10668          p = new((void*) gvp) ROOT::Math::VavilovFast;
10669        }
10670      }
10671      break;
10672    }
10673    result7->obj.i = (long) p;
10674    result7->ref = (long) p;
10675    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast));
10676    return(1 || funcname || hash || result7 || libp) ;
10677 }
10678 
10679 static int G__G__MathMore_246_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10680 {
10681       G__letint(result7, 85, (long) ROOT::Math::VavilovFast::GetInstance());
10682    return(1 || funcname || hash || result7 || libp) ;
10683 }
10684 
10685 static int G__G__MathMore_246_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10686 {
10687       G__letint(result7, 85, (long) ROOT::Math::VavilovFast::GetInstance((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10688    return(1 || funcname || hash || result7 || libp) ;
10689 }
10690 
10691 // automatic copy constructor
10692 static int G__G__MathMore_246_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10693 
10694 {
10695    ROOT::Math::VavilovFast* p;
10696    void* tmp = (void*) G__int(libp->para[0]);
10697    p = new ROOT::Math::VavilovFast(*(ROOT::Math::VavilovFast*) tmp);
10698    result7->obj.i = (long) p;
10699    result7->ref = (long) p;
10700    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast));
10701    return(1 || funcname || hash || result7 || libp) ;
10702 }
10703 
10704 // automatic destructor
10705 typedef ROOT::Math::VavilovFast G__TROOTcLcLMathcLcLVavilovFast;
10706 static int G__G__MathMore_246_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10707 {
10708    char* gvp = (char*) G__getgvp();
10709    long soff = G__getstructoffset();
10710    int n = G__getaryconstruct();
10711    //
10712    //has_a_delete: 0
10713    //has_own_delete1arg: 0
10714    //has_own_delete2arg: 0
10715    //
10716    if (!soff) {
10717      return(1);
10718    }
10719    if (n) {
10720      if (gvp == (char*)G__PVOID) {
10721        delete[] (ROOT::Math::VavilovFast*) soff;
10722      } else {
10723        G__setgvp((long) G__PVOID);
10724        for (int i = n - 1; i >= 0; --i) {
10725          ((ROOT::Math::VavilovFast*) (soff+(sizeof(ROOT::Math::VavilovFast)*i)))->~G__TROOTcLcLMathcLcLVavilovFast();
10726        }
10727        G__setgvp((long)gvp);
10728      }
10729    } else {
10730      if (gvp == (char*)G__PVOID) {
10731        delete (ROOT::Math::VavilovFast*) soff;
10732      } else {
10733        G__setgvp((long) G__PVOID);
10734        ((ROOT::Math::VavilovFast*) (soff))->~G__TROOTcLcLMathcLcLVavilovFast();
10735        G__setgvp((long)gvp);
10736      }
10737    }
10738    G__setnull(result7);
10739    return(1 || funcname || hash || result7 || libp) ;
10740 }
10741 
10742 // automatic assignment operator
10743 static int G__G__MathMore_246_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10744 {
10745    ROOT::Math::VavilovFast* dest = (ROOT::Math::VavilovFast*) G__getstructoffset();
10746    *dest = *(ROOT::Math::VavilovFast*) libp->para[0].ref;
10747    const ROOT::Math::VavilovFast& obj = *dest;
10748    result7->ref = (long) (&obj);
10749    result7->obj.i = (long) (&obj);
10750    return(1 || funcname || hash || result7 || libp) ;
10751 }
10752 
10753 
10754 /* ROOT::Math::Random<ROOT::Math::GSLRngMT> */
10755 static int G__G__MathMore_247_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10756 {
10757    ROOT::Math::Random<ROOT::Math::GSLRngMT>* p = NULL;
10758    char* gvp = (char*) G__getgvp();
10759    int n = G__getaryconstruct();
10760    if (n) {
10761      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10762        p = new ROOT::Math::Random<ROOT::Math::GSLRngMT>[n];
10763      } else {
10764        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngMT>[n];
10765      }
10766    } else {
10767      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10768        p = new ROOT::Math::Random<ROOT::Math::GSLRngMT>;
10769      } else {
10770        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngMT>;
10771      }
10772    }
10773    result7->obj.i = (long) p;
10774    result7->ref = (long) p;
10775    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR));
10776    return(1 || funcname || hash || result7 || libp) ;
10777 }
10778 
10779 static int G__G__MathMore_247_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10780 {
10781    ROOT::Math::Random<ROOT::Math::GSLRngMT>* p = NULL;
10782    char* gvp = (char*) G__getgvp();
10783    //m: 1
10784    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10785      p = new ROOT::Math::Random<ROOT::Math::GSLRngMT>((unsigned int) G__int(libp->para[0]));
10786    } else {
10787      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngMT>((unsigned int) G__int(libp->para[0]));
10788    }
10789    result7->obj.i = (long) p;
10790    result7->ref = (long) p;
10791    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR));
10792    return(1 || funcname || hash || result7 || libp) ;
10793 }
10794 
10795 static int G__G__MathMore_247_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10796 {
10797    ROOT::Math::Random<ROOT::Math::GSLRngMT>* p = NULL;
10798    char* gvp = (char*) G__getgvp();
10799    //m: 1
10800    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10801      p = new ROOT::Math::Random<ROOT::Math::GSLRngMT>(*(ROOT::Math::GSLRngMT*) libp->para[0].ref);
10802    } else {
10803      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngMT>(*(ROOT::Math::GSLRngMT*) libp->para[0].ref);
10804    }
10805    result7->obj.i = (long) p;
10806    result7->ref = (long) p;
10807    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR));
10808    return(1 || funcname || hash || result7 || libp) ;
10809 }
10810 
10811 static int G__G__MathMore_247_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10812 {
10813    switch (libp->paran) {
10814    case 1:
10815       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
10816       break;
10817    case 0:
10818       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Uniform());
10819       break;
10820    }
10821    return(1 || funcname || hash || result7 || libp) ;
10822 }
10823 
10824 static int G__G__MathMore_247_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10825 {
10826       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Rndm());
10827    return(1 || funcname || hash || result7 || libp) ;
10828 }
10829 
10830 static int G__G__MathMore_247_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10831 {
10832       ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
10833       G__setnull(result7);
10834    return(1 || funcname || hash || result7 || libp) ;
10835 }
10836 
10837 static int G__G__MathMore_247_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10838 {
10839       {
10840          const string* pobj;
10841          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Type();
10842          pobj = new string(xobj);
10843          result7->obj.i = (long) ((void*) pobj);
10844          result7->ref = result7->obj.i;
10845          G__store_tempobject(*result7);
10846       }
10847    return(1 || funcname || hash || result7 || libp) ;
10848 }
10849 
10850 static int G__G__MathMore_247_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10851 {
10852       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->EngineSize());
10853    return(1 || funcname || hash || result7 || libp) ;
10854 }
10855 
10856 static int G__G__MathMore_247_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10857 {
10858       ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
10859       G__setnull(result7);
10860    return(1 || funcname || hash || result7 || libp) ;
10861 }
10862 
10863 static int G__G__MathMore_247_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10864 {
10865    switch (libp->paran) {
10866    case 2:
10867       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10868       break;
10869    case 1:
10870       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
10871       break;
10872    case 0:
10873       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Gaus());
10874       break;
10875    }
10876    return(1 || funcname || hash || result7 || libp) ;
10877 }
10878 
10879 static int G__G__MathMore_247_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10880 {
10881    switch (libp->paran) {
10882    case 2:
10883       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10884       break;
10885    case 1:
10886       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
10887       break;
10888    case 0:
10889       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GausBM());
10890       break;
10891    }
10892    return(1 || funcname || hash || result7 || libp) ;
10893 }
10894 
10895 static int G__G__MathMore_247_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10896 {
10897    switch (libp->paran) {
10898    case 2:
10899       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10900       break;
10901    case 1:
10902       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
10903       break;
10904    case 0:
10905       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GausR());
10906       break;
10907    }
10908    return(1 || funcname || hash || result7 || libp) ;
10909 }
10910 
10911 static int G__G__MathMore_247_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10912 {
10913    switch (libp->paran) {
10914    case 2:
10915       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10916       break;
10917    case 1:
10918       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
10919       break;
10920    }
10921    return(1 || funcname || hash || result7 || libp) ;
10922 }
10923 
10924 static int G__G__MathMore_247_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10925 {
10926       ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
10927 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
10928 , *(double*) G__Doubleref(&libp->para[4]));
10929       G__setnull(result7);
10930    return(1 || funcname || hash || result7 || libp) ;
10931 }
10932 
10933 static int G__G__MathMore_247_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10934 {
10935       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
10936    return(1 || funcname || hash || result7 || libp) ;
10937 }
10938 
10939 static int G__G__MathMore_247_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10940 {
10941    switch (libp->paran) {
10942    case 2:
10943       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10944       break;
10945    case 1:
10946       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
10947       break;
10948    case 0:
10949       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->BreitWigner());
10950       break;
10951    }
10952    return(1 || funcname || hash || result7 || libp) ;
10953 }
10954 
10955 static int G__G__MathMore_247_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10956 {
10957    switch (libp->paran) {
10958    case 2:
10959       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10960       break;
10961    case 1:
10962       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
10963       break;
10964    case 0:
10965       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Landau());
10966       break;
10967    }
10968    return(1 || funcname || hash || result7 || libp) ;
10969 }
10970 
10971 static int G__G__MathMore_247_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10972 {
10973       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10974    return(1 || funcname || hash || result7 || libp) ;
10975 }
10976 
10977 static int G__G__MathMore_247_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10978 {
10979       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10980    return(1 || funcname || hash || result7 || libp) ;
10981 }
10982 
10983 static int G__G__MathMore_247_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10984 {
10985       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
10986    return(1 || funcname || hash || result7 || libp) ;
10987 }
10988 
10989 static int G__G__MathMore_247_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10990 {
10991       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
10992    return(1 || funcname || hash || result7 || libp) ;
10993 }
10994 
10995 static int G__G__MathMore_247_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10996 {
10997       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
10998    return(1 || funcname || hash || result7 || libp) ;
10999 }
11000 
11001 static int G__G__MathMore_247_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11002 {
11003    switch (libp->paran) {
11004    case 3:
11005       ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11006 , (double) G__double(libp->para[2]));
11007       G__setnull(result7);
11008       break;
11009    case 2:
11010       ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
11011       G__setnull(result7);
11012       break;
11013    }
11014    return(1 || funcname || hash || result7 || libp) ;
11015 }
11016 
11017 static int G__G__MathMore_247_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11018 {
11019    switch (libp->paran) {
11020    case 4:
11021       ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11022 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
11023       G__setnull(result7);
11024       break;
11025    case 3:
11026       ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11027 , *(double*) G__Doubleref(&libp->para[2]));
11028       G__setnull(result7);
11029       break;
11030    }
11031    return(1 || funcname || hash || result7 || libp) ;
11032 }
11033 
11034 static int G__G__MathMore_247_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11035 {
11036       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
11037    return(1 || funcname || hash || result7 || libp) ;
11038 }
11039 
11040 static int G__G__MathMore_247_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11041 {
11042       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
11043    return(1 || funcname || hash || result7 || libp) ;
11044 }
11045 
11046 static int G__G__MathMore_247_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11047 {
11048       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11049    return(1 || funcname || hash || result7 || libp) ;
11050 }
11051 
11052 static int G__G__MathMore_247_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11053 {
11054       {
11055          vector<unsigned int>* pobj;
11056          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
11057          pobj = new vector<unsigned int>(xobj);
11058          result7->obj.i = (long) ((void*) pobj);
11059          result7->ref = result7->obj.i;
11060          G__store_tempobject(*result7);
11061       }
11062    return(1 || funcname || hash || result7 || libp) ;
11063 }
11064 
11065 // automatic copy constructor
11066 static int G__G__MathMore_247_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11067 
11068 {
11069    ROOT::Math::Random<ROOT::Math::GSLRngMT>* p;
11070    void* tmp = (void*) G__int(libp->para[0]);
11071    p = new ROOT::Math::Random<ROOT::Math::GSLRngMT>(*(ROOT::Math::Random<ROOT::Math::GSLRngMT>*) tmp);
11072    result7->obj.i = (long) p;
11073    result7->ref = (long) p;
11074    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR));
11075    return(1 || funcname || hash || result7 || libp) ;
11076 }
11077 
11078 // automatic destructor
11079 typedef ROOT::Math::Random<ROOT::Math::GSLRngMT> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR;
11080 static int G__G__MathMore_247_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11081 {
11082    char* gvp = (char*) G__getgvp();
11083    long soff = G__getstructoffset();
11084    int n = G__getaryconstruct();
11085    //
11086    //has_a_delete: 0
11087    //has_own_delete1arg: 0
11088    //has_own_delete2arg: 0
11089    //
11090    if (!soff) {
11091      return(1);
11092    }
11093    if (n) {
11094      if (gvp == (char*)G__PVOID) {
11095        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngMT>*) soff;
11096      } else {
11097        G__setgvp((long) G__PVOID);
11098        for (int i = n - 1; i >= 0; --i) {
11099          ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngMT>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR();
11100        }
11101        G__setgvp((long)gvp);
11102      }
11103    } else {
11104      if (gvp == (char*)G__PVOID) {
11105        delete (ROOT::Math::Random<ROOT::Math::GSLRngMT>*) soff;
11106      } else {
11107        G__setgvp((long) G__PVOID);
11108        ((ROOT::Math::Random<ROOT::Math::GSLRngMT>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR();
11109        G__setgvp((long)gvp);
11110      }
11111    }
11112    G__setnull(result7);
11113    return(1 || funcname || hash || result7 || libp) ;
11114 }
11115 
11116 // automatic assignment operator
11117 static int G__G__MathMore_247_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11118 {
11119    ROOT::Math::Random<ROOT::Math::GSLRngMT>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngMT>*) G__getstructoffset();
11120    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngMT>*) libp->para[0].ref;
11121    const ROOT::Math::Random<ROOT::Math::GSLRngMT>& obj = *dest;
11122    result7->ref = (long) (&obj);
11123    result7->obj.i = (long) (&obj);
11124    return(1 || funcname || hash || result7 || libp) ;
11125 }
11126 
11127 
11128 /* ROOT::Math::Random<ROOT::Math::GSLRngTaus> */
11129 static int G__G__MathMore_248_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11130 {
11131    ROOT::Math::Random<ROOT::Math::GSLRngTaus>* p = NULL;
11132    char* gvp = (char*) G__getgvp();
11133    int n = G__getaryconstruct();
11134    if (n) {
11135      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11136        p = new ROOT::Math::Random<ROOT::Math::GSLRngTaus>[n];
11137      } else {
11138        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngTaus>[n];
11139      }
11140    } else {
11141      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11142        p = new ROOT::Math::Random<ROOT::Math::GSLRngTaus>;
11143      } else {
11144        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngTaus>;
11145      }
11146    }
11147    result7->obj.i = (long) p;
11148    result7->ref = (long) p;
11149    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR));
11150    return(1 || funcname || hash || result7 || libp) ;
11151 }
11152 
11153 static int G__G__MathMore_248_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11154 {
11155    ROOT::Math::Random<ROOT::Math::GSLRngTaus>* p = NULL;
11156    char* gvp = (char*) G__getgvp();
11157    //m: 1
11158    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11159      p = new ROOT::Math::Random<ROOT::Math::GSLRngTaus>((unsigned int) G__int(libp->para[0]));
11160    } else {
11161      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngTaus>((unsigned int) G__int(libp->para[0]));
11162    }
11163    result7->obj.i = (long) p;
11164    result7->ref = (long) p;
11165    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR));
11166    return(1 || funcname || hash || result7 || libp) ;
11167 }
11168 
11169 static int G__G__MathMore_248_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11170 {
11171    ROOT::Math::Random<ROOT::Math::GSLRngTaus>* p = NULL;
11172    char* gvp = (char*) G__getgvp();
11173    //m: 1
11174    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11175      p = new ROOT::Math::Random<ROOT::Math::GSLRngTaus>(*(ROOT::Math::GSLRngTaus*) libp->para[0].ref);
11176    } else {
11177      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngTaus>(*(ROOT::Math::GSLRngTaus*) libp->para[0].ref);
11178    }
11179    result7->obj.i = (long) p;
11180    result7->ref = (long) p;
11181    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR));
11182    return(1 || funcname || hash || result7 || libp) ;
11183 }
11184 
11185 static int G__G__MathMore_248_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11186 {
11187    switch (libp->paran) {
11188    case 1:
11189       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
11190       break;
11191    case 0:
11192       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Uniform());
11193       break;
11194    }
11195    return(1 || funcname || hash || result7 || libp) ;
11196 }
11197 
11198 static int G__G__MathMore_248_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11199 {
11200       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Rndm());
11201    return(1 || funcname || hash || result7 || libp) ;
11202 }
11203 
11204 static int G__G__MathMore_248_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11205 {
11206       ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
11207       G__setnull(result7);
11208    return(1 || funcname || hash || result7 || libp) ;
11209 }
11210 
11211 static int G__G__MathMore_248_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11212 {
11213       {
11214          const string* pobj;
11215          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Type();
11216          pobj = new string(xobj);
11217          result7->obj.i = (long) ((void*) pobj);
11218          result7->ref = result7->obj.i;
11219          G__store_tempobject(*result7);
11220       }
11221    return(1 || funcname || hash || result7 || libp) ;
11222 }
11223 
11224 static int G__G__MathMore_248_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11225 {
11226       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->EngineSize());
11227    return(1 || funcname || hash || result7 || libp) ;
11228 }
11229 
11230 static int G__G__MathMore_248_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11231 {
11232       ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
11233       G__setnull(result7);
11234    return(1 || funcname || hash || result7 || libp) ;
11235 }
11236 
11237 static int G__G__MathMore_248_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11238 {
11239    switch (libp->paran) {
11240    case 2:
11241       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11242       break;
11243    case 1:
11244       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
11245       break;
11246    case 0:
11247       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Gaus());
11248       break;
11249    }
11250    return(1 || funcname || hash || result7 || libp) ;
11251 }
11252 
11253 static int G__G__MathMore_248_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11254 {
11255    switch (libp->paran) {
11256    case 2:
11257       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11258       break;
11259    case 1:
11260       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
11261       break;
11262    case 0:
11263       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GausBM());
11264       break;
11265    }
11266    return(1 || funcname || hash || result7 || libp) ;
11267 }
11268 
11269 static int G__G__MathMore_248_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11270 {
11271    switch (libp->paran) {
11272    case 2:
11273       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11274       break;
11275    case 1:
11276       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
11277       break;
11278    case 0:
11279       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GausR());
11280       break;
11281    }
11282    return(1 || funcname || hash || result7 || libp) ;
11283 }
11284 
11285 static int G__G__MathMore_248_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11286 {
11287    switch (libp->paran) {
11288    case 2:
11289       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11290       break;
11291    case 1:
11292       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
11293       break;
11294    }
11295    return(1 || funcname || hash || result7 || libp) ;
11296 }
11297 
11298 static int G__G__MathMore_248_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11299 {
11300       ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
11301 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
11302 , *(double*) G__Doubleref(&libp->para[4]));
11303       G__setnull(result7);
11304    return(1 || funcname || hash || result7 || libp) ;
11305 }
11306 
11307 static int G__G__MathMore_248_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11308 {
11309       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
11310    return(1 || funcname || hash || result7 || libp) ;
11311 }
11312 
11313 static int G__G__MathMore_248_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11314 {
11315    switch (libp->paran) {
11316    case 2:
11317       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11318       break;
11319    case 1:
11320       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
11321       break;
11322    case 0:
11323       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->BreitWigner());
11324       break;
11325    }
11326    return(1 || funcname || hash || result7 || libp) ;
11327 }
11328 
11329 static int G__G__MathMore_248_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11330 {
11331    switch (libp->paran) {
11332    case 2:
11333       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11334       break;
11335    case 1:
11336       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
11337       break;
11338    case 0:
11339       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Landau());
11340       break;
11341    }
11342    return(1 || funcname || hash || result7 || libp) ;
11343 }
11344 
11345 static int G__G__MathMore_248_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11346 {
11347       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11348    return(1 || funcname || hash || result7 || libp) ;
11349 }
11350 
11351 static int G__G__MathMore_248_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11352 {
11353       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11354    return(1 || funcname || hash || result7 || libp) ;
11355 }
11356 
11357 static int G__G__MathMore_248_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11358 {
11359       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
11360    return(1 || funcname || hash || result7 || libp) ;
11361 }
11362 
11363 static int G__G__MathMore_248_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11364 {
11365       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11366    return(1 || funcname || hash || result7 || libp) ;
11367 }
11368 
11369 static int G__G__MathMore_248_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11370 {
11371       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
11372    return(1 || funcname || hash || result7 || libp) ;
11373 }
11374 
11375 static int G__G__MathMore_248_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11376 {
11377    switch (libp->paran) {
11378    case 3:
11379       ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11380 , (double) G__double(libp->para[2]));
11381       G__setnull(result7);
11382       break;
11383    case 2:
11384       ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
11385       G__setnull(result7);
11386       break;
11387    }
11388    return(1 || funcname || hash || result7 || libp) ;
11389 }
11390 
11391 static int G__G__MathMore_248_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11392 {
11393    switch (libp->paran) {
11394    case 4:
11395       ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11396 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
11397       G__setnull(result7);
11398       break;
11399    case 3:
11400       ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11401 , *(double*) G__Doubleref(&libp->para[2]));
11402       G__setnull(result7);
11403       break;
11404    }
11405    return(1 || funcname || hash || result7 || libp) ;
11406 }
11407 
11408 static int G__G__MathMore_248_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11409 {
11410       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
11411    return(1 || funcname || hash || result7 || libp) ;
11412 }
11413 
11414 static int G__G__MathMore_248_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11415 {
11416       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
11417    return(1 || funcname || hash || result7 || libp) ;
11418 }
11419 
11420 static int G__G__MathMore_248_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11421 {
11422       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11423    return(1 || funcname || hash || result7 || libp) ;
11424 }
11425 
11426 static int G__G__MathMore_248_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11427 {
11428       {
11429          vector<unsigned int>* pobj;
11430          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
11431          pobj = new vector<unsigned int>(xobj);
11432          result7->obj.i = (long) ((void*) pobj);
11433          result7->ref = result7->obj.i;
11434          G__store_tempobject(*result7);
11435       }
11436    return(1 || funcname || hash || result7 || libp) ;
11437 }
11438 
11439 // automatic copy constructor
11440 static int G__G__MathMore_248_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11441 
11442 {
11443    ROOT::Math::Random<ROOT::Math::GSLRngTaus>* p;
11444    void* tmp = (void*) G__int(libp->para[0]);
11445    p = new ROOT::Math::Random<ROOT::Math::GSLRngTaus>(*(ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) tmp);
11446    result7->obj.i = (long) p;
11447    result7->ref = (long) p;
11448    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR));
11449    return(1 || funcname || hash || result7 || libp) ;
11450 }
11451 
11452 // automatic destructor
11453 typedef ROOT::Math::Random<ROOT::Math::GSLRngTaus> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR;
11454 static int G__G__MathMore_248_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11455 {
11456    char* gvp = (char*) G__getgvp();
11457    long soff = G__getstructoffset();
11458    int n = G__getaryconstruct();
11459    //
11460    //has_a_delete: 0
11461    //has_own_delete1arg: 0
11462    //has_own_delete2arg: 0
11463    //
11464    if (!soff) {
11465      return(1);
11466    }
11467    if (n) {
11468      if (gvp == (char*)G__PVOID) {
11469        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) soff;
11470      } else {
11471        G__setgvp((long) G__PVOID);
11472        for (int i = n - 1; i >= 0; --i) {
11473          ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngTaus>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR();
11474        }
11475        G__setgvp((long)gvp);
11476      }
11477    } else {
11478      if (gvp == (char*)G__PVOID) {
11479        delete (ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) soff;
11480      } else {
11481        G__setgvp((long) G__PVOID);
11482        ((ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR();
11483        G__setgvp((long)gvp);
11484      }
11485    }
11486    G__setnull(result7);
11487    return(1 || funcname || hash || result7 || libp) ;
11488 }
11489 
11490 // automatic assignment operator
11491 static int G__G__MathMore_248_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11492 {
11493    ROOT::Math::Random<ROOT::Math::GSLRngTaus>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) G__getstructoffset();
11494    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngTaus>*) libp->para[0].ref;
11495    const ROOT::Math::Random<ROOT::Math::GSLRngTaus>& obj = *dest;
11496    result7->ref = (long) (&obj);
11497    result7->obj.i = (long) (&obj);
11498    return(1 || funcname || hash || result7 || libp) ;
11499 }
11500 
11501 
11502 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLux> */
11503 static int G__G__MathMore_249_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11504 {
11505    ROOT::Math::Random<ROOT::Math::GSLRngRanLux>* p = NULL;
11506    char* gvp = (char*) G__getgvp();
11507    int n = G__getaryconstruct();
11508    if (n) {
11509      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11510        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLux>[n];
11511      } else {
11512        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLux>[n];
11513      }
11514    } else {
11515      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11516        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLux>;
11517      } else {
11518        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLux>;
11519      }
11520    }
11521    result7->obj.i = (long) p;
11522    result7->ref = (long) p;
11523    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR));
11524    return(1 || funcname || hash || result7 || libp) ;
11525 }
11526 
11527 static int G__G__MathMore_249_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11528 {
11529    ROOT::Math::Random<ROOT::Math::GSLRngRanLux>* p = NULL;
11530    char* gvp = (char*) G__getgvp();
11531    //m: 1
11532    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11533      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLux>((unsigned int) G__int(libp->para[0]));
11534    } else {
11535      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLux>((unsigned int) G__int(libp->para[0]));
11536    }
11537    result7->obj.i = (long) p;
11538    result7->ref = (long) p;
11539    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR));
11540    return(1 || funcname || hash || result7 || libp) ;
11541 }
11542 
11543 static int G__G__MathMore_249_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11544 {
11545    ROOT::Math::Random<ROOT::Math::GSLRngRanLux>* p = NULL;
11546    char* gvp = (char*) G__getgvp();
11547    //m: 1
11548    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11549      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLux>(*(ROOT::Math::GSLRngRanLux*) libp->para[0].ref);
11550    } else {
11551      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLux>(*(ROOT::Math::GSLRngRanLux*) libp->para[0].ref);
11552    }
11553    result7->obj.i = (long) p;
11554    result7->ref = (long) p;
11555    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR));
11556    return(1 || funcname || hash || result7 || libp) ;
11557 }
11558 
11559 static int G__G__MathMore_249_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11560 {
11561    switch (libp->paran) {
11562    case 1:
11563       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
11564       break;
11565    case 0:
11566       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Uniform());
11567       break;
11568    }
11569    return(1 || funcname || hash || result7 || libp) ;
11570 }
11571 
11572 static int G__G__MathMore_249_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11573 {
11574       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Rndm());
11575    return(1 || funcname || hash || result7 || libp) ;
11576 }
11577 
11578 static int G__G__MathMore_249_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11579 {
11580       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
11581       G__setnull(result7);
11582    return(1 || funcname || hash || result7 || libp) ;
11583 }
11584 
11585 static int G__G__MathMore_249_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11586 {
11587       {
11588          const string* pobj;
11589          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Type();
11590          pobj = new string(xobj);
11591          result7->obj.i = (long) ((void*) pobj);
11592          result7->ref = result7->obj.i;
11593          G__store_tempobject(*result7);
11594       }
11595    return(1 || funcname || hash || result7 || libp) ;
11596 }
11597 
11598 static int G__G__MathMore_249_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11599 {
11600       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->EngineSize());
11601    return(1 || funcname || hash || result7 || libp) ;
11602 }
11603 
11604 static int G__G__MathMore_249_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11605 {
11606       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
11607       G__setnull(result7);
11608    return(1 || funcname || hash || result7 || libp) ;
11609 }
11610 
11611 static int G__G__MathMore_249_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11612 {
11613    switch (libp->paran) {
11614    case 2:
11615       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11616       break;
11617    case 1:
11618       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
11619       break;
11620    case 0:
11621       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Gaus());
11622       break;
11623    }
11624    return(1 || funcname || hash || result7 || libp) ;
11625 }
11626 
11627 static int G__G__MathMore_249_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11628 {
11629    switch (libp->paran) {
11630    case 2:
11631       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11632       break;
11633    case 1:
11634       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
11635       break;
11636    case 0:
11637       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GausBM());
11638       break;
11639    }
11640    return(1 || funcname || hash || result7 || libp) ;
11641 }
11642 
11643 static int G__G__MathMore_249_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11644 {
11645    switch (libp->paran) {
11646    case 2:
11647       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11648       break;
11649    case 1:
11650       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
11651       break;
11652    case 0:
11653       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GausR());
11654       break;
11655    }
11656    return(1 || funcname || hash || result7 || libp) ;
11657 }
11658 
11659 static int G__G__MathMore_249_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11660 {
11661    switch (libp->paran) {
11662    case 2:
11663       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11664       break;
11665    case 1:
11666       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
11667       break;
11668    }
11669    return(1 || funcname || hash || result7 || libp) ;
11670 }
11671 
11672 static int G__G__MathMore_249_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11673 {
11674       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
11675 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
11676 , *(double*) G__Doubleref(&libp->para[4]));
11677       G__setnull(result7);
11678    return(1 || funcname || hash || result7 || libp) ;
11679 }
11680 
11681 static int G__G__MathMore_249_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11682 {
11683       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
11684    return(1 || funcname || hash || result7 || libp) ;
11685 }
11686 
11687 static int G__G__MathMore_249_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11688 {
11689    switch (libp->paran) {
11690    case 2:
11691       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11692       break;
11693    case 1:
11694       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
11695       break;
11696    case 0:
11697       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->BreitWigner());
11698       break;
11699    }
11700    return(1 || funcname || hash || result7 || libp) ;
11701 }
11702 
11703 static int G__G__MathMore_249_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11704 {
11705    switch (libp->paran) {
11706    case 2:
11707       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11708       break;
11709    case 1:
11710       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
11711       break;
11712    case 0:
11713       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Landau());
11714       break;
11715    }
11716    return(1 || funcname || hash || result7 || libp) ;
11717 }
11718 
11719 static int G__G__MathMore_249_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11720 {
11721       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11722    return(1 || funcname || hash || result7 || libp) ;
11723 }
11724 
11725 static int G__G__MathMore_249_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11726 {
11727       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11728    return(1 || funcname || hash || result7 || libp) ;
11729 }
11730 
11731 static int G__G__MathMore_249_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11732 {
11733       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
11734    return(1 || funcname || hash || result7 || libp) ;
11735 }
11736 
11737 static int G__G__MathMore_249_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11738 {
11739       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11740    return(1 || funcname || hash || result7 || libp) ;
11741 }
11742 
11743 static int G__G__MathMore_249_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11744 {
11745       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
11746    return(1 || funcname || hash || result7 || libp) ;
11747 }
11748 
11749 static int G__G__MathMore_249_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11750 {
11751    switch (libp->paran) {
11752    case 3:
11753       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11754 , (double) G__double(libp->para[2]));
11755       G__setnull(result7);
11756       break;
11757    case 2:
11758       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
11759       G__setnull(result7);
11760       break;
11761    }
11762    return(1 || funcname || hash || result7 || libp) ;
11763 }
11764 
11765 static int G__G__MathMore_249_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11766 {
11767    switch (libp->paran) {
11768    case 4:
11769       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11770 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
11771       G__setnull(result7);
11772       break;
11773    case 3:
11774       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
11775 , *(double*) G__Doubleref(&libp->para[2]));
11776       G__setnull(result7);
11777       break;
11778    }
11779    return(1 || funcname || hash || result7 || libp) ;
11780 }
11781 
11782 static int G__G__MathMore_249_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11783 {
11784       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
11785    return(1 || funcname || hash || result7 || libp) ;
11786 }
11787 
11788 static int G__G__MathMore_249_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11789 {
11790       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
11791    return(1 || funcname || hash || result7 || libp) ;
11792 }
11793 
11794 static int G__G__MathMore_249_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11795 {
11796       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11797    return(1 || funcname || hash || result7 || libp) ;
11798 }
11799 
11800 static int G__G__MathMore_249_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11801 {
11802       {
11803          vector<unsigned int>* pobj;
11804          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
11805          pobj = new vector<unsigned int>(xobj);
11806          result7->obj.i = (long) ((void*) pobj);
11807          result7->ref = result7->obj.i;
11808          G__store_tempobject(*result7);
11809       }
11810    return(1 || funcname || hash || result7 || libp) ;
11811 }
11812 
11813 // automatic copy constructor
11814 static int G__G__MathMore_249_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11815 
11816 {
11817    ROOT::Math::Random<ROOT::Math::GSLRngRanLux>* p;
11818    void* tmp = (void*) G__int(libp->para[0]);
11819    p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLux>(*(ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) tmp);
11820    result7->obj.i = (long) p;
11821    result7->ref = (long) p;
11822    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR));
11823    return(1 || funcname || hash || result7 || libp) ;
11824 }
11825 
11826 // automatic destructor
11827 typedef ROOT::Math::Random<ROOT::Math::GSLRngRanLux> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR;
11828 static int G__G__MathMore_249_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11829 {
11830    char* gvp = (char*) G__getgvp();
11831    long soff = G__getstructoffset();
11832    int n = G__getaryconstruct();
11833    //
11834    //has_a_delete: 0
11835    //has_own_delete1arg: 0
11836    //has_own_delete2arg: 0
11837    //
11838    if (!soff) {
11839      return(1);
11840    }
11841    if (n) {
11842      if (gvp == (char*)G__PVOID) {
11843        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) soff;
11844      } else {
11845        G__setgvp((long) G__PVOID);
11846        for (int i = n - 1; i >= 0; --i) {
11847          ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLux>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR();
11848        }
11849        G__setgvp((long)gvp);
11850      }
11851    } else {
11852      if (gvp == (char*)G__PVOID) {
11853        delete (ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) soff;
11854      } else {
11855        G__setgvp((long) G__PVOID);
11856        ((ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR();
11857        G__setgvp((long)gvp);
11858      }
11859    }
11860    G__setnull(result7);
11861    return(1 || funcname || hash || result7 || libp) ;
11862 }
11863 
11864 // automatic assignment operator
11865 static int G__G__MathMore_249_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11866 {
11867    ROOT::Math::Random<ROOT::Math::GSLRngRanLux>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) G__getstructoffset();
11868    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*) libp->para[0].ref;
11869    const ROOT::Math::Random<ROOT::Math::GSLRngRanLux>& obj = *dest;
11870    result7->ref = (long) (&obj);
11871    result7->obj.i = (long) (&obj);
11872    return(1 || funcname || hash || result7 || libp) ;
11873 }
11874 
11875 
11876 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> */
11877 static int G__G__MathMore_250_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11878 {
11879    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>* p = NULL;
11880    char* gvp = (char*) G__getgvp();
11881    int n = G__getaryconstruct();
11882    if (n) {
11883      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11884        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>[n];
11885      } else {
11886        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>[n];
11887      }
11888    } else {
11889      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11890        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>;
11891      } else {
11892        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>;
11893      }
11894    }
11895    result7->obj.i = (long) p;
11896    result7->ref = (long) p;
11897    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR));
11898    return(1 || funcname || hash || result7 || libp) ;
11899 }
11900 
11901 static int G__G__MathMore_250_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11902 {
11903    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>* p = NULL;
11904    char* gvp = (char*) G__getgvp();
11905    //m: 1
11906    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11907      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>((unsigned int) G__int(libp->para[0]));
11908    } else {
11909      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>((unsigned int) G__int(libp->para[0]));
11910    }
11911    result7->obj.i = (long) p;
11912    result7->ref = (long) p;
11913    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR));
11914    return(1 || funcname || hash || result7 || libp) ;
11915 }
11916 
11917 static int G__G__MathMore_250_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11918 {
11919    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>* p = NULL;
11920    char* gvp = (char*) G__getgvp();
11921    //m: 1
11922    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11923      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>(*(ROOT::Math::GSLRngRanLuxS1*) libp->para[0].ref);
11924    } else {
11925      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>(*(ROOT::Math::GSLRngRanLuxS1*) libp->para[0].ref);
11926    }
11927    result7->obj.i = (long) p;
11928    result7->ref = (long) p;
11929    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR));
11930    return(1 || funcname || hash || result7 || libp) ;
11931 }
11932 
11933 static int G__G__MathMore_250_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11934 {
11935    switch (libp->paran) {
11936    case 1:
11937       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
11938       break;
11939    case 0:
11940       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Uniform());
11941       break;
11942    }
11943    return(1 || funcname || hash || result7 || libp) ;
11944 }
11945 
11946 static int G__G__MathMore_250_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11947 {
11948       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Rndm());
11949    return(1 || funcname || hash || result7 || libp) ;
11950 }
11951 
11952 static int G__G__MathMore_250_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11953 {
11954       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
11955       G__setnull(result7);
11956    return(1 || funcname || hash || result7 || libp) ;
11957 }
11958 
11959 static int G__G__MathMore_250_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11960 {
11961       {
11962          const string* pobj;
11963          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Type();
11964          pobj = new string(xobj);
11965          result7->obj.i = (long) ((void*) pobj);
11966          result7->ref = result7->obj.i;
11967          G__store_tempobject(*result7);
11968       }
11969    return(1 || funcname || hash || result7 || libp) ;
11970 }
11971 
11972 static int G__G__MathMore_250_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11973 {
11974       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->EngineSize());
11975    return(1 || funcname || hash || result7 || libp) ;
11976 }
11977 
11978 static int G__G__MathMore_250_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11979 {
11980       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
11981       G__setnull(result7);
11982    return(1 || funcname || hash || result7 || libp) ;
11983 }
11984 
11985 static int G__G__MathMore_250_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11986 {
11987    switch (libp->paran) {
11988    case 2:
11989       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
11990       break;
11991    case 1:
11992       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
11993       break;
11994    case 0:
11995       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Gaus());
11996       break;
11997    }
11998    return(1 || funcname || hash || result7 || libp) ;
11999 }
12000 
12001 static int G__G__MathMore_250_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12002 {
12003    switch (libp->paran) {
12004    case 2:
12005       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12006       break;
12007    case 1:
12008       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
12009       break;
12010    case 0:
12011       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GausBM());
12012       break;
12013    }
12014    return(1 || funcname || hash || result7 || libp) ;
12015 }
12016 
12017 static int G__G__MathMore_250_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12018 {
12019    switch (libp->paran) {
12020    case 2:
12021       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12022       break;
12023    case 1:
12024       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
12025       break;
12026    case 0:
12027       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GausR());
12028       break;
12029    }
12030    return(1 || funcname || hash || result7 || libp) ;
12031 }
12032 
12033 static int G__G__MathMore_250_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12034 {
12035    switch (libp->paran) {
12036    case 2:
12037       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12038       break;
12039    case 1:
12040       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
12041       break;
12042    }
12043    return(1 || funcname || hash || result7 || libp) ;
12044 }
12045 
12046 static int G__G__MathMore_250_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12047 {
12048       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
12049 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
12050 , *(double*) G__Doubleref(&libp->para[4]));
12051       G__setnull(result7);
12052    return(1 || funcname || hash || result7 || libp) ;
12053 }
12054 
12055 static int G__G__MathMore_250_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12056 {
12057       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
12058    return(1 || funcname || hash || result7 || libp) ;
12059 }
12060 
12061 static int G__G__MathMore_250_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12062 {
12063    switch (libp->paran) {
12064    case 2:
12065       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12066       break;
12067    case 1:
12068       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
12069       break;
12070    case 0:
12071       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->BreitWigner());
12072       break;
12073    }
12074    return(1 || funcname || hash || result7 || libp) ;
12075 }
12076 
12077 static int G__G__MathMore_250_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12078 {
12079    switch (libp->paran) {
12080    case 2:
12081       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12082       break;
12083    case 1:
12084       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
12085       break;
12086    case 0:
12087       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Landau());
12088       break;
12089    }
12090    return(1 || funcname || hash || result7 || libp) ;
12091 }
12092 
12093 static int G__G__MathMore_250_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12094 {
12095       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12096    return(1 || funcname || hash || result7 || libp) ;
12097 }
12098 
12099 static int G__G__MathMore_250_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12100 {
12101       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12102    return(1 || funcname || hash || result7 || libp) ;
12103 }
12104 
12105 static int G__G__MathMore_250_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12106 {
12107       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
12108    return(1 || funcname || hash || result7 || libp) ;
12109 }
12110 
12111 static int G__G__MathMore_250_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12112 {
12113       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12114    return(1 || funcname || hash || result7 || libp) ;
12115 }
12116 
12117 static int G__G__MathMore_250_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12118 {
12119       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
12120    return(1 || funcname || hash || result7 || libp) ;
12121 }
12122 
12123 static int G__G__MathMore_250_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12124 {
12125    switch (libp->paran) {
12126    case 3:
12127       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12128 , (double) G__double(libp->para[2]));
12129       G__setnull(result7);
12130       break;
12131    case 2:
12132       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
12133       G__setnull(result7);
12134       break;
12135    }
12136    return(1 || funcname || hash || result7 || libp) ;
12137 }
12138 
12139 static int G__G__MathMore_250_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12140 {
12141    switch (libp->paran) {
12142    case 4:
12143       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12144 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
12145       G__setnull(result7);
12146       break;
12147    case 3:
12148       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12149 , *(double*) G__Doubleref(&libp->para[2]));
12150       G__setnull(result7);
12151       break;
12152    }
12153    return(1 || funcname || hash || result7 || libp) ;
12154 }
12155 
12156 static int G__G__MathMore_250_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12157 {
12158       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
12159    return(1 || funcname || hash || result7 || libp) ;
12160 }
12161 
12162 static int G__G__MathMore_250_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12163 {
12164       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
12165    return(1 || funcname || hash || result7 || libp) ;
12166 }
12167 
12168 static int G__G__MathMore_250_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12169 {
12170       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12171    return(1 || funcname || hash || result7 || libp) ;
12172 }
12173 
12174 static int G__G__MathMore_250_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12175 {
12176       {
12177          vector<unsigned int>* pobj;
12178          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
12179          pobj = new vector<unsigned int>(xobj);
12180          result7->obj.i = (long) ((void*) pobj);
12181          result7->ref = result7->obj.i;
12182          G__store_tempobject(*result7);
12183       }
12184    return(1 || funcname || hash || result7 || libp) ;
12185 }
12186 
12187 // automatic copy constructor
12188 static int G__G__MathMore_250_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12189 
12190 {
12191    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>* p;
12192    void* tmp = (void*) G__int(libp->para[0]);
12193    p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>(*(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) tmp);
12194    result7->obj.i = (long) p;
12195    result7->ref = (long) p;
12196    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR));
12197    return(1 || funcname || hash || result7 || libp) ;
12198 }
12199 
12200 // automatic destructor
12201 typedef ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR;
12202 static int G__G__MathMore_250_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12203 {
12204    char* gvp = (char*) G__getgvp();
12205    long soff = G__getstructoffset();
12206    int n = G__getaryconstruct();
12207    //
12208    //has_a_delete: 0
12209    //has_own_delete1arg: 0
12210    //has_own_delete2arg: 0
12211    //
12212    if (!soff) {
12213      return(1);
12214    }
12215    if (n) {
12216      if (gvp == (char*)G__PVOID) {
12217        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) soff;
12218      } else {
12219        G__setgvp((long) G__PVOID);
12220        for (int i = n - 1; i >= 0; --i) {
12221          ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR();
12222        }
12223        G__setgvp((long)gvp);
12224      }
12225    } else {
12226      if (gvp == (char*)G__PVOID) {
12227        delete (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) soff;
12228      } else {
12229        G__setgvp((long) G__PVOID);
12230        ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR();
12231        G__setgvp((long)gvp);
12232      }
12233    }
12234    G__setnull(result7);
12235    return(1 || funcname || hash || result7 || libp) ;
12236 }
12237 
12238 // automatic assignment operator
12239 static int G__G__MathMore_250_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12240 {
12241    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) G__getstructoffset();
12242    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*) libp->para[0].ref;
12243    const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>& obj = *dest;
12244    result7->ref = (long) (&obj);
12245    result7->obj.i = (long) (&obj);
12246    return(1 || funcname || hash || result7 || libp) ;
12247 }
12248 
12249 
12250 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> */
12251 static int G__G__MathMore_251_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12252 {
12253    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>* p = NULL;
12254    char* gvp = (char*) G__getgvp();
12255    int n = G__getaryconstruct();
12256    if (n) {
12257      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12258        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>[n];
12259      } else {
12260        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>[n];
12261      }
12262    } else {
12263      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12264        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>;
12265      } else {
12266        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>;
12267      }
12268    }
12269    result7->obj.i = (long) p;
12270    result7->ref = (long) p;
12271    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR));
12272    return(1 || funcname || hash || result7 || libp) ;
12273 }
12274 
12275 static int G__G__MathMore_251_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12276 {
12277    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>* p = NULL;
12278    char* gvp = (char*) G__getgvp();
12279    //m: 1
12280    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12281      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>((unsigned int) G__int(libp->para[0]));
12282    } else {
12283      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>((unsigned int) G__int(libp->para[0]));
12284    }
12285    result7->obj.i = (long) p;
12286    result7->ref = (long) p;
12287    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR));
12288    return(1 || funcname || hash || result7 || libp) ;
12289 }
12290 
12291 static int G__G__MathMore_251_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12292 {
12293    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>* p = NULL;
12294    char* gvp = (char*) G__getgvp();
12295    //m: 1
12296    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12297      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>(*(ROOT::Math::GSLRngRanLuxS2*) libp->para[0].ref);
12298    } else {
12299      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>(*(ROOT::Math::GSLRngRanLuxS2*) libp->para[0].ref);
12300    }
12301    result7->obj.i = (long) p;
12302    result7->ref = (long) p;
12303    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR));
12304    return(1 || funcname || hash || result7 || libp) ;
12305 }
12306 
12307 static int G__G__MathMore_251_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12308 {
12309    switch (libp->paran) {
12310    case 1:
12311       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
12312       break;
12313    case 0:
12314       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Uniform());
12315       break;
12316    }
12317    return(1 || funcname || hash || result7 || libp) ;
12318 }
12319 
12320 static int G__G__MathMore_251_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12321 {
12322       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Rndm());
12323    return(1 || funcname || hash || result7 || libp) ;
12324 }
12325 
12326 static int G__G__MathMore_251_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12327 {
12328       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
12329       G__setnull(result7);
12330    return(1 || funcname || hash || result7 || libp) ;
12331 }
12332 
12333 static int G__G__MathMore_251_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12334 {
12335       {
12336          const string* pobj;
12337          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Type();
12338          pobj = new string(xobj);
12339          result7->obj.i = (long) ((void*) pobj);
12340          result7->ref = result7->obj.i;
12341          G__store_tempobject(*result7);
12342       }
12343    return(1 || funcname || hash || result7 || libp) ;
12344 }
12345 
12346 static int G__G__MathMore_251_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12347 {
12348       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->EngineSize());
12349    return(1 || funcname || hash || result7 || libp) ;
12350 }
12351 
12352 static int G__G__MathMore_251_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12353 {
12354       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
12355       G__setnull(result7);
12356    return(1 || funcname || hash || result7 || libp) ;
12357 }
12358 
12359 static int G__G__MathMore_251_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12360 {
12361    switch (libp->paran) {
12362    case 2:
12363       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12364       break;
12365    case 1:
12366       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
12367       break;
12368    case 0:
12369       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Gaus());
12370       break;
12371    }
12372    return(1 || funcname || hash || result7 || libp) ;
12373 }
12374 
12375 static int G__G__MathMore_251_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12376 {
12377    switch (libp->paran) {
12378    case 2:
12379       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12380       break;
12381    case 1:
12382       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
12383       break;
12384    case 0:
12385       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GausBM());
12386       break;
12387    }
12388    return(1 || funcname || hash || result7 || libp) ;
12389 }
12390 
12391 static int G__G__MathMore_251_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12392 {
12393    switch (libp->paran) {
12394    case 2:
12395       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12396       break;
12397    case 1:
12398       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
12399       break;
12400    case 0:
12401       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GausR());
12402       break;
12403    }
12404    return(1 || funcname || hash || result7 || libp) ;
12405 }
12406 
12407 static int G__G__MathMore_251_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12408 {
12409    switch (libp->paran) {
12410    case 2:
12411       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12412       break;
12413    case 1:
12414       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
12415       break;
12416    }
12417    return(1 || funcname || hash || result7 || libp) ;
12418 }
12419 
12420 static int G__G__MathMore_251_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12421 {
12422       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
12423 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
12424 , *(double*) G__Doubleref(&libp->para[4]));
12425       G__setnull(result7);
12426    return(1 || funcname || hash || result7 || libp) ;
12427 }
12428 
12429 static int G__G__MathMore_251_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12430 {
12431       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
12432    return(1 || funcname || hash || result7 || libp) ;
12433 }
12434 
12435 static int G__G__MathMore_251_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12436 {
12437    switch (libp->paran) {
12438    case 2:
12439       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12440       break;
12441    case 1:
12442       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
12443       break;
12444    case 0:
12445       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->BreitWigner());
12446       break;
12447    }
12448    return(1 || funcname || hash || result7 || libp) ;
12449 }
12450 
12451 static int G__G__MathMore_251_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12452 {
12453    switch (libp->paran) {
12454    case 2:
12455       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12456       break;
12457    case 1:
12458       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
12459       break;
12460    case 0:
12461       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Landau());
12462       break;
12463    }
12464    return(1 || funcname || hash || result7 || libp) ;
12465 }
12466 
12467 static int G__G__MathMore_251_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12468 {
12469       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12470    return(1 || funcname || hash || result7 || libp) ;
12471 }
12472 
12473 static int G__G__MathMore_251_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12474 {
12475       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12476    return(1 || funcname || hash || result7 || libp) ;
12477 }
12478 
12479 static int G__G__MathMore_251_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12480 {
12481       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
12482    return(1 || funcname || hash || result7 || libp) ;
12483 }
12484 
12485 static int G__G__MathMore_251_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12486 {
12487       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12488    return(1 || funcname || hash || result7 || libp) ;
12489 }
12490 
12491 static int G__G__MathMore_251_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12492 {
12493       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
12494    return(1 || funcname || hash || result7 || libp) ;
12495 }
12496 
12497 static int G__G__MathMore_251_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12498 {
12499    switch (libp->paran) {
12500    case 3:
12501       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12502 , (double) G__double(libp->para[2]));
12503       G__setnull(result7);
12504       break;
12505    case 2:
12506       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
12507       G__setnull(result7);
12508       break;
12509    }
12510    return(1 || funcname || hash || result7 || libp) ;
12511 }
12512 
12513 static int G__G__MathMore_251_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12514 {
12515    switch (libp->paran) {
12516    case 4:
12517       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12518 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
12519       G__setnull(result7);
12520       break;
12521    case 3:
12522       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12523 , *(double*) G__Doubleref(&libp->para[2]));
12524       G__setnull(result7);
12525       break;
12526    }
12527    return(1 || funcname || hash || result7 || libp) ;
12528 }
12529 
12530 static int G__G__MathMore_251_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12531 {
12532       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
12533    return(1 || funcname || hash || result7 || libp) ;
12534 }
12535 
12536 static int G__G__MathMore_251_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12537 {
12538       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
12539    return(1 || funcname || hash || result7 || libp) ;
12540 }
12541 
12542 static int G__G__MathMore_251_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12543 {
12544       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12545    return(1 || funcname || hash || result7 || libp) ;
12546 }
12547 
12548 static int G__G__MathMore_251_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12549 {
12550       {
12551          vector<unsigned int>* pobj;
12552          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
12553          pobj = new vector<unsigned int>(xobj);
12554          result7->obj.i = (long) ((void*) pobj);
12555          result7->ref = result7->obj.i;
12556          G__store_tempobject(*result7);
12557       }
12558    return(1 || funcname || hash || result7 || libp) ;
12559 }
12560 
12561 // automatic copy constructor
12562 static int G__G__MathMore_251_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12563 
12564 {
12565    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>* p;
12566    void* tmp = (void*) G__int(libp->para[0]);
12567    p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>(*(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) tmp);
12568    result7->obj.i = (long) p;
12569    result7->ref = (long) p;
12570    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR));
12571    return(1 || funcname || hash || result7 || libp) ;
12572 }
12573 
12574 // automatic destructor
12575 typedef ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR;
12576 static int G__G__MathMore_251_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12577 {
12578    char* gvp = (char*) G__getgvp();
12579    long soff = G__getstructoffset();
12580    int n = G__getaryconstruct();
12581    //
12582    //has_a_delete: 0
12583    //has_own_delete1arg: 0
12584    //has_own_delete2arg: 0
12585    //
12586    if (!soff) {
12587      return(1);
12588    }
12589    if (n) {
12590      if (gvp == (char*)G__PVOID) {
12591        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) soff;
12592      } else {
12593        G__setgvp((long) G__PVOID);
12594        for (int i = n - 1; i >= 0; --i) {
12595          ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR();
12596        }
12597        G__setgvp((long)gvp);
12598      }
12599    } else {
12600      if (gvp == (char*)G__PVOID) {
12601        delete (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) soff;
12602      } else {
12603        G__setgvp((long) G__PVOID);
12604        ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR();
12605        G__setgvp((long)gvp);
12606      }
12607    }
12608    G__setnull(result7);
12609    return(1 || funcname || hash || result7 || libp) ;
12610 }
12611 
12612 // automatic assignment operator
12613 static int G__G__MathMore_251_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12614 {
12615    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) G__getstructoffset();
12616    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*) libp->para[0].ref;
12617    const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>& obj = *dest;
12618    result7->ref = (long) (&obj);
12619    result7->obj.i = (long) (&obj);
12620    return(1 || funcname || hash || result7 || libp) ;
12621 }
12622 
12623 
12624 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> */
12625 static int G__G__MathMore_252_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12626 {
12627    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>* p = NULL;
12628    char* gvp = (char*) G__getgvp();
12629    int n = G__getaryconstruct();
12630    if (n) {
12631      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12632        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>[n];
12633      } else {
12634        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>[n];
12635      }
12636    } else {
12637      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12638        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>;
12639      } else {
12640        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>;
12641      }
12642    }
12643    result7->obj.i = (long) p;
12644    result7->ref = (long) p;
12645    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR));
12646    return(1 || funcname || hash || result7 || libp) ;
12647 }
12648 
12649 static int G__G__MathMore_252_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12650 {
12651    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>* p = NULL;
12652    char* gvp = (char*) G__getgvp();
12653    //m: 1
12654    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12655      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>((unsigned int) G__int(libp->para[0]));
12656    } else {
12657      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>((unsigned int) G__int(libp->para[0]));
12658    }
12659    result7->obj.i = (long) p;
12660    result7->ref = (long) p;
12661    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR));
12662    return(1 || funcname || hash || result7 || libp) ;
12663 }
12664 
12665 static int G__G__MathMore_252_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12666 {
12667    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>* p = NULL;
12668    char* gvp = (char*) G__getgvp();
12669    //m: 1
12670    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12671      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>(*(ROOT::Math::GSLRngRanLuxD1*) libp->para[0].ref);
12672    } else {
12673      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>(*(ROOT::Math::GSLRngRanLuxD1*) libp->para[0].ref);
12674    }
12675    result7->obj.i = (long) p;
12676    result7->ref = (long) p;
12677    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR));
12678    return(1 || funcname || hash || result7 || libp) ;
12679 }
12680 
12681 static int G__G__MathMore_252_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12682 {
12683    switch (libp->paran) {
12684    case 1:
12685       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
12686       break;
12687    case 0:
12688       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Uniform());
12689       break;
12690    }
12691    return(1 || funcname || hash || result7 || libp) ;
12692 }
12693 
12694 static int G__G__MathMore_252_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12695 {
12696       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Rndm());
12697    return(1 || funcname || hash || result7 || libp) ;
12698 }
12699 
12700 static int G__G__MathMore_252_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12701 {
12702       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
12703       G__setnull(result7);
12704    return(1 || funcname || hash || result7 || libp) ;
12705 }
12706 
12707 static int G__G__MathMore_252_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12708 {
12709       {
12710          const string* pobj;
12711          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Type();
12712          pobj = new string(xobj);
12713          result7->obj.i = (long) ((void*) pobj);
12714          result7->ref = result7->obj.i;
12715          G__store_tempobject(*result7);
12716       }
12717    return(1 || funcname || hash || result7 || libp) ;
12718 }
12719 
12720 static int G__G__MathMore_252_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12721 {
12722       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->EngineSize());
12723    return(1 || funcname || hash || result7 || libp) ;
12724 }
12725 
12726 static int G__G__MathMore_252_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12727 {
12728       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
12729       G__setnull(result7);
12730    return(1 || funcname || hash || result7 || libp) ;
12731 }
12732 
12733 static int G__G__MathMore_252_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12734 {
12735    switch (libp->paran) {
12736    case 2:
12737       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12738       break;
12739    case 1:
12740       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
12741       break;
12742    case 0:
12743       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Gaus());
12744       break;
12745    }
12746    return(1 || funcname || hash || result7 || libp) ;
12747 }
12748 
12749 static int G__G__MathMore_252_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12750 {
12751    switch (libp->paran) {
12752    case 2:
12753       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12754       break;
12755    case 1:
12756       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
12757       break;
12758    case 0:
12759       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GausBM());
12760       break;
12761    }
12762    return(1 || funcname || hash || result7 || libp) ;
12763 }
12764 
12765 static int G__G__MathMore_252_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12766 {
12767    switch (libp->paran) {
12768    case 2:
12769       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12770       break;
12771    case 1:
12772       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
12773       break;
12774    case 0:
12775       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GausR());
12776       break;
12777    }
12778    return(1 || funcname || hash || result7 || libp) ;
12779 }
12780 
12781 static int G__G__MathMore_252_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12782 {
12783    switch (libp->paran) {
12784    case 2:
12785       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12786       break;
12787    case 1:
12788       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
12789       break;
12790    }
12791    return(1 || funcname || hash || result7 || libp) ;
12792 }
12793 
12794 static int G__G__MathMore_252_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12795 {
12796       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
12797 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
12798 , *(double*) G__Doubleref(&libp->para[4]));
12799       G__setnull(result7);
12800    return(1 || funcname || hash || result7 || libp) ;
12801 }
12802 
12803 static int G__G__MathMore_252_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12804 {
12805       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
12806    return(1 || funcname || hash || result7 || libp) ;
12807 }
12808 
12809 static int G__G__MathMore_252_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12810 {
12811    switch (libp->paran) {
12812    case 2:
12813       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12814       break;
12815    case 1:
12816       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
12817       break;
12818    case 0:
12819       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->BreitWigner());
12820       break;
12821    }
12822    return(1 || funcname || hash || result7 || libp) ;
12823 }
12824 
12825 static int G__G__MathMore_252_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12826 {
12827    switch (libp->paran) {
12828    case 2:
12829       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12830       break;
12831    case 1:
12832       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
12833       break;
12834    case 0:
12835       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Landau());
12836       break;
12837    }
12838    return(1 || funcname || hash || result7 || libp) ;
12839 }
12840 
12841 static int G__G__MathMore_252_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12842 {
12843       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12844    return(1 || funcname || hash || result7 || libp) ;
12845 }
12846 
12847 static int G__G__MathMore_252_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12848 {
12849       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12850    return(1 || funcname || hash || result7 || libp) ;
12851 }
12852 
12853 static int G__G__MathMore_252_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12854 {
12855       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
12856    return(1 || funcname || hash || result7 || libp) ;
12857 }
12858 
12859 static int G__G__MathMore_252_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12860 {
12861       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12862    return(1 || funcname || hash || result7 || libp) ;
12863 }
12864 
12865 static int G__G__MathMore_252_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12866 {
12867       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
12868    return(1 || funcname || hash || result7 || libp) ;
12869 }
12870 
12871 static int G__G__MathMore_252_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12872 {
12873    switch (libp->paran) {
12874    case 3:
12875       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12876 , (double) G__double(libp->para[2]));
12877       G__setnull(result7);
12878       break;
12879    case 2:
12880       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
12881       G__setnull(result7);
12882       break;
12883    }
12884    return(1 || funcname || hash || result7 || libp) ;
12885 }
12886 
12887 static int G__G__MathMore_252_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12888 {
12889    switch (libp->paran) {
12890    case 4:
12891       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12892 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
12893       G__setnull(result7);
12894       break;
12895    case 3:
12896       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
12897 , *(double*) G__Doubleref(&libp->para[2]));
12898       G__setnull(result7);
12899       break;
12900    }
12901    return(1 || funcname || hash || result7 || libp) ;
12902 }
12903 
12904 static int G__G__MathMore_252_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12905 {
12906       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
12907    return(1 || funcname || hash || result7 || libp) ;
12908 }
12909 
12910 static int G__G__MathMore_252_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12911 {
12912       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
12913    return(1 || funcname || hash || result7 || libp) ;
12914 }
12915 
12916 static int G__G__MathMore_252_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12917 {
12918       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
12919    return(1 || funcname || hash || result7 || libp) ;
12920 }
12921 
12922 static int G__G__MathMore_252_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12923 {
12924       {
12925          vector<unsigned int>* pobj;
12926          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
12927          pobj = new vector<unsigned int>(xobj);
12928          result7->obj.i = (long) ((void*) pobj);
12929          result7->ref = result7->obj.i;
12930          G__store_tempobject(*result7);
12931       }
12932    return(1 || funcname || hash || result7 || libp) ;
12933 }
12934 
12935 // automatic copy constructor
12936 static int G__G__MathMore_252_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12937 
12938 {
12939    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>* p;
12940    void* tmp = (void*) G__int(libp->para[0]);
12941    p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>(*(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) tmp);
12942    result7->obj.i = (long) p;
12943    result7->ref = (long) p;
12944    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR));
12945    return(1 || funcname || hash || result7 || libp) ;
12946 }
12947 
12948 // automatic destructor
12949 typedef ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR;
12950 static int G__G__MathMore_252_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12951 {
12952    char* gvp = (char*) G__getgvp();
12953    long soff = G__getstructoffset();
12954    int n = G__getaryconstruct();
12955    //
12956    //has_a_delete: 0
12957    //has_own_delete1arg: 0
12958    //has_own_delete2arg: 0
12959    //
12960    if (!soff) {
12961      return(1);
12962    }
12963    if (n) {
12964      if (gvp == (char*)G__PVOID) {
12965        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) soff;
12966      } else {
12967        G__setgvp((long) G__PVOID);
12968        for (int i = n - 1; i >= 0; --i) {
12969          ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR();
12970        }
12971        G__setgvp((long)gvp);
12972      }
12973    } else {
12974      if (gvp == (char*)G__PVOID) {
12975        delete (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) soff;
12976      } else {
12977        G__setgvp((long) G__PVOID);
12978        ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR();
12979        G__setgvp((long)gvp);
12980      }
12981    }
12982    G__setnull(result7);
12983    return(1 || funcname || hash || result7 || libp) ;
12984 }
12985 
12986 // automatic assignment operator
12987 static int G__G__MathMore_252_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12988 {
12989    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) G__getstructoffset();
12990    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*) libp->para[0].ref;
12991    const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>& obj = *dest;
12992    result7->ref = (long) (&obj);
12993    result7->obj.i = (long) (&obj);
12994    return(1 || funcname || hash || result7 || libp) ;
12995 }
12996 
12997 
12998 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> */
12999 static int G__G__MathMore_253_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13000 {
13001    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>* p = NULL;
13002    char* gvp = (char*) G__getgvp();
13003    int n = G__getaryconstruct();
13004    if (n) {
13005      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13006        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>[n];
13007      } else {
13008        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>[n];
13009      }
13010    } else {
13011      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13012        p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>;
13013      } else {
13014        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>;
13015      }
13016    }
13017    result7->obj.i = (long) p;
13018    result7->ref = (long) p;
13019    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR));
13020    return(1 || funcname || hash || result7 || libp) ;
13021 }
13022 
13023 static int G__G__MathMore_253_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13024 {
13025    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>* p = NULL;
13026    char* gvp = (char*) G__getgvp();
13027    //m: 1
13028    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13029      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>((unsigned int) G__int(libp->para[0]));
13030    } else {
13031      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>((unsigned int) G__int(libp->para[0]));
13032    }
13033    result7->obj.i = (long) p;
13034    result7->ref = (long) p;
13035    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR));
13036    return(1 || funcname || hash || result7 || libp) ;
13037 }
13038 
13039 static int G__G__MathMore_253_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13040 {
13041    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>* p = NULL;
13042    char* gvp = (char*) G__getgvp();
13043    //m: 1
13044    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13045      p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>(*(ROOT::Math::GSLRngRanLuxD2*) libp->para[0].ref);
13046    } else {
13047      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>(*(ROOT::Math::GSLRngRanLuxD2*) libp->para[0].ref);
13048    }
13049    result7->obj.i = (long) p;
13050    result7->ref = (long) p;
13051    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR));
13052    return(1 || funcname || hash || result7 || libp) ;
13053 }
13054 
13055 static int G__G__MathMore_253_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13056 {
13057    switch (libp->paran) {
13058    case 1:
13059       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
13060       break;
13061    case 0:
13062       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Uniform());
13063       break;
13064    }
13065    return(1 || funcname || hash || result7 || libp) ;
13066 }
13067 
13068 static int G__G__MathMore_253_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13069 {
13070       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Rndm());
13071    return(1 || funcname || hash || result7 || libp) ;
13072 }
13073 
13074 static int G__G__MathMore_253_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13075 {
13076       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
13077       G__setnull(result7);
13078    return(1 || funcname || hash || result7 || libp) ;
13079 }
13080 
13081 static int G__G__MathMore_253_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13082 {
13083       {
13084          const string* pobj;
13085          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Type();
13086          pobj = new string(xobj);
13087          result7->obj.i = (long) ((void*) pobj);
13088          result7->ref = result7->obj.i;
13089          G__store_tempobject(*result7);
13090       }
13091    return(1 || funcname || hash || result7 || libp) ;
13092 }
13093 
13094 static int G__G__MathMore_253_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13095 {
13096       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->EngineSize());
13097    return(1 || funcname || hash || result7 || libp) ;
13098 }
13099 
13100 static int G__G__MathMore_253_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13101 {
13102       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
13103       G__setnull(result7);
13104    return(1 || funcname || hash || result7 || libp) ;
13105 }
13106 
13107 static int G__G__MathMore_253_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13108 {
13109    switch (libp->paran) {
13110    case 2:
13111       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13112       break;
13113    case 1:
13114       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
13115       break;
13116    case 0:
13117       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Gaus());
13118       break;
13119    }
13120    return(1 || funcname || hash || result7 || libp) ;
13121 }
13122 
13123 static int G__G__MathMore_253_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13124 {
13125    switch (libp->paran) {
13126    case 2:
13127       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13128       break;
13129    case 1:
13130       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
13131       break;
13132    case 0:
13133       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GausBM());
13134       break;
13135    }
13136    return(1 || funcname || hash || result7 || libp) ;
13137 }
13138 
13139 static int G__G__MathMore_253_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13140 {
13141    switch (libp->paran) {
13142    case 2:
13143       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13144       break;
13145    case 1:
13146       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
13147       break;
13148    case 0:
13149       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GausR());
13150       break;
13151    }
13152    return(1 || funcname || hash || result7 || libp) ;
13153 }
13154 
13155 static int G__G__MathMore_253_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13156 {
13157    switch (libp->paran) {
13158    case 2:
13159       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13160       break;
13161    case 1:
13162       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
13163       break;
13164    }
13165    return(1 || funcname || hash || result7 || libp) ;
13166 }
13167 
13168 static int G__G__MathMore_253_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13169 {
13170       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
13171 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
13172 , *(double*) G__Doubleref(&libp->para[4]));
13173       G__setnull(result7);
13174    return(1 || funcname || hash || result7 || libp) ;
13175 }
13176 
13177 static int G__G__MathMore_253_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13178 {
13179       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
13180    return(1 || funcname || hash || result7 || libp) ;
13181 }
13182 
13183 static int G__G__MathMore_253_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13184 {
13185    switch (libp->paran) {
13186    case 2:
13187       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13188       break;
13189    case 1:
13190       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
13191       break;
13192    case 0:
13193       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->BreitWigner());
13194       break;
13195    }
13196    return(1 || funcname || hash || result7 || libp) ;
13197 }
13198 
13199 static int G__G__MathMore_253_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13200 {
13201    switch (libp->paran) {
13202    case 2:
13203       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13204       break;
13205    case 1:
13206       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
13207       break;
13208    case 0:
13209       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Landau());
13210       break;
13211    }
13212    return(1 || funcname || hash || result7 || libp) ;
13213 }
13214 
13215 static int G__G__MathMore_253_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13216 {
13217       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13218    return(1 || funcname || hash || result7 || libp) ;
13219 }
13220 
13221 static int G__G__MathMore_253_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13222 {
13223       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13224    return(1 || funcname || hash || result7 || libp) ;
13225 }
13226 
13227 static int G__G__MathMore_253_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13228 {
13229       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
13230    return(1 || funcname || hash || result7 || libp) ;
13231 }
13232 
13233 static int G__G__MathMore_253_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13234 {
13235       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13236    return(1 || funcname || hash || result7 || libp) ;
13237 }
13238 
13239 static int G__G__MathMore_253_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13240 {
13241       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
13242    return(1 || funcname || hash || result7 || libp) ;
13243 }
13244 
13245 static int G__G__MathMore_253_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13246 {
13247    switch (libp->paran) {
13248    case 3:
13249       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
13250 , (double) G__double(libp->para[2]));
13251       G__setnull(result7);
13252       break;
13253    case 2:
13254       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
13255       G__setnull(result7);
13256       break;
13257    }
13258    return(1 || funcname || hash || result7 || libp) ;
13259 }
13260 
13261 static int G__G__MathMore_253_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13262 {
13263    switch (libp->paran) {
13264    case 4:
13265       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
13266 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
13267       G__setnull(result7);
13268       break;
13269    case 3:
13270       ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
13271 , *(double*) G__Doubleref(&libp->para[2]));
13272       G__setnull(result7);
13273       break;
13274    }
13275    return(1 || funcname || hash || result7 || libp) ;
13276 }
13277 
13278 static int G__G__MathMore_253_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13279 {
13280       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
13281    return(1 || funcname || hash || result7 || libp) ;
13282 }
13283 
13284 static int G__G__MathMore_253_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13285 {
13286       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
13287    return(1 || funcname || hash || result7 || libp) ;
13288 }
13289 
13290 static int G__G__MathMore_253_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13291 {
13292       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13293    return(1 || funcname || hash || result7 || libp) ;
13294 }
13295 
13296 static int G__G__MathMore_253_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13297 {
13298       {
13299          vector<unsigned int>* pobj;
13300          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
13301          pobj = new vector<unsigned int>(xobj);
13302          result7->obj.i = (long) ((void*) pobj);
13303          result7->ref = result7->obj.i;
13304          G__store_tempobject(*result7);
13305       }
13306    return(1 || funcname || hash || result7 || libp) ;
13307 }
13308 
13309 // automatic copy constructor
13310 static int G__G__MathMore_253_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13311 
13312 {
13313    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>* p;
13314    void* tmp = (void*) G__int(libp->para[0]);
13315    p = new ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>(*(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) tmp);
13316    result7->obj.i = (long) p;
13317    result7->ref = (long) p;
13318    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR));
13319    return(1 || funcname || hash || result7 || libp) ;
13320 }
13321 
13322 // automatic destructor
13323 typedef ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR;
13324 static int G__G__MathMore_253_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13325 {
13326    char* gvp = (char*) G__getgvp();
13327    long soff = G__getstructoffset();
13328    int n = G__getaryconstruct();
13329    //
13330    //has_a_delete: 0
13331    //has_own_delete1arg: 0
13332    //has_own_delete2arg: 0
13333    //
13334    if (!soff) {
13335      return(1);
13336    }
13337    if (n) {
13338      if (gvp == (char*)G__PVOID) {
13339        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) soff;
13340      } else {
13341        G__setgvp((long) G__PVOID);
13342        for (int i = n - 1; i >= 0; --i) {
13343          ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR();
13344        }
13345        G__setgvp((long)gvp);
13346      }
13347    } else {
13348      if (gvp == (char*)G__PVOID) {
13349        delete (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) soff;
13350      } else {
13351        G__setgvp((long) G__PVOID);
13352        ((ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR();
13353        G__setgvp((long)gvp);
13354      }
13355    }
13356    G__setnull(result7);
13357    return(1 || funcname || hash || result7 || libp) ;
13358 }
13359 
13360 // automatic assignment operator
13361 static int G__G__MathMore_253_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13362 {
13363    ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) G__getstructoffset();
13364    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*) libp->para[0].ref;
13365    const ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>& obj = *dest;
13366    result7->ref = (long) (&obj);
13367    result7->obj.i = (long) (&obj);
13368    return(1 || funcname || hash || result7 || libp) ;
13369 }
13370 
13371 
13372 /* ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> */
13373 static int G__G__MathMore_254_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13374 {
13375    ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>* p = NULL;
13376    char* gvp = (char*) G__getgvp();
13377    int n = G__getaryconstruct();
13378    if (n) {
13379      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13380        p = new ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>[n];
13381      } else {
13382        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>[n];
13383      }
13384    } else {
13385      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13386        p = new ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>;
13387      } else {
13388        p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>;
13389      }
13390    }
13391    result7->obj.i = (long) p;
13392    result7->ref = (long) p;
13393    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR));
13394    return(1 || funcname || hash || result7 || libp) ;
13395 }
13396 
13397 static int G__G__MathMore_254_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13398 {
13399    ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>* p = NULL;
13400    char* gvp = (char*) G__getgvp();
13401    //m: 1
13402    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13403      p = new ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>((unsigned int) G__int(libp->para[0]));
13404    } else {
13405      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>((unsigned int) G__int(libp->para[0]));
13406    }
13407    result7->obj.i = (long) p;
13408    result7->ref = (long) p;
13409    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR));
13410    return(1 || funcname || hash || result7 || libp) ;
13411 }
13412 
13413 static int G__G__MathMore_254_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13414 {
13415    ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>* p = NULL;
13416    char* gvp = (char*) G__getgvp();
13417    //m: 1
13418    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13419      p = new ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>(*(ROOT::Math::GSLRngGFSR4*) libp->para[0].ref);
13420    } else {
13421      p = new((void*) gvp) ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>(*(ROOT::Math::GSLRngGFSR4*) libp->para[0].ref);
13422    }
13423    result7->obj.i = (long) p;
13424    result7->ref = (long) p;
13425    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR));
13426    return(1 || funcname || hash || result7 || libp) ;
13427 }
13428 
13429 static int G__G__MathMore_254_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13430 {
13431    switch (libp->paran) {
13432    case 1:
13433       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Uniform((double) G__double(libp->para[0])));
13434       break;
13435    case 0:
13436       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Uniform());
13437       break;
13438    }
13439    return(1 || funcname || hash || result7 || libp) ;
13440 }
13441 
13442 static int G__G__MathMore_254_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13443 {
13444       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Rndm());
13445    return(1 || funcname || hash || result7 || libp) ;
13446 }
13447 
13448 static int G__G__MathMore_254_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13449 {
13450       ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->RndmArray((int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
13451       G__setnull(result7);
13452    return(1 || funcname || hash || result7 || libp) ;
13453 }
13454 
13455 static int G__G__MathMore_254_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13456 {
13457       {
13458          const string* pobj;
13459          const string xobj = ((const ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Type();
13460          pobj = new string(xobj);
13461          result7->obj.i = (long) ((void*) pobj);
13462          result7->ref = result7->obj.i;
13463          G__store_tempobject(*result7);
13464       }
13465    return(1 || funcname || hash || result7 || libp) ;
13466 }
13467 
13468 static int G__G__MathMore_254_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13469 {
13470       G__letint(result7, 104, (long) ((const ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->EngineSize());
13471    return(1 || funcname || hash || result7 || libp) ;
13472 }
13473 
13474 static int G__G__MathMore_254_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13475 {
13476       ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->SetSeed((unsigned int) G__int(libp->para[0]));
13477       G__setnull(result7);
13478    return(1 || funcname || hash || result7 || libp) ;
13479 }
13480 
13481 static int G__G__MathMore_254_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13482 {
13483    switch (libp->paran) {
13484    case 2:
13485       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13486       break;
13487    case 1:
13488       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Gaus((double) G__double(libp->para[0])));
13489       break;
13490    case 0:
13491       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Gaus());
13492       break;
13493    }
13494    return(1 || funcname || hash || result7 || libp) ;
13495 }
13496 
13497 static int G__G__MathMore_254_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13498 {
13499    switch (libp->paran) {
13500    case 2:
13501       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13502       break;
13503    case 1:
13504       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GausBM((double) G__double(libp->para[0])));
13505       break;
13506    case 0:
13507       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GausBM());
13508       break;
13509    }
13510    return(1 || funcname || hash || result7 || libp) ;
13511 }
13512 
13513 static int G__G__MathMore_254_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13514 {
13515    switch (libp->paran) {
13516    case 2:
13517       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GausR((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13518       break;
13519    case 1:
13520       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GausR((double) G__double(libp->para[0])));
13521       break;
13522    case 0:
13523       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GausR());
13524       break;
13525    }
13526    return(1 || funcname || hash || result7 || libp) ;
13527 }
13528 
13529 static int G__G__MathMore_254_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13530 {
13531    switch (libp->paran) {
13532    case 2:
13533       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13534       break;
13535    case 1:
13536       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->GaussianTail((double) G__double(libp->para[0])));
13537       break;
13538    }
13539    return(1 || funcname || hash || result7 || libp) ;
13540 }
13541 
13542 static int G__G__MathMore_254_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13543 {
13544       ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Gaussian2D((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
13545 , (double) G__double(libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
13546 , *(double*) G__Doubleref(&libp->para[4]));
13547       G__setnull(result7);
13548    return(1 || funcname || hash || result7 || libp) ;
13549 }
13550 
13551 static int G__G__MathMore_254_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13552 {
13553       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Exp((double) G__double(libp->para[0])));
13554    return(1 || funcname || hash || result7 || libp) ;
13555 }
13556 
13557 static int G__G__MathMore_254_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13558 {
13559    switch (libp->paran) {
13560    case 2:
13561       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13562       break;
13563    case 1:
13564       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->BreitWigner((double) G__double(libp->para[0])));
13565       break;
13566    case 0:
13567       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->BreitWigner());
13568       break;
13569    }
13570    return(1 || funcname || hash || result7 || libp) ;
13571 }
13572 
13573 static int G__G__MathMore_254_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13574 {
13575    switch (libp->paran) {
13576    case 2:
13577       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Landau((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13578       break;
13579    case 1:
13580       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Landau((double) G__double(libp->para[0])));
13581       break;
13582    case 0:
13583       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Landau());
13584       break;
13585    }
13586    return(1 || funcname || hash || result7 || libp) ;
13587 }
13588 
13589 static int G__G__MathMore_254_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13590 {
13591       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Gamma((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13592    return(1 || funcname || hash || result7 || libp) ;
13593 }
13594 
13595 static int G__G__MathMore_254_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13596 {
13597       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->LogNormal((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13598    return(1 || funcname || hash || result7 || libp) ;
13599 }
13600 
13601 static int G__G__MathMore_254_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13602 {
13603       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->ChiSquare((double) G__double(libp->para[0])));
13604    return(1 || funcname || hash || result7 || libp) ;
13605 }
13606 
13607 static int G__G__MathMore_254_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13608 {
13609       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->FDist((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13610    return(1 || funcname || hash || result7 || libp) ;
13611 }
13612 
13613 static int G__G__MathMore_254_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13614 {
13615       G__letdouble(result7, 100, (double) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->tDist((double) G__double(libp->para[0])));
13616    return(1 || funcname || hash || result7 || libp) ;
13617 }
13618 
13619 static int G__G__MathMore_254_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13620 {
13621    switch (libp->paran) {
13622    case 3:
13623       ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
13624 , (double) G__double(libp->para[2]));
13625       G__setnull(result7);
13626       break;
13627    case 2:
13628       ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Circle(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
13629       G__setnull(result7);
13630       break;
13631    }
13632    return(1 || funcname || hash || result7 || libp) ;
13633 }
13634 
13635 static int G__G__MathMore_254_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13636 {
13637    switch (libp->paran) {
13638    case 4:
13639       ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
13640 , *(double*) G__Doubleref(&libp->para[2]), (double) G__double(libp->para[3]));
13641       G__setnull(result7);
13642       break;
13643    case 3:
13644       ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Sphere(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
13645 , *(double*) G__Doubleref(&libp->para[2]));
13646       G__setnull(result7);
13647       break;
13648    }
13649    return(1 || funcname || hash || result7 || libp) ;
13650 }
13651 
13652 static int G__G__MathMore_254_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13653 {
13654       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Poisson((double) G__double(libp->para[0])));
13655    return(1 || funcname || hash || result7 || libp) ;
13656 }
13657 
13658 static int G__G__MathMore_254_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13659 {
13660       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Binomial((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
13661    return(1 || funcname || hash || result7 || libp) ;
13662 }
13663 
13664 static int G__G__MathMore_254_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13665 {
13666       G__letint(result7, 104, (long) ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->NegativeBinomial((double) G__double(libp->para[0]), (double) G__double(libp->para[1])));
13667    return(1 || funcname || hash || result7 || libp) ;
13668 }
13669 
13670 static int G__G__MathMore_254_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13671 {
13672       {
13673          vector<unsigned int>* pobj;
13674          vector<unsigned int> xobj = ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset())->Multinomial((unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref);
13675          pobj = new vector<unsigned int>(xobj);
13676          result7->obj.i = (long) ((void*) pobj);
13677          result7->ref = result7->obj.i;
13678          G__store_tempobject(*result7);
13679       }
13680    return(1 || funcname || hash || result7 || libp) ;
13681 }
13682 
13683 // automatic copy constructor
13684 static int G__G__MathMore_254_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13685 
13686 {
13687    ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>* p;
13688    void* tmp = (void*) G__int(libp->para[0]);
13689    p = new ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>(*(ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) tmp);
13690    result7->obj.i = (long) p;
13691    result7->ref = (long) p;
13692    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR));
13693    return(1 || funcname || hash || result7 || libp) ;
13694 }
13695 
13696 // automatic destructor
13697 typedef ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR;
13698 static int G__G__MathMore_254_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13699 {
13700    char* gvp = (char*) G__getgvp();
13701    long soff = G__getstructoffset();
13702    int n = G__getaryconstruct();
13703    //
13704    //has_a_delete: 0
13705    //has_own_delete1arg: 0
13706    //has_own_delete2arg: 0
13707    //
13708    if (!soff) {
13709      return(1);
13710    }
13711    if (n) {
13712      if (gvp == (char*)G__PVOID) {
13713        delete[] (ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) soff;
13714      } else {
13715        G__setgvp((long) G__PVOID);
13716        for (int i = n - 1; i >= 0; --i) {
13717          ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) (soff+(sizeof(ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>)*i)))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR();
13718        }
13719        G__setgvp((long)gvp);
13720      }
13721    } else {
13722      if (gvp == (char*)G__PVOID) {
13723        delete (ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) soff;
13724      } else {
13725        G__setgvp((long) G__PVOID);
13726        ((ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) (soff))->~G__TROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR();
13727        G__setgvp((long)gvp);
13728      }
13729    }
13730    G__setnull(result7);
13731    return(1 || funcname || hash || result7 || libp) ;
13732 }
13733 
13734 // automatic assignment operator
13735 static int G__G__MathMore_254_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13736 {
13737    ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>* dest = (ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) G__getstructoffset();
13738    *dest = *(ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*) libp->para[0].ref;
13739    const ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>& obj = *dest;
13740    result7->ref = (long) (&obj);
13741    result7->obj.i = (long) (&obj);
13742    return(1 || funcname || hash || result7 || libp) ;
13743 }
13744 
13745 
13746 /* Setting up global function */
13747 
13748 /*********************************************************
13749 * Member function Stub
13750 *********************************************************/
13751 
13752 /* ROOT */
13753 
13754 /* ROOT::Math */
13755 
13756 /* ROOT::MathMore */
13757 
13758 /* ROOT::Math::Polynomial */
13759 
13760 /* ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> */
13761 
13762 /* ROOT::Math::Derivator */
13763 
13764 /* ROOT::Math::Interpolator */
13765 
13766 /* ROOT::Math::GSLRootFinder */
13767 
13768 /* ROOT::Math::GSLRootFinderDeriv */
13769 
13770 /* ROOT::Math::Roots */
13771 
13772 /* ROOT::Math::Roots::Bisection */
13773 
13774 /* ROOT::Math::Roots::FalsePos */
13775 
13776 /* ROOT::Math::Roots::Brent */
13777 
13778 /* ROOT::Math::Roots::Newton */
13779 
13780 /* ROOT::Math::Roots::Secant */
13781 
13782 /* ROOT::Math::Roots::Steffenson */
13783 
13784 /* ROOT::Math::Integration */
13785 
13786 /* ROOT::Math::GSLIntegrator */
13787 
13788 /* ROOT::Math::VegasParameters */
13789 
13790 /* ROOT::Math::MiserParameters */
13791 
13792 /* ROOT::Math::GSLMCIntegrator */
13793 
13794 /* ROOT::Math::Minim1D */
13795 
13796 /* ROOT::Math::GSLMinimizer1D */
13797 
13798 /* ROOT::Math::Chebyshev */
13799 
13800 /* ROOT::Math::GSLRandomEngine */
13801 
13802 /* ROOT::Math::GSLRngMT */
13803 
13804 /* ROOT::Math::GSLRngRanLux */
13805 
13806 /* ROOT::Math::GSLRngRanLuxS1 */
13807 
13808 /* ROOT::Math::GSLRngRanLuxS2 */
13809 
13810 /* ROOT::Math::GSLRngRanLuxD1 */
13811 
13812 /* ROOT::Math::GSLRngRanLuxD2 */
13813 
13814 /* ROOT::Math::GSLRngTaus */
13815 
13816 /* ROOT::Math::GSLRngGFSR4 */
13817 
13818 /* ROOT::Math::KelvinFunctions */
13819 
13820 /* ROOT::Math::GSLMinimizer */
13821 
13822 /* ROOT::Math::LSResidualFunc */
13823 
13824 /* ROOT::Math::GSLNLSMinimizer */
13825 
13826 /* ROOT::Math::GSLSimAnFunc */
13827 
13828 /* ROOT::Math::GSLSimAnParams */
13829 
13830 /* ROOT::Math::GSLSimAnnealing */
13831 
13832 /* ROOT::Math::GSLSimAnMinimizer */
13833 
13834 /* ROOT::Math::Vavilov */
13835 
13836 /* ROOT::Math::VavilovAccurate */
13837 
13838 /* ROOT::Math::VavilovAccuratePdf */
13839 
13840 /* ROOT::Math::VavilovAccurateCdf */
13841 
13842 /* ROOT::Math::VavilovAccurateQuantile */
13843 
13844 /* ROOT::Math::VavilovFast */
13845 
13846 /* ROOT::Math::Random<ROOT::Math::GSLRngMT> */
13847 
13848 /* ROOT::Math::Random<ROOT::Math::GSLRngTaus> */
13849 
13850 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLux> */
13851 
13852 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> */
13853 
13854 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> */
13855 
13856 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> */
13857 
13858 /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> */
13859 
13860 /* ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> */
13861 
13862 /*********************************************************
13863 * Global function Stub
13864 *********************************************************/
13865 
13866 /*********************************************************
13867 * Get size of pointer to member function
13868 *********************************************************/
13869 class G__Sizep2memfuncG__MathMore {
13870  public:
13871   G__Sizep2memfuncG__MathMore(): p(&G__Sizep2memfuncG__MathMore::sizep2memfunc) {}
13872     size_t sizep2memfunc() { return(sizeof(p)); }
13873   private:
13874     size_t (G__Sizep2memfuncG__MathMore::*p)();
13875 };
13876 
13877 size_t G__get_sizep2memfuncG__MathMore()
13878 {
13879   G__Sizep2memfuncG__MathMore a;
13880   G__setsizep2memfunc((int)a.sizep2memfunc());
13881   return((size_t)a.sizep2memfunc());
13882 }
13883 
13884 
13885 /*********************************************************
13886 * virtual base class offset calculation interface
13887 *********************************************************/
13888 
13889    /* Setting up class inheritance */
13890 static long G__2vbo_ROOTcLcLMathcLcLPolynomial_ROOTcLcLMathcLcLIBaseFunctionOneDim_3(long pobject) {
13891   ROOT::Math::Polynomial *G__Lderived=(ROOT::Math::Polynomial*)pobject;
13892   ROOT::Math::IBaseFunctionOneDim *G__Lbase=G__Lderived;
13893   return((long)G__Lbase-(long)G__Lderived);
13894 }
13895 
13896 static long G__2vbo_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_ROOTcLcLMathcLcLIBaseFunctionOneDim_2(long pobject) {
13897   ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> *G__Lderived=(ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)pobject;
13898   ROOT::Math::IBaseFunctionOneDim *G__Lbase=G__Lderived;
13899   return((long)G__Lbase-(long)G__Lderived);
13900 }
13901 
13902 static long G__2vbo_ROOTcLcLMathcLcLLSResidualFunc_ROOTcLcLMathcLcLIBaseFunctionMultiDim_1(long pobject) {
13903   ROOT::Math::LSResidualFunc *G__Lderived=(ROOT::Math::LSResidualFunc*)pobject;
13904   ROOT::Math::IBaseFunctionMultiDim *G__Lbase=G__Lderived;
13905   return((long)G__Lbase-(long)G__Lderived);
13906 }
13907 
13908 static long G__2vbo_ROOTcLcLMathcLcLVavilovAccuratePdf_ROOTcLcLMathcLcLIBaseFunctionOneDim_1(long pobject) {
13909   ROOT::Math::VavilovAccuratePdf *G__Lderived=(ROOT::Math::VavilovAccuratePdf*)pobject;
13910   ROOT::Math::IBaseFunctionOneDim *G__Lbase=G__Lderived;
13911   return((long)G__Lbase-(long)G__Lderived);
13912 }
13913 
13914 static long G__2vbo_ROOTcLcLMathcLcLVavilovAccurateCdf_ROOTcLcLMathcLcLIBaseFunctionOneDim_1(long pobject) {
13915   ROOT::Math::VavilovAccurateCdf *G__Lderived=(ROOT::Math::VavilovAccurateCdf*)pobject;
13916   ROOT::Math::IBaseFunctionOneDim *G__Lbase=G__Lderived;
13917   return((long)G__Lbase-(long)G__Lderived);
13918 }
13919 
13920 static long G__2vbo_ROOTcLcLMathcLcLVavilovAccurateQuantile_ROOTcLcLMathcLcLIBaseFunctionOneDim_1(long pobject) {
13921   ROOT::Math::VavilovAccurateQuantile *G__Lderived=(ROOT::Math::VavilovAccurateQuantile*)pobject;
13922   ROOT::Math::IBaseFunctionOneDim *G__Lbase=G__Lderived;
13923   return((long)G__Lbase-(long)G__Lderived);
13924 }
13925 
13926 
13927 /*********************************************************
13928 * Inheritance information setup/
13929 *********************************************************/
13930 extern "C" void G__cpp_setup_inheritanceG__MathMore() {
13931 
13932    /* Setting up class inheritance */
13933    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial))) {
13934      ROOT::Math::Polynomial *G__Lderived;
13935      G__Lderived=(ROOT::Math::Polynomial*)0x1000;
13936      {
13937        ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> *G__Lpbase=(ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)G__Lderived;
13938        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),(long)G__Lpbase-(long)G__Lderived,1,1);
13939      }
13940      {
13941        ROOT::Math::IParametricGradFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricGradFunctionOneDim*)G__Lderived;
13942        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,0);
13943      }
13944      {
13945        ROOT::Math::IParametricFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricFunctionOneDim*)G__Lderived;
13946        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,0);
13947      }
13948      {
13949        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),(long)G__2vbo_ROOTcLcLMathcLcLPolynomial_ROOTcLcLMathcLcLIBaseFunctionOneDim_3,1,2);
13950      }
13951      {
13952        ROOT::Math::IBaseParam *G__Lpbase=(ROOT::Math::IBaseParam*)G__Lderived;
13953        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam),(long)G__Lpbase-(long)G__Lderived,1,0);
13954      }
13955      {
13956        ROOT::Math::IGradientOneDim *G__Lpbase=(ROOT::Math::IGradientOneDim*)G__Lderived;
13957        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
13958      }
13959    }
13960    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR))) {
13961      ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> *G__Lderived;
13962      G__Lderived=(ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)0x1000;
13963      {
13964        ROOT::Math::IParametricGradFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricGradFunctionOneDim*)G__Lderived;
13965        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
13966      }
13967      {
13968        ROOT::Math::IParametricFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricFunctionOneDim*)G__Lderived;
13969        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,0);
13970      }
13971      {
13972        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),(long)G__2vbo_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR_ROOTcLcLMathcLcLIBaseFunctionOneDim_2,1,2);
13973      }
13974      {
13975        ROOT::Math::IBaseParam *G__Lpbase=(ROOT::Math::IBaseParam*)G__Lderived;
13976        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam),(long)G__Lpbase-(long)G__Lderived,1,0);
13977      }
13978    }
13979    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder))) {
13980      ROOT::Math::GSLRootFinder *G__Lderived;
13981      G__Lderived=(ROOT::Math::GSLRootFinder*)0x1000;
13982      {
13983        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
13984        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,1);
13985      }
13986    }
13987    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv))) {
13988      ROOT::Math::GSLRootFinderDeriv *G__Lderived;
13989      G__Lderived=(ROOT::Math::GSLRootFinderDeriv*)0x1000;
13990      {
13991        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
13992        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,1);
13993      }
13994    }
13995    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection))) {
13996      ROOT::Math::Roots::Bisection *G__Lderived;
13997      G__Lderived=(ROOT::Math::Roots::Bisection*)0x1000;
13998      {
13999        ROOT::Math::GSLRootFinder *G__Lpbase=(ROOT::Math::GSLRootFinder*)G__Lderived;
14000        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
14001      }
14002      {
14003        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
14004        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,0);
14005      }
14006    }
14007    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos))) {
14008      ROOT::Math::Roots::FalsePos *G__Lderived;
14009      G__Lderived=(ROOT::Math::Roots::FalsePos*)0x1000;
14010      {
14011        ROOT::Math::GSLRootFinder *G__Lpbase=(ROOT::Math::GSLRootFinder*)G__Lderived;
14012        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
14013      }
14014      {
14015        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
14016        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,0);
14017      }
14018    }
14019    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent))) {
14020      ROOT::Math::Roots::Brent *G__Lderived;
14021      G__Lderived=(ROOT::Math::Roots::Brent*)0x1000;
14022      {
14023        ROOT::Math::GSLRootFinder *G__Lpbase=(ROOT::Math::GSLRootFinder*)G__Lderived;
14024        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
14025      }
14026      {
14027        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
14028        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,0);
14029      }
14030    }
14031    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton))) {
14032      ROOT::Math::Roots::Newton *G__Lderived;
14033      G__Lderived=(ROOT::Math::Roots::Newton*)0x1000;
14034      {
14035        ROOT::Math::GSLRootFinderDeriv *G__Lpbase=(ROOT::Math::GSLRootFinderDeriv*)G__Lderived;
14036        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv),(long)G__Lpbase-(long)G__Lderived,1,1);
14037      }
14038      {
14039        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
14040        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,0);
14041      }
14042    }
14043    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant))) {
14044      ROOT::Math::Roots::Secant *G__Lderived;
14045      G__Lderived=(ROOT::Math::Roots::Secant*)0x1000;
14046      {
14047        ROOT::Math::GSLRootFinderDeriv *G__Lpbase=(ROOT::Math::GSLRootFinderDeriv*)G__Lderived;
14048        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv),(long)G__Lpbase-(long)G__Lderived,1,1);
14049      }
14050      {
14051        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
14052        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,0);
14053      }
14054    }
14055    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson))) {
14056      ROOT::Math::Roots::Steffenson *G__Lderived;
14057      G__Lderived=(ROOT::Math::Roots::Steffenson*)0x1000;
14058      {
14059        ROOT::Math::GSLRootFinderDeriv *G__Lpbase=(ROOT::Math::GSLRootFinderDeriv*)G__Lderived;
14060        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv),(long)G__Lpbase-(long)G__Lderived,1,1);
14061      }
14062      {
14063        ROOT::Math::IRootFinderMethod *G__Lpbase=(ROOT::Math::IRootFinderMethod*)G__Lderived;
14064        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod),(long)G__Lpbase-(long)G__Lderived,1,0);
14065      }
14066    }
14067    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator))) {
14068      ROOT::Math::GSLIntegrator *G__Lderived;
14069      G__Lderived=(ROOT::Math::GSLIntegrator*)0x1000;
14070      {
14071        ROOT::Math::VirtualIntegratorOneDim *G__Lpbase=(ROOT::Math::VirtualIntegratorOneDim*)G__Lderived;
14072        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
14073      }
14074      {
14075        ROOT::Math::VirtualIntegrator *G__Lpbase=(ROOT::Math::VirtualIntegrator*)G__Lderived;
14076        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegrator),(long)G__Lpbase-(long)G__Lderived,1,0);
14077      }
14078    }
14079    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator))) {
14080      ROOT::Math::GSLMCIntegrator *G__Lderived;
14081      G__Lderived=(ROOT::Math::GSLMCIntegrator*)0x1000;
14082      {
14083        ROOT::Math::VirtualIntegratorMultiDim *G__Lpbase=(ROOT::Math::VirtualIntegratorMultiDim*)G__Lderived;
14084        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorMultiDim),(long)G__Lpbase-(long)G__Lderived,1,1);
14085      }
14086      {
14087        ROOT::Math::VirtualIntegrator *G__Lpbase=(ROOT::Math::VirtualIntegrator*)G__Lderived;
14088        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegrator),(long)G__Lpbase-(long)G__Lderived,1,0);
14089      }
14090    }
14091    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D))) {
14092      ROOT::Math::GSLMinimizer1D *G__Lderived;
14093      G__Lderived=(ROOT::Math::GSLMinimizer1D*)0x1000;
14094      {
14095        ROOT::Math::IMinimizer1D *G__Lpbase=(ROOT::Math::IMinimizer1D*)G__Lderived;
14096        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIMinimizer1D),(long)G__Lpbase-(long)G__Lderived,1,1);
14097      }
14098    }
14099    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT))) {
14100      ROOT::Math::GSLRngMT *G__Lderived;
14101      G__Lderived=(ROOT::Math::GSLRngMT*)0x1000;
14102      {
14103        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14104        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14105      }
14106    }
14107    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux))) {
14108      ROOT::Math::GSLRngRanLux *G__Lderived;
14109      G__Lderived=(ROOT::Math::GSLRngRanLux*)0x1000;
14110      {
14111        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14112        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14113      }
14114    }
14115    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1))) {
14116      ROOT::Math::GSLRngRanLuxS1 *G__Lderived;
14117      G__Lderived=(ROOT::Math::GSLRngRanLuxS1*)0x1000;
14118      {
14119        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14120        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14121      }
14122    }
14123    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2))) {
14124      ROOT::Math::GSLRngRanLuxS2 *G__Lderived;
14125      G__Lderived=(ROOT::Math::GSLRngRanLuxS2*)0x1000;
14126      {
14127        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14128        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14129      }
14130    }
14131    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1))) {
14132      ROOT::Math::GSLRngRanLuxD1 *G__Lderived;
14133      G__Lderived=(ROOT::Math::GSLRngRanLuxD1*)0x1000;
14134      {
14135        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14136        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14137      }
14138    }
14139    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2))) {
14140      ROOT::Math::GSLRngRanLuxD2 *G__Lderived;
14141      G__Lderived=(ROOT::Math::GSLRngRanLuxD2*)0x1000;
14142      {
14143        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14144        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14145      }
14146    }
14147    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus))) {
14148      ROOT::Math::GSLRngTaus *G__Lderived;
14149      G__Lderived=(ROOT::Math::GSLRngTaus*)0x1000;
14150      {
14151        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14152        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14153      }
14154    }
14155    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4))) {
14156      ROOT::Math::GSLRngGFSR4 *G__Lderived;
14157      G__Lderived=(ROOT::Math::GSLRngGFSR4*)0x1000;
14158      {
14159        ROOT::Math::GSLRandomEngine *G__Lpbase=(ROOT::Math::GSLRandomEngine*)G__Lderived;
14160        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),(long)G__Lpbase-(long)G__Lderived,1,1);
14161      }
14162    }
14163    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer))) {
14164      ROOT::Math::GSLMinimizer *G__Lderived;
14165      G__Lderived=(ROOT::Math::GSLMinimizer*)0x1000;
14166      {
14167        ROOT::Math::Minimizer *G__Lpbase=(ROOT::Math::Minimizer*)G__Lderived;
14168        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
14169      }
14170    }
14171    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc))) {
14172      ROOT::Math::LSResidualFunc *G__Lderived;
14173      G__Lderived=(ROOT::Math::LSResidualFunc*)0x1000;
14174      {
14175        ROOT::Math::IGradientFunctionMultiDim *G__Lpbase=(ROOT::Math::IGradientFunctionMultiDim*)G__Lderived;
14176        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,1);
14177      }
14178      {
14179        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__2vbo_ROOTcLcLMathcLcLLSResidualFunc_ROOTcLcLMathcLcLIBaseFunctionMultiDim_1,1,2);
14180      }
14181      {
14182        ROOT::Math::IGradientMultiDim *G__Lpbase=(ROOT::Math::IGradientMultiDim*)G__Lderived;
14183        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
14184      }
14185    }
14186    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer))) {
14187      ROOT::Math::GSLNLSMinimizer *G__Lderived;
14188      G__Lderived=(ROOT::Math::GSLNLSMinimizer*)0x1000;
14189      {
14190        ROOT::Math::Minimizer *G__Lpbase=(ROOT::Math::Minimizer*)G__Lderived;
14191        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
14192      }
14193    }
14194    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer))) {
14195      ROOT::Math::GSLSimAnMinimizer *G__Lderived;
14196      G__Lderived=(ROOT::Math::GSLSimAnMinimizer*)0x1000;
14197      {
14198        ROOT::Math::Minimizer *G__Lpbase=(ROOT::Math::Minimizer*)G__Lderived;
14199        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
14200      }
14201    }
14202    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate))) {
14203      ROOT::Math::VavilovAccurate *G__Lderived;
14204      G__Lderived=(ROOT::Math::VavilovAccurate*)0x1000;
14205      {
14206        ROOT::Math::Vavilov *G__Lpbase=(ROOT::Math::Vavilov*)G__Lderived;
14207        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov),(long)G__Lpbase-(long)G__Lderived,1,1);
14208      }
14209    }
14210    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf))) {
14211      ROOT::Math::VavilovAccuratePdf *G__Lderived;
14212      G__Lderived=(ROOT::Math::VavilovAccuratePdf*)0x1000;
14213      {
14214        ROOT::Math::IParametricFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricFunctionOneDim*)G__Lderived;
14215        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
14216      }
14217      {
14218        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),(long)G__2vbo_ROOTcLcLMathcLcLVavilovAccuratePdf_ROOTcLcLMathcLcLIBaseFunctionOneDim_1,1,2);
14219      }
14220      {
14221        ROOT::Math::IBaseParam *G__Lpbase=(ROOT::Math::IBaseParam*)G__Lderived;
14222        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam),(long)G__Lpbase-(long)G__Lderived,1,0);
14223      }
14224    }
14225    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf))) {
14226      ROOT::Math::VavilovAccurateCdf *G__Lderived;
14227      G__Lderived=(ROOT::Math::VavilovAccurateCdf*)0x1000;
14228      {
14229        ROOT::Math::IParametricFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricFunctionOneDim*)G__Lderived;
14230        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
14231      }
14232      {
14233        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),(long)G__2vbo_ROOTcLcLMathcLcLVavilovAccurateCdf_ROOTcLcLMathcLcLIBaseFunctionOneDim_1,1,2);
14234      }
14235      {
14236        ROOT::Math::IBaseParam *G__Lpbase=(ROOT::Math::IBaseParam*)G__Lderived;
14237        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam),(long)G__Lpbase-(long)G__Lderived,1,0);
14238      }
14239    }
14240    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile))) {
14241      ROOT::Math::VavilovAccurateQuantile *G__Lderived;
14242      G__Lderived=(ROOT::Math::VavilovAccurateQuantile*)0x1000;
14243      {
14244        ROOT::Math::IParametricFunctionOneDim *G__Lpbase=(ROOT::Math::IParametricFunctionOneDim*)G__Lderived;
14245        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),(long)G__Lpbase-(long)G__Lderived,1,1);
14246      }
14247      {
14248        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),(long)G__2vbo_ROOTcLcLMathcLcLVavilovAccurateQuantile_ROOTcLcLMathcLcLIBaseFunctionOneDim_1,1,2);
14249      }
14250      {
14251        ROOT::Math::IBaseParam *G__Lpbase=(ROOT::Math::IBaseParam*)G__Lderived;
14252        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam),(long)G__Lpbase-(long)G__Lderived,1,0);
14253      }
14254    }
14255    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast))) {
14256      ROOT::Math::VavilovFast *G__Lderived;
14257      G__Lderived=(ROOT::Math::VavilovFast*)0x1000;
14258      {
14259        ROOT::Math::Vavilov *G__Lpbase=(ROOT::Math::Vavilov*)G__Lderived;
14260        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast),G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov),(long)G__Lpbase-(long)G__Lderived,1,1);
14261      }
14262    }
14263 }
14264 
14265 /*********************************************************
14266 * typedef information setup/
14267 *********************************************************/
14268 extern "C" void G__cpp_setup_typetableG__MathMore() {
14269 
14270    /* Setting up typedef entry */
14271    G__search_typename2("Short_t",115,-1,0,-1);
14272    G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
14273    G__search_typename2("Int_t",105,-1,0,-1);
14274    G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
14275    G__search_typename2("Version_t",115,-1,0,-1);
14276    G__setnewtype(-1,"Class version identifier (short)",0);
14277    G__search_typename2("VoidFuncPtr_t",89,-1,0,-1);
14278    G__setnewtype(-1,"pointer to void function",0);
14279    G__search_typename2("ShowMembersFunc_t",89,-1,0,-1);
14280    G__setnewtype(-1,"void (*ShowMembersFunc_t)(void *obj, TMemberInspector &R__insp);",0);
14281    G__search_typename2("NewFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
14282    G__setnewtype(-1,"void *(*NewFunc_t)(void *);",0);
14283    G__search_typename2("NewArrFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
14284    G__setnewtype(-1,"void *(*NewArrFunc_t)(Long_t size, void *arena);",0);
14285    G__search_typename2("DelFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
14286    G__setnewtype(-1,"void  (*DelFunc_t)(void *);",0);
14287    G__search_typename2("DelArrFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
14288    G__setnewtype(-1,"void  (*DelArrFunc_t)(void *);",0);
14289    G__search_typename2("DesFunc_t",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
14290    G__setnewtype(-1,"void  (*DesFunc_t)(void *);",0);
14291    G__search_typename2("DirAutoAdd_t",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
14292    G__setnewtype(-1,"void  (*DirAutoAdd_t)(void *, TDirectory*);",0);
14293    G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
14294    G__setnewtype(-1,NULL,0);
14295    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
14296    G__setnewtype(-1,NULL,0);
14297    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
14298    G__setnewtype(-1,NULL,0);
14299    G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
14300    G__setnewtype(-1,NULL,0);
14301    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
14302    G__setnewtype(-1,NULL,0);
14303    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
14304    G__setnewtype(-1,NULL,0);
14305    G__search_typename2("IGenFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14306    G__setnewtype(-1,NULL,0);
14307    G__search_typename2("IMultiGenFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14308    G__setnewtype(-1,NULL,0);
14309    G__search_typename2("IGradFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14310    G__setnewtype(-1,NULL,0);
14311    G__search_typename2("IMultiGradFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14312    G__setnewtype(-1,NULL,0);
14313    G__search_typename2("IParamFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14314    G__setnewtype(-1,NULL,0);
14315    G__search_typename2("IParamMultiFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14316    G__setnewtype(-1,NULL,0);
14317    G__search_typename2("IParamGradFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14318    G__setnewtype(-1,NULL,0);
14319    G__search_typename2("IParamMultiGradFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14320    G__setnewtype(-1,NULL,0);
14321    G__search_typename2("ParamFunction<IParamGradFunction>",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14322    G__setnewtype(-1,NULL,0);
14323    G__search_typename2("BaseParFunc",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR));
14324    G__setnewtype(-1,NULL,0);
14325    G__search_typename2("BaseFunc",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR));
14326    G__setnewtype(-1,NULL,0);
14327    G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
14328    G__setnewtype(-1,NULL,0);
14329    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
14330    G__setnewtype(-1,NULL,0);
14331    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
14332    G__setnewtype(-1,NULL,0);
14333    G__search_typename2("ParFunc",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
14334    G__setnewtype(-1,NULL,0);
14335    G__search_typename2("vector<std::complex<double> >",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR),0,-1);
14336    G__setnewtype(-1,NULL,0);
14337    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR));
14338    G__setnewtype(-1,NULL,0);
14339    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR));
14340    G__setnewtype(-1,NULL,0);
14341    G__search_typename2("vector<complex<double> >",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR),0,-1);
14342    G__setnewtype(-1,NULL,0);
14343    G__search_typename2("GSLFuncPointer",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator));
14344    G__setnewtype(-1,"double ( * GSLFuncPointer ) ( double, void * );",0);
14345    G__search_typename2("GSLFuncPointer",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14346    G__setnewtype(-1,"double ( * GSLFuncPointer ) ( double, void *);",0);
14347    G__search_typename2("GSLFuncPointer",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder));
14348    G__setnewtype(-1,"double ( * GSLFuncPointer ) ( double, void *);",0);
14349    G__search_typename2("GSLFuncPointer",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv));
14350    G__setnewtype(-1,"double ( * GSLFuncPointer ) ( double, void *);",0);
14351    G__search_typename2("GSLFdFPointer",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv));
14352    G__setnewtype(-1,"void ( * GSLFdFPointer ) ( double, void *, double *, double *);",0);
14353    G__search_typename2("Type",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDimcLcLType),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator));
14354    G__setnewtype(-1,NULL,0);
14355    G__search_typename2("GSLMonteFuncPointer",89,-1,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator));
14356    G__setnewtype(-1,"double ( * GSLMonteFuncPointer ) ( double *, size_t, void *);",0);
14357    G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
14358    G__setnewtype(-1,NULL,0);
14359    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
14360    G__setnewtype(-1,NULL,0);
14361    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
14362    G__setnewtype(-1,NULL,0);
14363    G__search_typename2("GSLRngRanLux1",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14364    G__setnewtype(-1,"for backward compatibility",0);
14365    G__search_typename2("GSLRngRanLux2",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14366    G__setnewtype(-1,"for backward compatibility",0);
14367    G__search_typename2("GSLRngRanLux48",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14368    G__setnewtype(-1,"for backward compatibility",0);
14369    G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
14370    G__setnewtype(-1,NULL,0);
14371    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR));
14372    G__setnewtype(-1,NULL,0);
14373    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR));
14374    G__setnewtype(-1,NULL,0);
14375    G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
14376    G__setnewtype(-1,NULL,0);
14377    G__search_typename2("vector<ROOT::Math::EMinimVariableType>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR),0,-1);
14378    G__setnewtype(-1,NULL,0);
14379    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR));
14380    G__setnewtype(-1,NULL,0);
14381    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR));
14382    G__setnewtype(-1,NULL,0);
14383    G__search_typename2("map<unsigned int,std::pair<double,double> >",117,G__get_linked_tagnum(&G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
14384    G__setnewtype(-1,NULL,0);
14385    G__search_typename2("map<unsigned int,pair<double,double> >",117,G__get_linked_tagnum(&G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
14386    G__setnewtype(-1,NULL,0);
14387    G__search_typename2("map<unsigned int,pair<double,double>,less<unsigned int> >",117,G__get_linked_tagnum(&G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
14388    G__setnewtype(-1,NULL,0);
14389    G__search_typename2("BasicFitMethodFunction<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14390    G__setnewtype(-1,NULL,0);
14391    G__search_typename2("FitMethodFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14392    G__setnewtype(-1,NULL,0);
14393    G__search_typename2("BasicFitMethodFunction<ROOT::Math::IMultiGradFunction>",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14394    G__setnewtype(-1,NULL,0);
14395    G__search_typename2("FitMethodGradFunction",117,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14396    G__setnewtype(-1,NULL,0);
14397    G__search_typename2("vector<LSResidualFunc>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR),0,-1);
14398    G__setnewtype(-1,NULL,0);
14399    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR));
14400    G__setnewtype(-1,NULL,0);
14401    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR));
14402    G__setnewtype(-1,NULL,0);
14403    G__search_typename2("vector<ROOT::Math::LSResidualFunc>",117,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR),0,-1);
14404    G__setnewtype(-1,NULL,0);
14405 }
14406 
14407 /*********************************************************
14408 * Data Member information setup/
14409 *********************************************************/
14410 
14411    /* Setting up class,struct,union tag member variable */
14412 
14413    /* ROOT */
14414 static void G__setup_memvarROOT(void) {
14415    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
14416    {
14417    }
14418    G__tag_memvar_reset();
14419 }
14420 
14421 
14422    /* ROOT::Math */
14423 static void G__setup_memvarROOTcLcLMath(void) {
14424    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
14425    {
14426    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType),-1,-2,1,G__FastAllocString(2048).Format("kDefault=%lldLL",(long long)ROOT::Math::kDefault).data(),0,(char*)NULL);
14427    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType),-1,-2,1,G__FastAllocString(2048).Format("kFix=%lldLL",(long long)ROOT::Math::kFix).data(),0,(char*)NULL);
14428    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType),-1,-2,1,G__FastAllocString(2048).Format("kBounds=%lldLL",(long long)ROOT::Math::kBounds).data(),0,(char*)NULL);
14429    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType),-1,-2,1,G__FastAllocString(2048).Format("kLowBound=%lldLL",(long long)ROOT::Math::kLowBound).data(),0,(char*)NULL);
14430    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType),-1,-2,1,G__FastAllocString(2048).Format("kUpBound=%lldLL",(long long)ROOT::Math::kUpBound).data(),0,(char*)NULL);
14431    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kConjugateFR=%lldLL",(long long)ROOT::Math::kConjugateFR).data(),0,(char*)NULL);
14432    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kConjugatePR=%lldLL",(long long)ROOT::Math::kConjugatePR).data(),0,(char*)NULL);
14433    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kVectorBFGS=%lldLL",(long long)ROOT::Math::kVectorBFGS).data(),0,(char*)NULL);
14434    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kVectorBFGS2=%lldLL",(long long)ROOT::Math::kVectorBFGS2).data(),0,(char*)NULL);
14435    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kSteepestDescent=%lldLL",(long long)ROOT::Math::kSteepestDescent).data(),0,(char*)NULL);
14436    }
14437    G__tag_memvar_reset();
14438 }
14439 
14440 
14441    /* ROOT::MathMore */
14442 static void G__setup_memvarROOTcLcLMathMore(void) {
14443    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathMore));
14444    {
14445    }
14446    G__tag_memvar_reset();
14447 }
14448 
14449 
14450    /* ROOT::Math::Polynomial */
14451 static void G__setup_memvarROOTcLcLMathcLcLPolynomial(void) {
14452    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
14453    { ROOT::Math::Polynomial *p; p=(ROOT::Math::Polynomial*)0x1000; if (p) { }
14454    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fOrder=",0,(char*)NULL);
14455    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fDerived_params=",0,(char*)NULL);
14456    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR),G__defined_typename("vector<std::complex<double> >"),-1,4,"fRoots=",0,(char*)NULL);
14457    }
14458    G__tag_memvar_reset();
14459 }
14460 
14461 
14462    /* ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> */
14463 static void G__setup_memvarROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void) {
14464    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR));
14465    { ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> *p; p=(ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>*)0x1000; if (p) { }
14466    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNpar=",0,(char*)NULL);
14467    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fParams=",0,(char*)NULL);
14468    }
14469    G__tag_memvar_reset();
14470 }
14471 
14472 
14473    /* ROOT::Math::Derivator */
14474 static void G__setup_memvarROOTcLcLMathcLcLDerivator(void) {
14475    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator));
14476    { ROOT::Math::Derivator *p; p=(ROOT::Math::Derivator*)0x1000; if (p) { }
14477    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14478    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLDerivator),-1,-1,4,"fDerivator=",0,(char*)NULL);
14479    }
14480    G__tag_memvar_reset();
14481 }
14482 
14483 
14484    /* ROOT::Math::Interpolator */
14485 static void G__setup_memvarROOTcLcLMathcLcLInterpolator(void) {
14486    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator));
14487    { ROOT::Math::Interpolator *p; p=(ROOT::Math::Interpolator*)0x1000; if (p) { }
14488    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14489    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLInterpolator),-1,-1,4,"fInterp=",0,"pointer to GSL interpolator class");
14490    }
14491    G__tag_memvar_reset();
14492 }
14493 
14494 
14495    /* ROOT::Math::GSLRootFinder */
14496 static void G__setup_memvarROOTcLcLMathcLcLGSLRootFinder(void) {
14497    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder));
14498    { ROOT::Math::GSLRootFinder *p; p=(ROOT::Math::GSLRootFinder*)0x1000; if (p) { }
14499    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionWrapper),-1,-1,4,"fFunction=",0,(char*)NULL);
14500    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFSolver),-1,-1,4,"fS=",0,(char*)NULL);
14501    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fRoot=",0,(char*)NULL);
14502    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fXlow=",0,(char*)NULL);
14503    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fXup=",0,(char*)NULL);
14504    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fIter=",0,(char*)NULL);
14505    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatus=",0,(char*)NULL);
14506    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fValidInterval=",0,(char*)NULL);
14507    }
14508    G__tag_memvar_reset();
14509 }
14510 
14511 
14512    /* ROOT::Math::GSLRootFinderDeriv */
14513 static void G__setup_memvarROOTcLcLMathcLcLGSLRootFinderDeriv(void) {
14514    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv));
14515    { ROOT::Math::GSLRootFinderDeriv *p; p=(ROOT::Math::GSLRootFinderDeriv*)0x1000; if (p) { }
14516    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionDerivWrapper),-1,-1,4,"fFunction=",0,(char*)NULL);
14517    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFdFSolver),-1,-1,4,"fS=",0,(char*)NULL);
14518    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fRoot=",0,(char*)NULL);
14519    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fPrevRoot=",0,(char*)NULL);
14520    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fIter=",0,(char*)NULL);
14521    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatus=",0,(char*)NULL);
14522    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fValidPoint=",0,(char*)NULL);
14523    }
14524    G__tag_memvar_reset();
14525 }
14526 
14527 
14528    /* ROOT::Math::Roots */
14529 static void G__setup_memvarROOTcLcLMathcLcLRoots(void) {
14530    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRoots));
14531    {
14532    }
14533    G__tag_memvar_reset();
14534 }
14535 
14536 
14537    /* ROOT::Math::Roots::Bisection */
14538 static void G__setup_memvarROOTcLcLMathcLcLRootscLcLBisection(void) {
14539    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection));
14540    { ROOT::Math::Roots::Bisection *p; p=(ROOT::Math::Roots::Bisection*)0x1000; if (p) { }
14541    }
14542    G__tag_memvar_reset();
14543 }
14544 
14545 
14546    /* ROOT::Math::Roots::FalsePos */
14547 static void G__setup_memvarROOTcLcLMathcLcLRootscLcLFalsePos(void) {
14548    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos));
14549    { ROOT::Math::Roots::FalsePos *p; p=(ROOT::Math::Roots::FalsePos*)0x1000; if (p) { }
14550    }
14551    G__tag_memvar_reset();
14552 }
14553 
14554 
14555    /* ROOT::Math::Roots::Brent */
14556 static void G__setup_memvarROOTcLcLMathcLcLRootscLcLBrent(void) {
14557    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent));
14558    { ROOT::Math::Roots::Brent *p; p=(ROOT::Math::Roots::Brent*)0x1000; if (p) { }
14559    }
14560    G__tag_memvar_reset();
14561 }
14562 
14563 
14564    /* ROOT::Math::Roots::Newton */
14565 static void G__setup_memvarROOTcLcLMathcLcLRootscLcLNewton(void) {
14566    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton));
14567    { ROOT::Math::Roots::Newton *p; p=(ROOT::Math::Roots::Newton*)0x1000; if (p) { }
14568    }
14569    G__tag_memvar_reset();
14570 }
14571 
14572 
14573    /* ROOT::Math::Roots::Secant */
14574 static void G__setup_memvarROOTcLcLMathcLcLRootscLcLSecant(void) {
14575    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant));
14576    { ROOT::Math::Roots::Secant *p; p=(ROOT::Math::Roots::Secant*)0x1000; if (p) { }
14577    }
14578    G__tag_memvar_reset();
14579 }
14580 
14581 
14582    /* ROOT::Math::Roots::Steffenson */
14583 static void G__setup_memvarROOTcLcLMathcLcLRootscLcLSteffenson(void) {
14584    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson));
14585    { ROOT::Math::Roots::Steffenson *p; p=(ROOT::Math::Roots::Steffenson*)0x1000; if (p) { }
14586    }
14587    G__tag_memvar_reset();
14588 }
14589 
14590 
14591    /* ROOT::Math::Integration */
14592 static void G__setup_memvarROOTcLcLMathcLcLIntegration(void) {
14593    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegration));
14594    {
14595    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule),-1,-2,1,G__FastAllocString(2048).Format("kGAUSS15=%lldLL",(long long)ROOT::Math::Integration::kGAUSS15).data(),0,(char*)NULL);
14596    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule),-1,-2,1,G__FastAllocString(2048).Format("kGAUSS21=%lldLL",(long long)ROOT::Math::Integration::kGAUSS21).data(),0,(char*)NULL);
14597    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule),-1,-2,1,G__FastAllocString(2048).Format("kGAUSS31=%lldLL",(long long)ROOT::Math::Integration::kGAUSS31).data(),0,(char*)NULL);
14598    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule),-1,-2,1,G__FastAllocString(2048).Format("kGAUSS41=%lldLL",(long long)ROOT::Math::Integration::kGAUSS41).data(),0,(char*)NULL);
14599    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule),-1,-2,1,G__FastAllocString(2048).Format("kGAUSS51=%lldLL",(long long)ROOT::Math::Integration::kGAUSS51).data(),0,(char*)NULL);
14600    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule),-1,-2,1,G__FastAllocString(2048).Format("kGAUSS61=%lldLL",(long long)ROOT::Math::Integration::kGAUSS61).data(),0,(char*)NULL);
14601    }
14602    G__tag_memvar_reset();
14603 }
14604 
14605 
14606    /* ROOT::Math::GSLIntegrator */
14607 static void G__setup_memvarROOTcLcLMathcLcLGSLIntegrator(void) {
14608    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator));
14609    { ROOT::Math::GSLIntegrator *p; p=(ROOT::Math::GSLIntegrator*)0x1000; if (p) { }
14610    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDimcLcLType),-1,-1,4,"fType=",0,(char*)NULL);
14611    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule),-1,-1,4,"fRule=",0,(char*)NULL);
14612    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fAbsTol=",0,(char*)NULL);
14613    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fRelTol=",0,(char*)NULL);
14614    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("size_t"),-1,4,"fSize=",0,(char*)NULL);
14615    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("size_t"),-1,4,"fMaxIntervals=",0,(char*)NULL);
14616    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fResult=",0,(char*)NULL);
14617    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fError=",0,(char*)NULL);
14618    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatus=",0,(char*)NULL);
14619    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fNEval=",0,(char*)NULL);
14620    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionWrapper),-1,-1,4,"fFunction=",0,(char*)NULL);
14621    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrationWorkspace),-1,-1,4,"fWorkspace=",0,(char*)NULL);
14622    }
14623    G__tag_memvar_reset();
14624 }
14625 
14626 
14627    /* ROOT::Math::VegasParameters */
14628 static void G__setup_memvarROOTcLcLMathcLcLVegasParameters(void) {
14629    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters));
14630    { ROOT::Math::VegasParameters *p; p=(ROOT::Math::VegasParameters*)0x1000; if (p) { }
14631    G__memvar_setup((void*)((long)(&p->alpha)-(long)(p)),100,0,0,-1,-1,-1,1,"alpha=",0,(char*)NULL);
14632    G__memvar_setup((void*)((long)(&p->iterations)-(long)(p)),104,0,0,-1,G__defined_typename("size_t"),-1,1,"iterations=",0,(char*)NULL);
14633    G__memvar_setup((void*)((long)(&p->stage)-(long)(p)),105,0,0,-1,-1,-1,1,"stage=",0,(char*)NULL);
14634    G__memvar_setup((void*)((long)(&p->mode)-(long)(p)),105,0,0,-1,-1,-1,1,"mode=",0,(char*)NULL);
14635    G__memvar_setup((void*)((long)(&p->verbose)-(long)(p)),105,0,0,-1,-1,-1,1,"verbose=",0,(char*)NULL);
14636    }
14637    G__tag_memvar_reset();
14638 }
14639 
14640 
14641    /* ROOT::Math::MiserParameters */
14642 static void G__setup_memvarROOTcLcLMathcLcLMiserParameters(void) {
14643    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters));
14644    { ROOT::Math::MiserParameters *p; p=(ROOT::Math::MiserParameters*)0x1000; if (p) { }
14645    G__memvar_setup((void*)((long)(&p->estimate_frac)-(long)(p)),100,0,0,-1,-1,-1,1,"estimate_frac=",0,(char*)NULL);
14646    G__memvar_setup((void*)((long)(&p->min_calls)-(long)(p)),104,0,0,-1,G__defined_typename("size_t"),-1,1,"min_calls=",0,(char*)NULL);
14647    G__memvar_setup((void*)((long)(&p->min_calls_per_bisection)-(long)(p)),104,0,0,-1,G__defined_typename("size_t"),-1,1,"min_calls_per_bisection=",0,(char*)NULL);
14648    G__memvar_setup((void*)((long)(&p->alpha)-(long)(p)),100,0,0,-1,-1,-1,1,"alpha=",0,(char*)NULL);
14649    G__memvar_setup((void*)((long)(&p->dither)-(long)(p)),100,0,0,-1,-1,-1,1,"dither=",0,(char*)NULL);
14650    }
14651    G__tag_memvar_reset();
14652 }
14653 
14654 
14655    /* ROOT::Math::GSLMCIntegrator */
14656 static void G__setup_memvarROOTcLcLMathcLcLGSLMCIntegrator(void) {
14657    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator));
14658    { ROOT::Math::GSLMCIntegrator *p; p=(ROOT::Math::GSLMCIntegrator*)0x1000; if (p) { }
14659    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDimcLcLType),-1,-1,4,"fType=",0,(char*)NULL);
14660    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngWrapper),-1,-1,4,"fRng=",0,(char*)NULL);
14661    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,(char*)NULL);
14662    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fCalls=",0,(char*)NULL);
14663    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fAbsTol=",0,(char*)NULL);
14664    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fRelTol=",0,(char*)NULL);
14665    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fResult=",0,(char*)NULL);
14666    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fError=",0,(char*)NULL);
14667    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatus=",0,(char*)NULL);
14668    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrationWorkspace),-1,-1,4,"fWorkspace=",0,(char*)NULL);
14669    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMonteFunctionWrapper),-1,-1,4,"fFunction=",0,(char*)NULL);
14670    }
14671    G__tag_memvar_reset();
14672 }
14673 
14674 
14675    /* ROOT::Math::Minim1D */
14676 static void G__setup_memvarROOTcLcLMathcLcLMinim1D(void) {
14677    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1D));
14678    {
14679    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1DcLcLType),-1,-2,1,G__FastAllocString(2048).Format("kGOLDENSECTION=%lldLL",(long long)ROOT::Math::Minim1D::kGOLDENSECTION).data(),0,(char*)NULL);
14680    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1DcLcLType),-1,-2,1,G__FastAllocString(2048).Format("kBRENT=%lldLL",(long long)ROOT::Math::Minim1D::kBRENT).data(),0,(char*)NULL);
14681    }
14682    G__tag_memvar_reset();
14683 }
14684 
14685 
14686    /* ROOT::Math::GSLMinimizer1D */
14687 static void G__setup_memvarROOTcLcLMathcLcLGSLMinimizer1D(void) {
14688    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D));
14689    { ROOT::Math::GSLMinimizer1D *p; p=(ROOT::Math::GSLMinimizer1D*)0x1000; if (p) { }
14690    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fXmin=",0,(char*)NULL);
14691    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fXlow=",0,(char*)NULL);
14692    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fXup=",0,(char*)NULL);
14693    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fMin=",0,(char*)NULL);
14694    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLow=",0,(char*)NULL);
14695    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fUp=",0,(char*)NULL);
14696    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fIter=",0,(char*)NULL);
14697    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStatus=",0,"status of last minimization (==0 ok =1 failed)");
14698    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fIsSet=",0,(char*)NULL);
14699    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSL1DMinimizerWrapper),-1,-1,4,"fMinimizer=",0,(char*)NULL);
14700    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionWrapper),-1,-1,4,"fFunction=",0,(char*)NULL);
14701    }
14702    G__tag_memvar_reset();
14703 }
14704 
14705 
14706    /* ROOT::Math::Chebyshev */
14707 static void G__setup_memvarROOTcLcLMathcLcLChebyshev(void) {
14708    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev));
14709    { ROOT::Math::Chebyshev *p; p=(ROOT::Math::Chebyshev*)0x1000; if (p) { }
14710    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14711    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("size_t"),-1,4,"fOrder=",0,(char*)NULL);
14712    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLChebSeries),-1,-1,4,"fSeries=",0,(char*)NULL);
14713    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionWrapper),-1,-1,4,"fFunction=",0,"pointer to function");
14714    }
14715    G__tag_memvar_reset();
14716 }
14717 
14718 
14719    /* ROOT::Math::GSLRandomEngine */
14720 static void G__setup_memvarROOTcLcLMathcLcLGSLRandomEngine(void) {
14721    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine));
14722    { ROOT::Math::GSLRandomEngine *p; p=(ROOT::Math::GSLRandomEngine*)0x1000; if (p) { }
14723    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14724    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngWrapper),-1,-1,4,"fRng=",0,"pointer to GSL generator wrapper (managed by the class)");
14725    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fCurTime=",0,"current time used to seed the generator");
14726    }
14727    G__tag_memvar_reset();
14728 }
14729 
14730 
14731    /* ROOT::Math::GSLRngMT */
14732 static void G__setup_memvarROOTcLcLMathcLcLGSLRngMT(void) {
14733    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT));
14734    { ROOT::Math::GSLRngMT *p; p=(ROOT::Math::GSLRngMT*)0x1000; if (p) { }
14735    }
14736    G__tag_memvar_reset();
14737 }
14738 
14739 
14740    /* ROOT::Math::GSLRngRanLux */
14741 static void G__setup_memvarROOTcLcLMathcLcLGSLRngRanLux(void) {
14742    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux));
14743    { ROOT::Math::GSLRngRanLux *p; p=(ROOT::Math::GSLRngRanLux*)0x1000; if (p) { }
14744    }
14745    G__tag_memvar_reset();
14746 }
14747 
14748 
14749    /* ROOT::Math::GSLRngRanLuxS1 */
14750 static void G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxS1(void) {
14751    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1));
14752    { ROOT::Math::GSLRngRanLuxS1 *p; p=(ROOT::Math::GSLRngRanLuxS1*)0x1000; if (p) { }
14753    }
14754    G__tag_memvar_reset();
14755 }
14756 
14757 
14758    /* ROOT::Math::GSLRngRanLuxS2 */
14759 static void G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxS2(void) {
14760    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2));
14761    { ROOT::Math::GSLRngRanLuxS2 *p; p=(ROOT::Math::GSLRngRanLuxS2*)0x1000; if (p) { }
14762    }
14763    G__tag_memvar_reset();
14764 }
14765 
14766 
14767    /* ROOT::Math::GSLRngRanLuxD1 */
14768 static void G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxD1(void) {
14769    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1));
14770    { ROOT::Math::GSLRngRanLuxD1 *p; p=(ROOT::Math::GSLRngRanLuxD1*)0x1000; if (p) { }
14771    }
14772    G__tag_memvar_reset();
14773 }
14774 
14775 
14776    /* ROOT::Math::GSLRngRanLuxD2 */
14777 static void G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxD2(void) {
14778    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2));
14779    { ROOT::Math::GSLRngRanLuxD2 *p; p=(ROOT::Math::GSLRngRanLuxD2*)0x1000; if (p) { }
14780    }
14781    G__tag_memvar_reset();
14782 }
14783 
14784 
14785    /* ROOT::Math::GSLRngTaus */
14786 static void G__setup_memvarROOTcLcLMathcLcLGSLRngTaus(void) {
14787    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus));
14788    { ROOT::Math::GSLRngTaus *p; p=(ROOT::Math::GSLRngTaus*)0x1000; if (p) { }
14789    }
14790    G__tag_memvar_reset();
14791 }
14792 
14793 
14794    /* ROOT::Math::GSLRngGFSR4 */
14795 static void G__setup_memvarROOTcLcLMathcLcLGSLRngGFSR4(void) {
14796    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4));
14797    { ROOT::Math::GSLRngGFSR4 *p; p=(ROOT::Math::GSLRngGFSR4*)0x1000; if (p) { }
14798    }
14799    G__tag_memvar_reset();
14800 }
14801 
14802 
14803    /* ROOT::Math::KelvinFunctions */
14804 static void G__setup_memvarROOTcLcLMathcLcLKelvinFunctions(void) {
14805    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions));
14806    { ROOT::Math::KelvinFunctions *p; p=(ROOT::Math::KelvinFunctions*)0x1000; if (p) { }
14807    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14808    G__memvar_setup((void*)0,100,0,0,-1,-1,-2,2,"fgMin=",0,(char*)NULL);
14809    G__memvar_setup((void*)0,100,0,0,-1,-1,-2,2,"fgEpsilon=",0,(char*)NULL);
14810    }
14811    G__tag_memvar_reset();
14812 }
14813 
14814 
14815    /* ROOT::Math::GSLMinimizer */
14816 static void G__setup_memvarROOTcLcLMathcLcLGSLMinimizer(void) {
14817    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer));
14818    { ROOT::Math::GSLMinimizer *p; p=(ROOT::Math::GSLMinimizer*)0x1000; if (p) { }
14819    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,(char*)NULL);
14820    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiMinimizer),-1,-1,4,"fGSLMultiMin=",0,(char*)NULL);
14821    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),G__defined_typename("IMultiGradFunction"),-1,4,"fObjFunc=",0,(char*)NULL);
14822    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fMinVal=",0,(char*)NULL);
14823    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLSTolerance=",0,"Line Search Tolerance");
14824    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fValues=",0,(char*)NULL);
14825    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fSteps=",0,(char*)NULL);
14826    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,4,"fNames=",0,(char*)NULL);
14827    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR),G__defined_typename("vector<ROOT::Math::EMinimVariableType>"),-1,4,"fVarTypes=",0,"vector specifyng the type of variables");
14828    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),G__defined_typename("map<unsigned int,std::pair<double,double> >"),-1,4,"fBounds=",0,"map specifying the bound using as key the parameter index");
14829    }
14830    G__tag_memvar_reset();
14831 }
14832 
14833 
14834    /* ROOT::Math::LSResidualFunc */
14835 static void G__setup_memvarROOTcLcLMathcLcLLSResidualFunc(void) {
14836    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc));
14837    { ROOT::Math::LSResidualFunc *p; p=(ROOT::Math::LSResidualFunc*)0x1000; if (p) { }
14838    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fIndex=",0,(char*)NULL);
14839    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__defined_typename("FitMethodFunction"),-1,4,"fChi2=",0,(char*)NULL);
14840    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fX2=",0,"cached vector");
14841    }
14842    G__tag_memvar_reset();
14843 }
14844 
14845 
14846    /* ROOT::Math::GSLNLSMinimizer */
14847 static void G__setup_memvarROOTcLcLMathcLcLGSLNLSMinimizer(void) {
14848    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer));
14849    { ROOT::Math::GSLNLSMinimizer *p; p=(ROOT::Math::GSLNLSMinimizer*)0x1000; if (p) { }
14850    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,"dimension of the function to be minimized ");
14851    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNFree=",0,"dimension of the internal function to be minimized ");
14852    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fSize=",0,"number of fit points (residuals)");
14853    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiFit),-1,-1,4,"fGSLMultiFit=",0,"pointer to GSL multi fit solver ");
14854    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__defined_typename("FitMethodFunction"),-1,4,"fObjFunc=",0,"pointer to Least square function");
14855    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fMinVal=",0,"minimum function value");
14856    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fEdm=",0,"edm value");
14857    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLSTolerance=",0,"Line Search Tolerance");
14858    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fValues=",0,(char*)NULL);
14859    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fErrors=",0,(char*)NULL);
14860    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCovMatrix=",0,"cov matrix (stored as cov[ i * dim + j] ");
14861    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fSteps=",0,(char*)NULL);
14862    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,4,"fNames=",0,(char*)NULL);
14863    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR),G__defined_typename("vector<LSResidualFunc>"),-1,4,"fResiduals=",0,"! transient Vector of the residual functions");
14864    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR),G__defined_typename("vector<ROOT::Math::EMinimVariableType>"),-1,4,"fVarTypes=",0,"vector specifyng the type of variables");
14865    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),G__defined_typename("map<unsigned int,std::pair<double,double> >"),-1,4,"fBounds=",0,"map specifying the bound using as key the parameter index");
14866    }
14867    G__tag_memvar_reset();
14868 }
14869 
14870 
14871    /* ROOT::Math::GSLSimAnFunc */
14872 static void G__setup_memvarROOTcLcLMathcLcLGSLSimAnFunc(void) {
14873    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc));
14874    { ROOT::Math::GSLSimAnFunc *p; p=(ROOT::Math::GSLSimAnFunc*)0x1000; if (p) { }
14875    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14876    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fX=",0,(char*)NULL);
14877    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fScale=",0,(char*)NULL);
14878    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),G__defined_typename("IMultiGenFunction"),-1,4,"fFunc=",0,(char*)NULL);
14879    }
14880    G__tag_memvar_reset();
14881 }
14882 
14883 
14884    /* ROOT::Math::GSLSimAnParams */
14885 static void G__setup_memvarROOTcLcLMathcLcLGSLSimAnParams(void) {
14886    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams));
14887    { ROOT::Math::GSLSimAnParams *p; p=(ROOT::Math::GSLSimAnParams*)0x1000; if (p) { }
14888    G__memvar_setup((void*)((long)(&p->n_tries)-(long)(p)),105,0,0,-1,-1,-1,1,"n_tries=",0,"number of points to try for each step");
14889    G__memvar_setup((void*)((long)(&p->iters_fixed_T)-(long)(p)),105,0,0,-1,-1,-1,1,"iters_fixed_T=",0,"number of iterations at each temperature");
14890    G__memvar_setup((void*)((long)(&p->step_size)-(long)(p)),100,0,0,-1,-1,-1,1,"step_size=",0,"max step size used in random walk");
14891    G__memvar_setup((void*)((long)(&p->k)-(long)(p)),100,0,0,-1,-1,-1,1,"k=",0,(char*)NULL);
14892    G__memvar_setup((void*)((long)(&p->t_initial)-(long)(p)),100,0,0,-1,-1,-1,1,"t_initial=",0,(char*)NULL);
14893    G__memvar_setup((void*)((long)(&p->mu)-(long)(p)),100,0,0,-1,-1,-1,1,"mu=",0,(char*)NULL);
14894    G__memvar_setup((void*)((long)(&p->t_min)-(long)(p)),100,0,0,-1,-1,-1,1,"t_min=",0,(char*)NULL);
14895    }
14896    G__tag_memvar_reset();
14897 }
14898 
14899 
14900    /* ROOT::Math::GSLSimAnnealing */
14901 static void G__setup_memvarROOTcLcLMathcLcLGSLSimAnnealing(void) {
14902    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing));
14903    { ROOT::Math::GSLSimAnnealing *p; p=(ROOT::Math::GSLSimAnnealing*)0x1000; if (p) { }
14904    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams),-1,-1,4,"fParams=",0,"parameters for GSLSimAnnealig");
14905    }
14906    G__tag_memvar_reset();
14907 }
14908 
14909 
14910    /* ROOT::Math::GSLSimAnMinimizer */
14911 static void G__setup_memvarROOTcLcLMathcLcLGSLSimAnMinimizer(void) {
14912    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer));
14913    { ROOT::Math::GSLSimAnMinimizer *p; p=(ROOT::Math::GSLSimAnMinimizer*)0x1000; if (p) { }
14914    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,"dimension of the function to be minimized ");
14915    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fOwnFunc=",0,"flag to indicate if objective function is managed ");
14916    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing),-1,-1,4,"fSolver=",0,(char*)NULL);
14917    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),G__defined_typename("IMultiGenFunction"),-1,4,"fObjFunc=",0,(char*)NULL);
14918    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fMinVal=",0,"minimum values ");
14919    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fValues=",0,(char*)NULL);
14920    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fSteps=",0,(char*)NULL);
14921    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,4,"fNames=",0,(char*)NULL);
14922    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR),G__defined_typename("vector<ROOT::Math::EMinimVariableType>"),-1,4,"fVarTypes=",0,"vector specifyng the type of variables");
14923    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),G__defined_typename("map<unsigned int,std::pair<double,double> >"),-1,4,"fBounds=",0,"map specifying the bound using as key the parameter index");
14924    }
14925    G__tag_memvar_reset();
14926 }
14927 
14928 
14929    /* ROOT::Math::Vavilov */
14930 static void G__setup_memvarROOTcLcLMathcLcLVavilov(void) {
14931    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov));
14932    { ROOT::Math::Vavilov *p; p=(ROOT::Math::Vavilov*)0x1000; if (p) { }
14933    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
14934    }
14935    G__tag_memvar_reset();
14936 }
14937 
14938 
14939    /* ROOT::Math::VavilovAccurate */
14940 static void G__setup_memvarROOTcLcLMathcLcLVavilovAccurate(void) {
14941    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate));
14942    { ROOT::Math::VavilovAccurate *p; p=(ROOT::Math::VavilovAccurate*)0x1000; if (p) { }
14943    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratecLcLdA),-1,-2,4,"MAXTERMS=500LL",0,(char*)NULL);
14944    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fH[8]=",0,(char*)NULL);
14945    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fT0=",0,(char*)NULL);
14946    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fT1=",0,(char*)NULL);
14947    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fT=",0,(char*)NULL);
14948    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fOmega=",0,(char*)NULL);
14949    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fA_pdf[501]=",0,(char*)NULL);
14950    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fB_pdf[501]=",0,(char*)NULL);
14951    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fA_cdf[501]=",0,(char*)NULL);
14952    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fB_cdf[501]=",0,(char*)NULL);
14953    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fX0=",0,(char*)NULL);
14954    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fKappa=",0,(char*)NULL);
14955    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fBeta2=",0,(char*)NULL);
14956    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fEpsilonPM=",0,(char*)NULL);
14957    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fEpsilon=",0,(char*)NULL);
14958    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fQuantileInit=",0,(char*)NULL);
14959    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fNQuant=",0,(char*)NULL);
14960    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratecLcLdA),-1,-2,4,"kNquantMax=32LL",0,(char*)NULL);
14961    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fQuant[32]=",0,(char*)NULL);
14962    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLambda[32]=",0,(char*)NULL);
14963    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate),-1,-2,4,"fgInstance=",0,(char*)NULL);
14964    }
14965    G__tag_memvar_reset();
14966 }
14967 
14968 
14969    /* ROOT::Math::VavilovAccuratePdf */
14970 static void G__setup_memvarROOTcLcLMathcLcLVavilovAccuratePdf(void) {
14971    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf));
14972    { ROOT::Math::VavilovAccuratePdf *p; p=(ROOT::Math::VavilovAccuratePdf*)0x1000; if (p) { }
14973    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fP[5]=",0,(char*)NULL);
14974    }
14975    G__tag_memvar_reset();
14976 }
14977 
14978 
14979    /* ROOT::Math::VavilovAccurateCdf */
14980 static void G__setup_memvarROOTcLcLMathcLcLVavilovAccurateCdf(void) {
14981    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf));
14982    { ROOT::Math::VavilovAccurateCdf *p; p=(ROOT::Math::VavilovAccurateCdf*)0x1000; if (p) { }
14983    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fP[5]=",0,(char*)NULL);
14984    }
14985    G__tag_memvar_reset();
14986 }
14987 
14988 
14989    /* ROOT::Math::VavilovAccurateQuantile */
14990 static void G__setup_memvarROOTcLcLMathcLcLVavilovAccurateQuantile(void) {
14991    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile));
14992    { ROOT::Math::VavilovAccurateQuantile *p; p=(ROOT::Math::VavilovAccurateQuantile*)0x1000; if (p) { }
14993    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fP[5]=",0,(char*)NULL);
14994    }
14995    G__tag_memvar_reset();
14996 }
14997 
14998 
14999    /* ROOT::Math::VavilovFast */
15000 static void G__setup_memvarROOTcLcLMathcLcLVavilovFast(void) {
15001    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast));
15002    { ROOT::Math::VavilovFast *p; p=(ROOT::Math::VavilovFast*)0x1000; if (p) { }
15003    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fKappa=",0,(char*)NULL);
15004    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fBeta2=",0,(char*)NULL);
15005    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fAC[14]=",0,(char*)NULL);
15006    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fHC[9]=",0,(char*)NULL);
15007    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fWCM[201]=",0,(char*)NULL);
15008    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fItype=",0,(char*)NULL);
15009    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fNpt=",0,(char*)NULL);
15010    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast),-1,-2,4,"fgInstance=",0,(char*)NULL);
15011    }
15012    G__tag_memvar_reset();
15013 }
15014 
15015 
15016    /* ROOT::Math::Random<ROOT::Math::GSLRngMT> */
15017 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void) {
15018    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR));
15019    { ROOT::Math::Random<ROOT::Math::GSLRngMT> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngMT>*)0x1000; if (p) { }
15020    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT),-1,-1,4,"fEngine=",0,(char*)NULL);
15021    }
15022    G__tag_memvar_reset();
15023 }
15024 
15025 
15026    /* ROOT::Math::Random<ROOT::Math::GSLRngTaus> */
15027 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void) {
15028    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR));
15029    { ROOT::Math::Random<ROOT::Math::GSLRngTaus> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngTaus>*)0x1000; if (p) { }
15030    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus),-1,-1,4,"fEngine=",0,(char*)NULL);
15031    }
15032    G__tag_memvar_reset();
15033 }
15034 
15035 
15036    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLux> */
15037 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void) {
15038    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR));
15039    { ROOT::Math::Random<ROOT::Math::GSLRngRanLux> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngRanLux>*)0x1000; if (p) { }
15040    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux),-1,-1,4,"fEngine=",0,(char*)NULL);
15041    }
15042    G__tag_memvar_reset();
15043 }
15044 
15045 
15046    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> */
15047 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void) {
15048    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR));
15049    { ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>*)0x1000; if (p) { }
15050    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1),-1,-1,4,"fEngine=",0,(char*)NULL);
15051    }
15052    G__tag_memvar_reset();
15053 }
15054 
15055 
15056    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> */
15057 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void) {
15058    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR));
15059    { ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>*)0x1000; if (p) { }
15060    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2),-1,-1,4,"fEngine=",0,(char*)NULL);
15061    }
15062    G__tag_memvar_reset();
15063 }
15064 
15065 
15066    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> */
15067 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void) {
15068    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR));
15069    { ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>*)0x1000; if (p) { }
15070    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1),-1,-1,4,"fEngine=",0,(char*)NULL);
15071    }
15072    G__tag_memvar_reset();
15073 }
15074 
15075 
15076    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> */
15077 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void) {
15078    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR));
15079    { ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>*)0x1000; if (p) { }
15080    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2),-1,-1,4,"fEngine=",0,(char*)NULL);
15081    }
15082    G__tag_memvar_reset();
15083 }
15084 
15085 
15086    /* ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> */
15087 static void G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void) {
15088    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR));
15089    { ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> *p; p=(ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>*)0x1000; if (p) { }
15090    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4),-1,-1,4,"fEngine=",0,(char*)NULL);
15091    }
15092    G__tag_memvar_reset();
15093 }
15094 
15095 extern "C" void G__cpp_setup_memvarG__MathMore() {
15096 }
15097 /***********************************************************
15098 ************************************************************
15099 ************************************************************
15100 ************************************************************
15101 ************************************************************
15102 ************************************************************
15103 ************************************************************
15104 ***********************************************************/
15105 
15106 /*********************************************************
15107 * Member function information setup for each class
15108 *********************************************************/
15109 static void G__setup_memfuncROOT(void) {
15110    /* ROOT */
15111    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOT));
15112    G__memfunc_setup("CreateClass",1098,G__G__MathMore_19_0_1, 85, G__get_linked_tagnum(&G__G__MathMoreLN_TClass), -1, 0, 9, 1, 1, 0, 
15113 "C - - 10 - cname s - 'Version_t' 0 - id "
15114 "u 'type_info' - 11 - info U 'TVirtualIsAProxy' - 0 - isa "
15115 "Y - 'ShowMembersFunc_t' 0 - show C - - 10 - dfil "
15116 "C - - 10 - ifil i - 'Int_t' 0 - dl "
15117 "i - 'Int_t' 0 - il", (char*)NULL, (void*) G__func2void( (TClass* (*)(const char*, Version_t, const type_info&, TVirtualIsAProxy*, ShowMembersFunc_t, const char*, const char*, Int_t, Int_t))(&ROOT::CreateClass) ), 0);
15118    G__memfunc_setup("AddClass",767,G__G__MathMore_19_0_2, 121, -1, -1, 0, 5, 1, 1, 0, 
15119 "C - - 10 - cname s - 'Version_t' 0 - id "
15120 "u 'type_info' - 11 - info Y - 'VoidFuncPtr_t' 0 - dict "
15121 "i - 'Int_t' 0 - pragmabits", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Version_t, const type_info&, VoidFuncPtr_t, Int_t))(&ROOT::AddClass) ), 0);
15122    G__memfunc_setup("RemoveClass",1124,G__G__MathMore_19_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - cname", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&ROOT::RemoveClass) ), 0);
15123    G__memfunc_setup("ResetClassVersion",1759,G__G__MathMore_19_0_4, 121, -1, -1, 0, 3, 1, 1, 0, 
15124 "U 'TClass' - 0 - - C - - 10 - - "
15125 "s - 'Short_t' 0 - -", (char*)NULL, (void*) G__func2void( (void (*)(TClass*, const char*, Short_t))(&ROOT::ResetClassVersion) ), 0);
15126    G__memfunc_setup("RegisterClassTemplate",2167,G__G__MathMore_19_0_5, 85, G__get_linked_tagnum(&G__G__MathMoreLN_TNamed), -1, 0, 3, 1, 1, 0, 
15127 "C - - 10 - name C - - 10 - file "
15128 "i - 'Int_t' 0 - line", (char*)NULL, (void*) G__func2void( (TNamed* (*)(const char*, const char*, Int_t))(&ROOT::RegisterClassTemplate) ), 0);
15129    G__memfunc_setup("DefineBehavior",1403,G__G__MathMore_19_0_6, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLTInitBehavior), -1, 0, 2, 1, 1, 1, 
15130 "Y - - 0 - - Y - - 0 - -", (char*)NULL, (void*) G__func2void( (const ROOT::TInitBehavior* (*)(void*, void*))(&ROOT::DefineBehavior) ), 0);
15131    G__tag_memfunc_reset();
15132 }
15133 
15134 static void G__setup_memfuncROOTcLcLMath(void) {
15135    /* ROOT::Math */
15136    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMath));
15137    G__memfunc_setup("noncentral_chisquared_pdf",2645,G__G__MathMore_99_0_1, 100, -1, -1, 0, 3, 1, 1, 0, 
15138 "d - - 0 - x d - - 0 - r "
15139 "d - - 0 - lambda", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::noncentral_chisquared_pdf) ), 0);
15140    G__memfunc_setup("tdistribution_quantile_c",2584,G__G__MathMore_99_0_2, 100, -1, -1, 0, 2, 1, 1, 0, 
15141 "d - - 0 - z d - - 0 - r", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::tdistribution_quantile_c) ), 0);
15142    G__memfunc_setup("tdistribution_quantile",2390,G__G__MathMore_99_0_3, 100, -1, -1, 0, 2, 1, 1, 0, 
15143 "d - - 0 - z d - - 0 - r", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::tdistribution_quantile) ), 0);
15144    G__memfunc_setup("assoc_laguerre",1487,G__G__MathMore_99_0_4, 100, -1, -1, 0, 3, 1, 1, 0, 
15145 "h - - 0 - - d - - 0 - m "
15146 "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, double, double))(&ROOT::Math::assoc_laguerre) ), 0);
15147    G__memfunc_setup("assoc_legendre",1470,G__G__MathMore_99_0_5, 100, -1, -1, 0, 3, 1, 1, 0, 
15148 "h - - 0 - - h - - 0 - - "
15149 "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, unsigned int, double))(&ROOT::Math::assoc_legendre) ), 0);
15150    G__memfunc_setup("comp_ellint_1",1318,G__G__MathMore_99_0_6, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - k", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::comp_ellint_1) ), 0);
15151    G__memfunc_setup("comp_ellint_2",1319,G__G__MathMore_99_0_7, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - k", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::comp_ellint_2) ), 0);
15152    G__memfunc_setup("comp_ellint_3",1320,G__G__MathMore_99_0_8, 100, -1, -1, 0, 2, 1, 1, 0, 
15153 "d - - 0 - n d - - 0 - k", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::comp_ellint_3) ), 0);
15154    G__memfunc_setup("conf_hyperg",1172,G__G__MathMore_99_0_9, 100, -1, -1, 0, 3, 1, 1, 0, 
15155 "d - - 0 - a d - - 0 - b "
15156 "d - - 0 - z", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::conf_hyperg) ), 0);
15157    G__memfunc_setup("conf_hypergU",1257,G__G__MathMore_99_0_10, 100, -1, -1, 0, 3, 1, 1, 0, 
15158 "d - - 0 - a d - - 0 - b "
15159 "d - - 0 - z", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::conf_hypergU) ), 0);
15160    G__memfunc_setup("cyl_bessel_i",1261,G__G__MathMore_99_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
15161 "d - - 0 - nu d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::cyl_bessel_i) ), 0);
15162    G__memfunc_setup("cyl_bessel_j",1262,G__G__MathMore_99_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
15163 "d - - 0 - nu d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::cyl_bessel_j) ), 0);
15164    G__memfunc_setup("cyl_bessel_k",1263,G__G__MathMore_99_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
15165 "d - - 0 - nu d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::cyl_bessel_k) ), 0);
15166    G__memfunc_setup("cyl_neumann",1177,G__G__MathMore_99_0_14, 100, -1, -1, 0, 2, 1, 1, 0, 
15167 "d - - 0 - nu d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::cyl_neumann) ), 0);
15168    G__memfunc_setup("ellint_1",792,G__G__MathMore_99_0_15, 100, -1, -1, 0, 2, 1, 1, 0, 
15169 "d - - 0 - k d - - 0 - phi", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::ellint_1) ), 0);
15170    G__memfunc_setup("ellint_2",793,G__G__MathMore_99_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
15171 "d - - 0 - k d - - 0 - phi", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::ellint_2) ), 0);
15172    G__memfunc_setup("ellint_3",794,G__G__MathMore_99_0_17, 100, -1, -1, 0, 3, 1, 1, 0, 
15173 "d - - 0 - n d - - 0 - k "
15174 "d - - 0 - phi", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::ellint_3) ), 0);
15175    G__memfunc_setup("expint",664,G__G__MathMore_99_0_18, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::expint) ), 0);
15176    G__memfunc_setup("hyperg",655,G__G__MathMore_99_0_19, 100, -1, -1, 0, 4, 1, 1, 0, 
15177 "d - - 0 - a d - - 0 - b "
15178 "d - - 0 - c d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double, double))(&ROOT::Math::hyperg) ), 0);
15179    G__memfunc_setup("laguerre",855,G__G__MathMore_99_0_20, 100, -1, -1, 0, 2, 1, 1, 0, 
15180 "h - - 0 - - d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, double))(&ROOT::Math::laguerre) ), 0);
15181    G__memfunc_setup("legendre",838,G__G__MathMore_99_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
15182 "h - - 0 - - d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, double))(&ROOT::Math::legendre) ), 0);
15183    G__memfunc_setup("riemann_zeta",1277,G__G__MathMore_99_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::riemann_zeta) ), 0);
15184    G__memfunc_setup("sph_bessel",1064,G__G__MathMore_99_0_23, 100, -1, -1, 0, 2, 1, 1, 0, 
15185 "h - - 0 - - d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, double))(&ROOT::Math::sph_bessel) ), 0);
15186    G__memfunc_setup("sph_legendre",1264,G__G__MathMore_99_0_24, 100, -1, -1, 0, 3, 1, 1, 0, 
15187 "h - - 0 - - h - - 0 - - "
15188 "d - - 0 - theta", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, unsigned int, double))(&ROOT::Math::sph_legendre) ), 0);
15189    G__memfunc_setup("sph_neumann",1180,G__G__MathMore_99_0_25, 100, -1, -1, 0, 2, 1, 1, 0, 
15190 "h - - 0 - - d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int, double))(&ROOT::Math::sph_neumann) ), 0);
15191    G__memfunc_setup("airy_Ai",702,G__G__MathMore_99_0_26, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::airy_Ai) ), 0);
15192    G__memfunc_setup("airy_Bi",703,G__G__MathMore_99_0_27, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::airy_Bi) ), 0);
15193    G__memfunc_setup("airy_Ai_deriv",1335,G__G__MathMore_99_0_28, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::airy_Ai_deriv) ), 0);
15194    G__memfunc_setup("airy_Bi_deriv",1336,G__G__MathMore_99_0_29, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::airy_Bi_deriv) ), 0);
15195    G__memfunc_setup("airy_zero_Ai",1245,G__G__MathMore_99_0_30, 100, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - s", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int))(&ROOT::Math::airy_zero_Ai) ), 0);
15196    G__memfunc_setup("airy_zero_Bi",1246,G__G__MathMore_99_0_31, 100, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - s", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int))(&ROOT::Math::airy_zero_Bi) ), 0);
15197    G__memfunc_setup("airy_zero_Ai_deriv",1878,G__G__MathMore_99_0_32, 100, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - s", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int))(&ROOT::Math::airy_zero_Ai_deriv) ), 0);
15198    G__memfunc_setup("airy_zero_Bi_deriv",1879,G__G__MathMore_99_0_33, 100, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - s", (char*)NULL, (void*) G__func2void( (double (*)(unsigned int))(&ROOT::Math::airy_zero_Bi_deriv) ), 0);
15199    G__memfunc_setup("wigner_3j",904,G__G__MathMore_99_0_34, 100, -1, -1, 0, 6, 1, 1, 0, 
15200 "i - - 0 - ja i - - 0 - jb "
15201 "i - - 0 - jc i - - 0 - ma "
15202 "i - - 0 - mb i - - 0 - mc", (char*)NULL, (void*) G__func2void( (double (*)(int, int, int, int, int, int))(&ROOT::Math::wigner_3j) ), 0);
15203    G__memfunc_setup("wigner_6j",907,G__G__MathMore_99_0_35, 100, -1, -1, 0, 6, 1, 1, 0, 
15204 "i - - 0 - ja i - - 0 - jb "
15205 "i - - 0 - jc i - - 0 - jd "
15206 "i - - 0 - je i - - 0 - jf", (char*)NULL, (void*) G__func2void( (double (*)(int, int, int, int, int, int))(&ROOT::Math::wigner_6j) ), 0);
15207    G__memfunc_setup("wigner_9j",910,G__G__MathMore_99_0_36, 100, -1, -1, 0, 9, 1, 1, 0, 
15208 "i - - 0 - ja i - - 0 - jb "
15209 "i - - 0 - jc i - - 0 - jd "
15210 "i - - 0 - je i - - 0 - jf "
15211 "i - - 0 - jg i - - 0 - jh "
15212 "i - - 0 - ji", (char*)NULL, (void*) G__func2void( (double (*)(int, int, int, int, int, int, int, int, int))(&ROOT::Math::wigner_9j) ), 0);
15213    G__memfunc_setup("vavilov_accurate_pdf",2119,G__G__MathMore_99_0_37, 100, -1, -1, 0, 3, 1, 1, 0, 
15214 "d - - 0 - x d - - 0 - kappa "
15215 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_accurate_pdf) ), 0);
15216    G__memfunc_setup("vavilov_accurate_cdf",2106,G__G__MathMore_99_0_38, 100, -1, -1, 0, 3, 1, 1, 0, 
15217 "d - - 0 - x d - - 0 - kappa "
15218 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_accurate_cdf) ), 0);
15219    G__memfunc_setup("vavilov_accurate_cdf_c",2300,G__G__MathMore_99_0_39, 100, -1, -1, 0, 3, 1, 1, 0, 
15220 "d - - 0 - x d - - 0 - kappa "
15221 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_accurate_cdf_c) ), 0);
15222    G__memfunc_setup("vavilov_accurate_quantile",2672,G__G__MathMore_99_0_40, 100, -1, -1, 0, 3, 1, 1, 0, 
15223 "d - - 0 - z d - - 0 - kappa "
15224 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_accurate_quantile) ), 0);
15225    G__memfunc_setup("vavilov_accurate_quantile_c",2866,G__G__MathMore_99_0_41, 100, -1, -1, 0, 3, 1, 1, 0, 
15226 "d - - 0 - z d - - 0 - kappa "
15227 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_accurate_quantile_c) ), 0);
15228    G__memfunc_setup("vavilov_fast_pdf",1709,G__G__MathMore_99_0_42, 100, -1, -1, 0, 3, 1, 1, 0, 
15229 "d - - 0 - x d - - 0 - kappa "
15230 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_fast_pdf) ), 0);
15231    G__memfunc_setup("vavilov_fast_cdf",1696,G__G__MathMore_99_0_43, 100, -1, -1, 0, 3, 1, 1, 0, 
15232 "d - - 0 - x d - - 0 - kappa "
15233 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_fast_cdf) ), 0);
15234    G__memfunc_setup("vavilov_fast_cdf_c",1890,G__G__MathMore_99_0_44, 100, -1, -1, 0, 3, 1, 1, 0, 
15235 "d - - 0 - x d - - 0 - kappa "
15236 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_fast_cdf_c) ), 0);
15237    G__memfunc_setup("vavilov_fast_quantile",2262,G__G__MathMore_99_0_45, 100, -1, -1, 0, 3, 1, 1, 0, 
15238 "d - - 0 - z d - - 0 - kappa "
15239 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_fast_quantile) ), 0);
15240    G__memfunc_setup("vavilov_fast_quantile_c",2456,G__G__MathMore_99_0_46, 100, -1, -1, 0, 3, 1, 1, 0, 
15241 "d - - 0 - z d - - 0 - kappa "
15242 "d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::Math::vavilov_fast_quantile_c) ), 0);
15243    G__tag_memfunc_reset();
15244 }
15245 
15246 static void G__setup_memfuncROOTcLcLMathMore(void) {
15247    /* ROOT::MathMore */
15248    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathMore));
15249    G__memfunc_setup("chisquared_quantile",2027,G__G__MathMore_100_0_1, 100, -1, -1, 0, 2, 1, 1, 0, 
15250 "d - - 0 - z d - - 0 - r", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::MathMore::chisquared_quantile) ), 0);
15251    G__memfunc_setup("gamma_quantile",1477,G__G__MathMore_100_0_2, 100, -1, -1, 0, 3, 1, 1, 0, 
15252 "d - - 0 - z d - - 0 - alpha "
15253 "d - - 0 - theta", (char*)NULL, (void*) G__func2void( (double (*)(double, double, double))(&ROOT::MathMore::gamma_quantile) ), 0);
15254    G__tag_memfunc_reset();
15255 }
15256 
15257 static void G__setup_memfuncROOTcLcLMathcLcLPolynomial(void) {
15258    /* ROOT::Math::Polynomial */
15259    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial));
15260    G__memfunc_setup("Polynomial",1060,G__G__MathMore_113_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial), -1, 0, 1, 1, 1, 0, "h - - 0 '0' n", (char*)NULL, (void*) NULL, 0);
15261    G__memfunc_setup("Polynomial",1060,G__G__MathMore_113_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial), -1, 0, 2, 1, 1, 0, 
15262 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15263    G__memfunc_setup("Polynomial",1060,G__G__MathMore_113_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial), -1, 0, 3, 1, 1, 0, 
15264 "d - - 0 - a d - - 0 - b "
15265 "d - - 0 - c", (char*)NULL, (void*) NULL, 0);
15266    G__memfunc_setup("Polynomial",1060,G__G__MathMore_113_0_4, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial), -1, 0, 4, 1, 1, 0, 
15267 "d - - 0 - a d - - 0 - b "
15268 "d - - 0 - c d - - 0 - d", (char*)NULL, (void*) NULL, 0);
15269    G__memfunc_setup("Polynomial",1060,G__G__MathMore_113_0_5, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial), -1, 0, 5, 1, 1, 0, 
15270 "d - - 0 - a d - - 0 - b "
15271 "d - - 0 - c d - - 0 - d "
15272 "d - - 0 - e", (char*)NULL, (void*) NULL, 0);
15273    G__memfunc_setup("FindRoots",920,G__G__MathMore_113_0_6, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR), G__defined_typename("vector<std::complex<double> >"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
15274    G__memfunc_setup("FindRealRoots",1308,G__G__MathMore_113_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15275    G__memfunc_setup("FindNumRoots",1224,G__G__MathMore_113_0_8, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR), G__defined_typename("vector<std::complex<double> >"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
15276    G__memfunc_setup("Order",508,G__G__MathMore_113_0_9, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15277    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim), G__defined_typename("ROOT::Math::IGenFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15278    G__memfunc_setup("FdF",240,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
15279 "d - - 0 - x d - - 1 - f "
15280 "d - - 1 - df", (char*)NULL, (void*) NULL, 1);
15281    G__memfunc_setup("DoEvalPar",862,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
15282 "d - - 0 - x D - - 10 - p", (char*)NULL, (void*) NULL, 1);
15283    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
15284    G__memfunc_setup("DoParameterDerivative",2151,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 3, 1, 4, 8, 
15285 "d - - 0 - x D - - 10 - p "
15286 "h - - 0 - ipar", (char*)NULL, (void*) NULL, 1);
15287    // automatic copy constructor
15288    G__memfunc_setup("Polynomial", 1060, G__G__MathMore_113_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Polynomial' - 11 - -", (char*) NULL, (void*) NULL, 0);
15289    // automatic destructor
15290    G__memfunc_setup("~Polynomial", 1186, G__G__MathMore_113_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15291    // automatic assignment operator
15292    G__memfunc_setup("operator=", 937, G__G__MathMore_113_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Polynomial' - 11 - -", (char*) NULL, (void*) NULL, 0);
15293    G__tag_memfunc_reset();
15294 }
15295 
15296 static void G__setup_memfuncROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR(void) {
15297    /* ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim> */
15298    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR));
15299    G__memfunc_setup("Parameters",1044,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15300    G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 1);
15301    G__memfunc_setup("NPar",369,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15302    // automatic destructor
15303    G__memfunc_setup("~ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>", 5430, G__G__MathMore_114_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15304    // automatic assignment operator
15305    G__memfunc_setup("operator=", 937, G__G__MathMore_114_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>' - 11 - -", (char*) NULL, (void*) NULL, 0);
15306    G__tag_memfunc_reset();
15307 }
15308 
15309 static void G__setup_memfuncROOTcLcLMathcLcLDerivator(void) {
15310    /* ROOT::Math::Derivator */
15311    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator));
15312    G__memfunc_setup("Derivator",944,G__G__MathMore_125_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15313    G__memfunc_setup("Derivator",944,G__G__MathMore_125_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f", (char*)NULL, (void*) NULL, 0);
15314    G__memfunc_setup("Derivator",944,G__G__MathMore_125_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator), -1, 0, 2, 5, 1, 0, 
15315 "Y - 'ROOT::Math::Derivator::GSLFuncPointer' 11 - f Y - - 0 '0' p", (char*)NULL, (void*) NULL, 0);
15316    G__memfunc_setup("Derivator",944,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Derivator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15317    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Derivator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15318    G__memfunc_setup("SetFunction",1138,G__G__MathMore_125_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f", (char*)NULL, (void*) NULL, 0);
15319    G__memfunc_setup("SetFunction",1138,G__G__MathMore_125_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
15320 "Y - 'ROOT::Math::Derivator::GSLFuncPointer' 11 - f Y - - 0 '0' p", (char*)NULL, (void*) NULL, 0);
15321    G__memfunc_setup("Eval",392,G__G__MathMore_125_0_8, 100, -1, -1, 0, 2, 1, 1, 8, 
15322 "d - - 0 - x d - - 0 '1E-8' h", (char*)NULL, (void*) NULL, 0);
15323    G__memfunc_setup("EvalCentral",1105,G__G__MathMore_125_0_9, 100, -1, -1, 0, 2, 1, 1, 8, 
15324 "d - - 0 - x d - - 0 '1E-8' h", (char*)NULL, (void*) NULL, 0);
15325    G__memfunc_setup("EvalForward",1117,G__G__MathMore_125_0_10, 100, -1, -1, 0, 2, 1, 1, 8, 
15326 "d - - 0 - x d - - 0 '1E-8' h", (char*)NULL, (void*) NULL, 0);
15327    G__memfunc_setup("EvalBackward",1191,G__G__MathMore_125_0_11, 100, -1, -1, 0, 2, 1, 1, 8, 
15328 "d - - 0 - x d - - 0 '1E-8' h", (char*)NULL, (void*) NULL, 0);
15329    G__memfunc_setup("Eval",392,G__G__MathMore_125_0_12, 100, -1, -1, 0, 3, 3, 1, 0, 
15330 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - x "
15331 "d - - 0 '1E-8' h", (char*)NULL, (void*) G__func2void( (double (*)(const ROOT::Math::IGenFunction&, double, double))(&ROOT::Math::Derivator::Eval) ), 0);
15332    G__memfunc_setup("EvalCentral",1105,G__G__MathMore_125_0_13, 100, -1, -1, 0, 3, 3, 1, 0, 
15333 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - x "
15334 "d - - 0 '1E-8' h", (char*)NULL, (void*) G__func2void( (double (*)(const ROOT::Math::IGenFunction&, double, double))(&ROOT::Math::Derivator::EvalCentral) ), 0);
15335    G__memfunc_setup("EvalForward",1117,G__G__MathMore_125_0_14, 100, -1, -1, 0, 3, 3, 1, 0, 
15336 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - x "
15337 "d - - 0 '1E-8' h", (char*)NULL, (void*) G__func2void( (double (*)(const ROOT::Math::IGenFunction&, double, double))(&ROOT::Math::Derivator::EvalForward) ), 0);
15338    G__memfunc_setup("EvalBackward",1191,G__G__MathMore_125_0_15, 100, -1, -1, 0, 3, 3, 1, 0, 
15339 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - x "
15340 "d - - 0 '1E-8' h", (char*)NULL, (void*) G__func2void( (double (*)(const ROOT::Math::IGenFunction&, double, double))(&ROOT::Math::Derivator::EvalBackward) ), 0);
15341    G__memfunc_setup("Eval",392,G__G__MathMore_125_0_16, 100, -1, -1, 0, 4, 3, 1, 0, 
15342 "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - f D - - 10 - x "
15343 "h - - 0 '0' icoord d - - 0 '1E-8' h", (char*)NULL, (void*) G__func2void( (double (*)(const ROOT::Math::IMultiGenFunction&, const double*, unsigned int, double))(&ROOT::Math::Derivator::Eval) ), 0);
15344    G__memfunc_setup("Eval",392,G__G__MathMore_125_0_17, 100, -1, -1, 0, 5, 3, 1, 0, 
15345 "u 'ROOT::Math::IParametricFunctionOneDim' 'ROOT::Math::IParamFunction' 1 - f d - - 0 - x "
15346 "D - - 10 - p h - - 0 '0' ipar "
15347 "d - - 0 '1E-8' h", (char*)NULL, (void*) G__func2void( (double (*)(ROOT::Math::IParamFunction&, double, const double*, unsigned int, double))(&ROOT::Math::Derivator::Eval) ), 0);
15348    G__memfunc_setup("Eval",392,G__G__MathMore_125_0_18, 100, -1, -1, 0, 5, 3, 1, 0, 
15349 "u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Math::IParamMultiFunction' 1 - f D - - 10 - x "
15350 "D - - 10 - p h - - 0 '0' ipar "
15351 "d - - 0 '1E-8' h", (char*)NULL, (void*) G__func2void( (double (*)(ROOT::Math::IParamMultiFunction&, const double*, const double*, unsigned int, double))(&ROOT::Math::Derivator::Eval) ), 0);
15352    G__memfunc_setup("Status",644,G__G__MathMore_125_0_19, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15353    G__memfunc_setup("Result",639,G__G__MathMore_125_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15354    G__memfunc_setup("Error",522,G__G__MathMore_125_0_21, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15355    // automatic destructor
15356    G__memfunc_setup("~Derivator", 1070, G__G__MathMore_125_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15357    G__tag_memfunc_reset();
15358 }
15359 
15360 static void G__setup_memfuncROOTcLcLMathcLcLInterpolator(void) {
15361    /* ROOT::Math::Interpolator */
15362    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator));
15363    G__memfunc_setup("Interpolator",1283,G__G__MathMore_129_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator), -1, 0, 2, 1, 1, 0, 
15364 "h - - 0 '0' ndata i 'ROOT::Math::Interpolation::Type' - 0 'Interpolation::kCSPLINE' type", (char*)NULL, (void*) NULL, 0);
15365    G__memfunc_setup("Interpolator",1283,G__G__MathMore_129_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator), -1, 0, 3, 1, 1, 0, 
15366 "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x u 'vector<double,allocator<double> >' 'vector<double>' 11 - y "
15367 "i 'ROOT::Math::Interpolation::Type' - 0 'Interpolation::kCSPLINE' type", (char*)NULL, (void*) NULL, 0);
15368    G__memfunc_setup("Interpolator",1283,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Interpolator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15369    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Interpolator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15370    G__memfunc_setup("SetData",678,G__G__MathMore_129_0_5, 103, -1, -1, 0, 2, 1, 1, 0, 
15371 "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x u 'vector<double,allocator<double> >' 'vector<double>' 11 - y", (char*)NULL, (void*) NULL, 0);
15372    G__memfunc_setup("SetData",678,G__G__MathMore_129_0_6, 103, -1, -1, 0, 3, 1, 1, 0, 
15373 "h - - 0 - ndata D - - 10 - x "
15374 "D - - 10 - y", (char*)NULL, (void*) NULL, 0);
15375    G__memfunc_setup("Eval",392,G__G__MathMore_129_0_7, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
15376    G__memfunc_setup("Deriv",506,G__G__MathMore_129_0_8, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
15377    G__memfunc_setup("Deriv2",556,G__G__MathMore_129_0_9, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
15378    G__memfunc_setup("Integ",503,G__G__MathMore_129_0_10, 100, -1, -1, 0, 2, 1, 1, 8, 
15379 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15380    G__memfunc_setup("Type",418,G__G__MathMore_129_0_11, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15381    G__memfunc_setup("TypeGet",706,G__G__MathMore_129_0_12, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15382    // automatic destructor
15383    G__memfunc_setup("~Interpolator", 1409, G__G__MathMore_129_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15384    G__tag_memfunc_reset();
15385 }
15386 
15387 static void G__setup_memfuncROOTcLcLMathcLcLGSLRootFinder(void) {
15388    /* ROOT::Math::GSLRootFinder */
15389    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder));
15390    G__memfunc_setup("GSLRootFinder",1250,G__G__MathMore_133_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15391    G__memfunc_setup("GSLRootFinder",1250,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLRootFinder' - 11 - -", (char*)NULL, (void*) NULL, 0);
15392    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLRootFinder' - 11 - -", (char*)NULL, (void*) NULL, 0);
15393    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,103, -1, -1, 0, 2, 1, 1, 0, 
15394 "u 'ROOT::Math::IGradientFunctionOneDim' 'ROOT::Math::IGradFunction' 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 1);
15395    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
15396 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - xlow "
15397 "d - - 0 - xup", (char*)NULL, (void*) NULL, 1);
15398    G__memfunc_setup("SetFunction",1138,G__G__MathMore_133_0_6, 103, -1, -1, 0, 4, 1, 1, 0, 
15399 "Y - 'ROOT::Math::GSLRootFinder::GSLFuncPointer' 0 - f Y - - 0 - params "
15400 "d - - 0 - xlow d - - 0 - xup", (char*)NULL, (void*) NULL, 0);
15401    G__memfunc_setup("Iterate",718,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15402    G__memfunc_setup("Root",420,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15403    G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
15404 "i - - 0 '100' maxIter d - - 0 '1E-8' absTol "
15405 "d - - 0 '1E-10' relTol", (char*)NULL, (void*) NULL, 1);
15406    G__memfunc_setup("Iterations",1058,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15407    G__memfunc_setup("Status",644,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15408    G__memfunc_setup("Name",385,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15409    G__memfunc_setup("SetSolver",935,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'ROOT::Math::GSLRootFSolver' - 0 - s", (char*)NULL, (void*) NULL, 0);
15410    G__memfunc_setup("FreeSolver",1021,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15411    // automatic destructor
15412    G__memfunc_setup("~GSLRootFinder", 1376, G__G__MathMore_133_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15413    G__tag_memfunc_reset();
15414 }
15415 
15416 static void G__setup_memfuncROOTcLcLMathcLcLGSLRootFinderDeriv(void) {
15417    /* ROOT::Math::GSLRootFinderDeriv */
15418    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv));
15419    G__memfunc_setup("GSLRootFinderDeriv",1756,G__G__MathMore_136_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15420    G__memfunc_setup("GSLRootFinderDeriv",1756,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLRootFinderDeriv' - 11 - -", (char*)NULL, (void*) NULL, 0);
15421    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLRootFinderDeriv' - 11 - -", (char*)NULL, (void*) NULL, 0);
15422    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
15423 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - - d - - 0 - - "
15424 "d - - 0 - -", (char*)NULL, (void*) NULL, 1);
15425    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,103, -1, -1, 0, 2, 1, 1, 0, 
15426 "u 'ROOT::Math::IGradientFunctionOneDim' 'ROOT::Math::IGradFunction' 11 - f d - - 0 - xstart", (char*)NULL, (void*) NULL, 1);
15427    G__memfunc_setup("SetFunction",1138,G__G__MathMore_136_0_6, 103, -1, -1, 0, 5, 1, 1, 0, 
15428 "Y - 'ROOT::Math::GSLRootFinderDeriv::GSLFuncPointer' 0 - f Y - 'ROOT::Math::GSLRootFinderDeriv::GSLFuncPointer' 0 - df "
15429 "Y - 'ROOT::Math::GSLRootFinderDeriv::GSLFdFPointer' 0 - fdf Y - - 0 - p "
15430 "d - - 0 - Root", (char*)NULL, (void*) NULL, 0);
15431    G__memfunc_setup("Iterate",718,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15432    G__memfunc_setup("Root",420,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15433    G__memfunc_setup("Solve",521,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
15434 "i - - 0 '100' maxIter d - - 0 '1E-8' absTol "
15435 "d - - 0 '1E-10' relTol", (char*)NULL, (void*) NULL, 1);
15436    G__memfunc_setup("Iterations",1058,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15437    G__memfunc_setup("Status",644,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15438    G__memfunc_setup("Name",385,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15439    G__memfunc_setup("SetSolver",935,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'ROOT::Math::GSLRootFdFSolver' - 0 - s", (char*)NULL, (void*) NULL, 0);
15440    G__memfunc_setup("FreeSolver",1021,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15441    // automatic destructor
15442    G__memfunc_setup("~GSLRootFinderDeriv", 1882, G__G__MathMore_136_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15443    G__tag_memfunc_reset();
15444 }
15445 
15446 static void G__setup_memfuncROOTcLcLMathcLcLRoots(void) {
15447    /* ROOT::Math::Roots */
15448    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRoots));
15449    G__tag_memfunc_reset();
15450 }
15451 
15452 static void G__setup_memfuncROOTcLcLMathcLcLRootscLcLBisection(void) {
15453    /* ROOT::Math::Roots::Bisection */
15454    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection));
15455    G__memfunc_setup("Bisection",928,G__G__MathMore_138_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15456    G__memfunc_setup("Bisection",928,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Bisection' - 11 - -", (char*)NULL, (void*) NULL, 0);
15457    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Bisection' - 11 - -", (char*)NULL, (void*) NULL, 0);
15458    // automatic destructor
15459    G__memfunc_setup("~Bisection", 1054, G__G__MathMore_138_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15460    G__tag_memfunc_reset();
15461 }
15462 
15463 static void G__setup_memfuncROOTcLcLMathcLcLRootscLcLFalsePos(void) {
15464    /* ROOT::Math::Roots::FalsePos */
15465    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos));
15466    G__memfunc_setup("FalsePos",797,G__G__MathMore_139_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15467    G__memfunc_setup("FalsePos",797,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Roots::FalsePos' - 11 - -", (char*)NULL, (void*) NULL, 0);
15468    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Roots::FalsePos' - 11 - -", (char*)NULL, (void*) NULL, 0);
15469    // automatic destructor
15470    G__memfunc_setup("~FalsePos", 923, G__G__MathMore_139_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15471    G__tag_memfunc_reset();
15472 }
15473 
15474 static void G__setup_memfuncROOTcLcLMathcLcLRootscLcLBrent(void) {
15475    /* ROOT::Math::Roots::Brent */
15476    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent));
15477    G__memfunc_setup("Brent",507,G__G__MathMore_140_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15478    G__memfunc_setup("Brent",507,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Brent' - 11 - -", (char*)NULL, (void*) NULL, 0);
15479    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Brent' - 11 - -", (char*)NULL, (void*) NULL, 0);
15480    // automatic destructor
15481    G__memfunc_setup("~Brent", 633, G__G__MathMore_140_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15482    G__tag_memfunc_reset();
15483 }
15484 
15485 static void G__setup_memfuncROOTcLcLMathcLcLRootscLcLNewton(void) {
15486    /* ROOT::Math::Roots::Newton */
15487    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton));
15488    G__memfunc_setup("Newton",635,G__G__MathMore_141_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15489    G__memfunc_setup("Newton",635,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Newton' - 11 - -", (char*)NULL, (void*) NULL, 0);
15490    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Newton' - 11 - -", (char*)NULL, (void*) NULL, 0);
15491    // automatic destructor
15492    G__memfunc_setup("~Newton", 761, G__G__MathMore_141_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15493    G__tag_memfunc_reset();
15494 }
15495 
15496 static void G__setup_memfuncROOTcLcLMathcLcLRootscLcLSecant(void) {
15497    /* ROOT::Math::Roots::Secant */
15498    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant));
15499    G__memfunc_setup("Secant",606,G__G__MathMore_142_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15500    G__memfunc_setup("Secant",606,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Secant' - 11 - -", (char*)NULL, (void*) NULL, 0);
15501    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Secant' - 11 - -", (char*)NULL, (void*) NULL, 0);
15502    // automatic destructor
15503    G__memfunc_setup("~Secant", 732, G__G__MathMore_142_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15504    G__tag_memfunc_reset();
15505 }
15506 
15507 static void G__setup_memfuncROOTcLcLMathcLcLRootscLcLSteffenson(void) {
15508    /* ROOT::Math::Roots::Steffenson */
15509    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson));
15510    G__memfunc_setup("Steffenson",1051,G__G__MathMore_143_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15511    G__memfunc_setup("Steffenson",1051,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Steffenson' - 11 - -", (char*)NULL, (void*) NULL, 0);
15512    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Roots::Steffenson' - 11 - -", (char*)NULL, (void*) NULL, 0);
15513    // automatic destructor
15514    G__memfunc_setup("~Steffenson", 1177, G__G__MathMore_143_0_4, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15515    G__tag_memfunc_reset();
15516 }
15517 
15518 static void G__setup_memfuncROOTcLcLMathcLcLIntegration(void) {
15519    /* ROOT::Math::Integration */
15520    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegration));
15521    G__tag_memfunc_reset();
15522 }
15523 
15524 static void G__setup_memfuncROOTcLcLMathcLcLGSLIntegrator(void) {
15525    /* ROOT::Math::GSLIntegrator */
15526    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator));
15527    G__memfunc_setup("GSLIntegrator",1285,G__G__MathMore_158_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator), -1, 0, 3, 1, 1, 0, 
15528 "d - - 0 '1.E-9' absTol d - - 0 '1E-6' relTol "
15529 "h - 'size_t' 0 '1000' size", (char*)NULL, (void*) NULL, 0);
15530    G__memfunc_setup("GSLIntegrator",1285,G__G__MathMore_158_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator), -1, 0, 4, 1, 1, 0, 
15531 "i 'ROOT::Math::IntegrationOneDim::Type' - 10 - type d - - 0 '1.E-9' absTol "
15532 "d - - 0 '1E-6' relTol h - 'size_t' 0 '1000' size", (char*)NULL, (void*) NULL, 0);
15533    G__memfunc_setup("GSLIntegrator",1285,G__G__MathMore_158_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator), -1, 0, 5, 1, 1, 0, 
15534 "i 'ROOT::Math::IntegrationOneDim::Type' - 10 - type i 'ROOT::Math::Integration::GKRule' - 10 - rule "
15535 "d - - 0 '1.E-9' absTol d - - 0 '1E-6' relTol "
15536 "h - 'size_t' 0 '1000' size", (char*)NULL, (void*) NULL, 0);
15537    G__memfunc_setup("GSLIntegrator",1285,G__G__MathMore_158_0_4, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator), -1, 0, 5, 1, 1, 0, 
15538 "C - - 10 - type i - - 0 - rule "
15539 "d - - 0 - absTol d - - 0 - relTol "
15540 "h - 'size_t' 0 - size", (char*)NULL, (void*) NULL, 0);
15541    G__memfunc_setup("GSLIntegrator",1285,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLIntegrator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15542    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLIntegrator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15543    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f", (char*)NULL, (void*) NULL, 1);
15544    G__memfunc_setup("SetFunction",1138,G__G__MathMore_158_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
15545 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 '0' p", (char*)NULL, (void*) NULL, 0);
15546    G__memfunc_setup("Integral",822,G__G__MathMore_158_0_9, 100, -1, -1, 0, 3, 1, 1, 0, 
15547 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - a "
15548 "d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15549    G__memfunc_setup("Integral",822,G__G__MathMore_158_0_10, 100, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f", (char*)NULL, (void*) NULL, 0);
15550    G__memfunc_setup("IntegralCauchy",1427,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
15551 "d - - 0 - a d - - 0 - b "
15552 "d - - 0 - c", (char*)NULL, (void*) NULL, 1);
15553    G__memfunc_setup("IntegralCauchy",1427,G__G__MathMore_158_0_12, 100, -1, -1, 0, 4, 1, 1, 0, 
15554 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - a "
15555 "d - - 0 - b d - - 0 - c", (char*)NULL, (void*) NULL, 0);
15556    G__memfunc_setup("IntegralUp",1019,G__G__MathMore_158_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
15557 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - a", (char*)NULL, (void*) NULL, 0);
15558    G__memfunc_setup("IntegralLow",1128,G__G__MathMore_158_0_14, 100, -1, -1, 0, 2, 1, 1, 0, 
15559 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15560    G__memfunc_setup("Integral",822,G__G__MathMore_158_0_15, 100, -1, -1, 0, 2, 1, 1, 0, 
15561 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f u 'vector<double,allocator<double> >' 'vector<double>' 11 - pts", (char*)NULL, (void*) NULL, 0);
15562    G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
15563 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 1);
15564    G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15565    G__memfunc_setup("IntegralUp",1019,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - a", (char*)NULL, (void*) NULL, 1);
15566    G__memfunc_setup("IntegralLow",1128,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - b", (char*)NULL, (void*) NULL, 1);
15567    G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - pts", (char*)NULL, (void*) NULL, 1);
15568    G__memfunc_setup("Integral",822,G__G__MathMore_158_0_21, 100, -1, -1, 0, 4, 1, 1, 0, 
15569 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - p "
15570 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15571    G__memfunc_setup("Integral",822,G__G__MathMore_158_0_22, 100, -1, -1, 0, 2, 1, 1, 0, 
15572 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - p", (char*)NULL, (void*) NULL, 0);
15573    G__memfunc_setup("IntegralUp",1019,G__G__MathMore_158_0_23, 100, -1, -1, 0, 3, 1, 1, 0, 
15574 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - p "
15575 "d - - 0 - a", (char*)NULL, (void*) NULL, 0);
15576    G__memfunc_setup("IntegralLow",1128,G__G__MathMore_158_0_24, 100, -1, -1, 0, 3, 1, 1, 0, 
15577 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - p "
15578 "d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15579    G__memfunc_setup("Integral",822,G__G__MathMore_158_0_25, 100, -1, -1, 0, 3, 1, 1, 0, 
15580 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - p "
15581 "u 'vector<double,allocator<double> >' 'vector<double>' 11 - pts", (char*)NULL, (void*) NULL, 0);
15582    G__memfunc_setup("Result",639,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15583    G__memfunc_setup("Error",522,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15584    G__memfunc_setup("Status",644,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15585    G__memfunc_setup("NEval",470,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15586    G__memfunc_setup("SetRelTolerance",1516,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - relTolerance", (char*)NULL, (void*) NULL, 1);
15587    G__memfunc_setup("SetAbsTolerance",1503,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - absTolerance", (char*)NULL, (void*) NULL, 1);
15588    G__memfunc_setup("SetIntegrationRule",1864,G__G__MathMore_158_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i 'ROOT::Math::Integration::GKRule' - 0 - -", (char*)NULL, (void*) NULL, 0);
15589    G__memfunc_setup("SetOptions",1048,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IntegratorOneDimOptions' - 11 - opt", (char*)NULL, (void*) NULL, 1);
15590    G__memfunc_setup("Options",748,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorOneDimOptions), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15591    G__memfunc_setup("GetType",706,G__G__MathMore_158_0_35, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDimcLcLType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15592    G__memfunc_setup("GetTypeName",1091,G__G__MathMore_158_0_36, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15593    G__memfunc_setup("CheckFunction",1316,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15594    // automatic destructor
15595    G__memfunc_setup("~GSLIntegrator", 1411, G__G__MathMore_158_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15596    G__tag_memfunc_reset();
15597 }
15598 
15599 static void G__setup_memfuncROOTcLcLMathcLcLVegasParameters(void) {
15600    /* ROOT::Math::VegasParameters */
15601    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters));
15602    G__memfunc_setup("VegasParameters",1546,G__G__MathMore_161_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15603    G__memfunc_setup("VegasParameters",1546,G__G__MathMore_161_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IOptions' - 11 - opt", (char*)NULL, (void*) NULL, 0);
15604    G__memfunc_setup("SetDefaultValues",1633,G__G__MathMore_161_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15605    G__memfunc_setup("operator=",937,G__G__MathMore_161_0_4, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::IOptions' - 11 - opt", (char*)NULL, (void*) NULL, 0);
15606    G__memfunc_setup("operator()",957,G__G__MathMore_161_0_5, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIOptions), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15607    // automatic copy constructor
15608    G__memfunc_setup("VegasParameters", 1546, G__G__MathMore_161_0_6, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::VegasParameters' - 11 - -", (char*) NULL, (void*) NULL, 0);
15609    // automatic destructor
15610    G__memfunc_setup("~VegasParameters", 1672, G__G__MathMore_161_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15611    // automatic assignment operator
15612    G__memfunc_setup("operator=", 937, G__G__MathMore_161_0_8, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::VegasParameters' - 11 - -", (char*) NULL, (void*) NULL, 0);
15613    G__tag_memfunc_reset();
15614 }
15615 
15616 static void G__setup_memfuncROOTcLcLMathcLcLMiserParameters(void) {
15617    /* ROOT::Math::MiserParameters */
15618    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters));
15619    G__memfunc_setup("MiserParameters",1556,G__G__MathMore_162_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters), -1, 0, 1, 1, 1, 0, "h - 'size_t' 0 '10' dim", (char*)NULL, (void*) NULL, 0);
15620    G__memfunc_setup("SetDefaultValues",1633,G__G__MathMore_162_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'size_t' 0 '10' dim", (char*)NULL, (void*) NULL, 0);
15621    G__memfunc_setup("MiserParameters",1556,G__G__MathMore_162_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters), -1, 0, 2, 1, 1, 0, 
15622 "u 'ROOT::Math::IOptions' - 11 - opt h - 'size_t' 0 '10' dim", (char*)NULL, (void*) NULL, 0);
15623    G__memfunc_setup("operator=",937,G__G__MathMore_162_0_4, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::IOptions' - 11 - opt", (char*)NULL, (void*) NULL, 0);
15624    G__memfunc_setup("operator()",957,G__G__MathMore_162_0_5, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIOptions), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15625    // automatic copy constructor
15626    G__memfunc_setup("MiserParameters", 1556, G__G__MathMore_162_0_6, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::MiserParameters' - 11 - -", (char*) NULL, (void*) NULL, 0);
15627    // automatic destructor
15628    G__memfunc_setup("~MiserParameters", 1682, G__G__MathMore_162_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15629    // automatic assignment operator
15630    G__memfunc_setup("operator=", 937, G__G__MathMore_162_0_8, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::MiserParameters' - 11 - -", (char*) NULL, (void*) NULL, 0);
15631    G__tag_memfunc_reset();
15632 }
15633 
15634 static void G__setup_memfuncROOTcLcLMathcLcLGSLMCIntegrator(void) {
15635    /* ROOT::Math::GSLMCIntegrator */
15636    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator));
15637    G__memfunc_setup("GSLMCIntegrator",1429,G__G__MathMore_167_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator), -1, 0, 4, 5, 1, 0, 
15638 "i 'ROOT::Math::IntegrationMultiDim::Type' - 0 'MCIntegration::kVEGAS' type d - - 0 '0' absTol "
15639 "d - - 0 '0' relTol h - - 0 '0' calls", (char*)NULL, (void*) NULL, 0);
15640    G__memfunc_setup("GSLMCIntegrator",1429,G__G__MathMore_167_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator), -1, 0, 4, 1, 1, 0, 
15641 "C - - 10 - type d - - 0 - absTol "
15642 "d - - 0 - relTol h - - 0 - calls", (char*)NULL, (void*) NULL, 0);
15643    G__memfunc_setup("GSLMCIntegrator",1429,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLMCIntegrator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15644    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLMCIntegrator' - 11 - -", (char*)NULL, (void*) NULL, 0);
15645    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - f", (char*)NULL, (void*) NULL, 1);
15646    G__memfunc_setup("SetFunction",1138,G__G__MathMore_167_0_6, 121, -1, -1, 0, 3, 1, 1, 0, 
15647 "Y - 'ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer' 0 - f h - - 0 - dim "
15648 "Y - - 0 '0' p", (char*)NULL, (void*) NULL, 0);
15649    G__memfunc_setup("Integral",822,G__G__MathMore_167_0_7, 100, -1, -1, 0, 5, 1, 1, 0, 
15650 "Y - 'ROOT::Math::GSLMCIntegrator::GSLMonteFuncPointer' 11 - f h - - 0 - dim "
15651 "D - - 0 - a D - - 0 - b "
15652 "Y - - 0 '0' p", (char*)NULL, (void*) NULL, 0);
15653    G__memfunc_setup("Integral",822,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
15654 "D - - 10 - a D - - 10 - b", (char*)NULL, (void*) NULL, 1);
15655    G__memfunc_setup("Result",639,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15656    G__memfunc_setup("Error",522,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15657    G__memfunc_setup("Status",644,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15658    G__memfunc_setup("NEval",470,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15659    G__memfunc_setup("SetRelTolerance",1516,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - relTolerance", (char*)NULL, (void*) NULL, 1);
15660    G__memfunc_setup("SetAbsTolerance",1503,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - absTolerance", (char*)NULL, (void*) NULL, 1);
15661    G__memfunc_setup("SetOptions",1048,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IntegratorMultiDimOptions' - 11 - opt", (char*)NULL, (void*) NULL, 1);
15662    G__memfunc_setup("SetGenerator",1235,G__G__MathMore_167_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'ROOT::Math::GSLRngWrapper' - 0 - r", (char*)NULL, (void*) NULL, 0);
15663    G__memfunc_setup("SetType",718,G__G__MathMore_167_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i 'ROOT::Math::IntegrationMultiDim::Type' - 0 - type", (char*)NULL, (void*) NULL, 0);
15664    G__memfunc_setup("SetTypeName",1103,G__G__MathMore_167_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - typeName", (char*)NULL, (void*) NULL, 0);
15665    G__memfunc_setup("SetMode",689,G__G__MathMore_167_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "i 'ROOT::Math::MCIntegration::Mode' - 0 - mode", (char*)NULL, (void*) NULL, 0);
15666    G__memfunc_setup("SetParameters",1344,G__G__MathMore_167_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::VegasParameters' - 11 - p", (char*)NULL, (void*) NULL, 0);
15667    G__memfunc_setup("SetParameters",1344,G__G__MathMore_167_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::MiserParameters' - 11 - p", (char*)NULL, (void*) NULL, 0);
15668    G__memfunc_setup("Sigma",497,G__G__MathMore_167_0_22, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15669    G__memfunc_setup("ChiSqr",586,G__G__MathMore_167_0_23, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15670    G__memfunc_setup("GetType",706,G__G__MathMore_167_0_24, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDimcLcLType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15671    G__memfunc_setup("GetTypeName",1091,G__G__MathMore_167_0_25, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15672    G__memfunc_setup("Options",748,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorMultiDimOptions), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15673    G__memfunc_setup("ExtraOptions",1264,G__G__MathMore_167_0_27, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIOptions), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15674    G__memfunc_setup("CheckFunction",1316,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15675    G__memfunc_setup("DoInitialize",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
15676    // automatic destructor
15677    G__memfunc_setup("~GSLMCIntegrator", 1555, G__G__MathMore_167_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15678    G__tag_memfunc_reset();
15679 }
15680 
15681 static void G__setup_memfuncROOTcLcLMathcLcLMinim1D(void) {
15682    /* ROOT::Math::Minim1D */
15683    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1D));
15684    G__tag_memfunc_reset();
15685 }
15686 
15687 static void G__setup_memfuncROOTcLcLMathcLcLGSLMinimizer1D(void) {
15688    /* ROOT::Math::GSLMinimizer1D */
15689    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D));
15690    G__memfunc_setup("GSLMinimizer1D",1295,G__G__MathMore_172_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D), -1, 0, 1, 5, 1, 0, "i 'ROOT::Math::Minim1D::Type' - 0 'Minim1D::kBRENT' type", (char*)NULL, (void*) NULL, 0);
15691    G__memfunc_setup("GSLMinimizer1D",1295,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLMinimizer1D' - 11 - -", (char*)NULL, (void*) NULL, 0);
15692    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLMinimizer1D' - 11 - -", (char*)NULL, (void*) NULL, 0);
15693    G__memfunc_setup("SetFunction",1138,G__G__MathMore_172_0_4, 121, -1, -1, 0, 5, 1, 1, 0, 
15694 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - params "
15695 "d - - 0 - xmin d - - 0 - xlow "
15696 "d - - 0 - xup", (char*)NULL, (void*) NULL, 0);
15697    G__memfunc_setup("Iterate",718,G__G__MathMore_172_0_5, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15698    G__memfunc_setup("XMinimum",820,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15699    G__memfunc_setup("XLower",609,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15700    G__memfunc_setup("XUpper",612,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15701    G__memfunc_setup("FValMinimum",1093,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15702    G__memfunc_setup("FValLower",882,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15703    G__memfunc_setup("FValUpper",885,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15704    G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
15705 "i - - 0 - maxIter d - - 0 - absTol "
15706 "d - - 0 - relTol", (char*)NULL, (void*) NULL, 1);
15707    G__memfunc_setup("Iterations",1058,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15708    G__memfunc_setup("Status",644,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15709    G__memfunc_setup("Name",385,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15710    G__memfunc_setup("TestInterval",1253,G__G__MathMore_172_0_16, 105, -1, -1, 0, 4, 3, 1, 0, 
15711 "d - - 0 - xlow d - - 0 - xup "
15712 "d - - 0 - epsAbs d - - 0 - epsRel", (char*)NULL, (void*) G__func2void( (int (*)(double, double, double, double))(&ROOT::Math::GSLMinimizer1D::TestInterval) ), 0);
15713    // automatic destructor
15714    G__memfunc_setup("~GSLMinimizer1D", 1421, G__G__MathMore_172_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15715    G__tag_memfunc_reset();
15716 }
15717 
15718 static void G__setup_memfuncROOTcLcLMathcLcLChebyshev(void) {
15719    /* ROOT::Math::Chebyshev */
15720    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev));
15721    G__memfunc_setup("Chebyshev",929,G__G__MathMore_174_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev), -1, 0, 4, 1, 1, 0, 
15722 "u 'ROOT::Math::IBaseFunctionOneDim' 'ROOT::Math::IGenFunction' 11 - f d - - 0 - a "
15723 "d - - 0 - b h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
15724    G__memfunc_setup("Chebyshev",929,G__G__MathMore_174_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev), -1, 0, 5, 1, 1, 0, 
15725 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - p "
15726 "d - - 0 - a d - - 0 - b "
15727 "h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
15728    G__memfunc_setup("Chebyshev",929,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev), -1, 0, 1, 1, 4, 0, "h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
15729    G__memfunc_setup("Chebyshev",929,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::Chebyshev' - 11 - -", (char*)NULL, (void*) NULL, 0);
15730    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::Chebyshev' - 11 - -", (char*)NULL, (void*) NULL, 0);
15731    G__memfunc_setup("operator()",957,G__G__MathMore_174_0_6, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
15732    G__memfunc_setup("EvalErr",689,G__G__MathMore_174_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_pairlEdoublecOdoublegR), -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
15733    G__memfunc_setup("operator()",957,G__G__MathMore_174_0_8, 100, -1, -1, 0, 2, 1, 1, 8, 
15734 "d - - 0 - x h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
15735    G__memfunc_setup("EvalErr",689,G__G__MathMore_174_0_9, 117, G__get_linked_tagnum(&G__G__MathMoreLN_pairlEdoublecOdoublegR), -1, 0, 2, 1, 1, 8, 
15736 "d - - 0 - x h - 'size_t' 0 - n", (char*)NULL, (void*) NULL, 0);
15737    G__memfunc_setup("Deriv",506,G__G__MathMore_174_0_10, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15738    G__memfunc_setup("Integral",822,G__G__MathMore_174_0_11, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15739    G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
15740 "Y - 'ROOT::Math::GSLFuncPointer' 0 - f Y - - 0 - params "
15741 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15742    // automatic destructor
15743    G__memfunc_setup("~Chebyshev", 1055, G__G__MathMore_174_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15744    G__tag_memfunc_reset();
15745 }
15746 
15747 static void G__setup_memfuncROOTcLcLMathcLcLGSLRandomEngine(void) {
15748    /* ROOT::Math::GSLRandomEngine */
15749    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine));
15750    G__memfunc_setup("GSLRandomEngine",1437,G__G__MathMore_176_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15751    G__memfunc_setup("GSLRandomEngine",1437,G__G__MathMore_176_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine), -1, 0, 1, 1, 1, 0, "U 'ROOT::Math::GSLRngWrapper' - 0 - rng", (char*)NULL, (void*) NULL, 0);
15752    G__memfunc_setup("Initialize",1042,G__G__MathMore_176_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15753    G__memfunc_setup("Terminate",937,G__G__MathMore_176_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15754    G__memfunc_setup("operator()",957,G__G__MathMore_176_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15755    G__memfunc_setup("RndmInt",700,G__G__MathMore_176_0_6, 104, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - max", (char*)NULL, (void*) NULL, 0);
15756    G__memfunc_setup("RandomArray",1120,G__G__MathMore_176_0_7, 121, -1, -1, 0, 2, 1, 1, 8, 
15757 "D - - 0 - begin D - - 0 - end", (char*)NULL, (void*) NULL, 0);
15758    G__memfunc_setup("Name",385,G__G__MathMore_176_0_8, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15759    G__memfunc_setup("Size",411,G__G__MathMore_176_0_9, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15760    G__memfunc_setup("SetSeed",685,G__G__MathMore_176_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
15761    G__memfunc_setup("Gaussian",827,G__G__MathMore_176_0_11, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
15762    G__memfunc_setup("GaussianZig",1125,G__G__MathMore_176_0_12, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
15763    G__memfunc_setup("GaussianRatio",1338,G__G__MathMore_176_0_13, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
15764    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_176_0_14, 100, -1, -1, 0, 2, 1, 1, 8, 
15765 "d - - 0 - a d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
15766    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_176_0_15, 121, -1, -1, 0, 5, 1, 1, 8, 
15767 "d - - 0 - sigmaX d - - 0 - sigmaY "
15768 "d - - 0 - rho d - - 1 - x "
15769 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
15770    G__memfunc_setup("Exponential",1159,G__G__MathMore_176_0_16, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
15771    G__memfunc_setup("Cauchy",605,G__G__MathMore_176_0_17, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - a", (char*)NULL, (void*) NULL, 0);
15772    G__memfunc_setup("Landau",597,G__G__MathMore_176_0_18, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
15773    G__memfunc_setup("Gamma",483,G__G__MathMore_176_0_19, 100, -1, -1, 0, 2, 1, 1, 8, 
15774 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
15775    G__memfunc_setup("LogNormal",907,G__G__MathMore_176_0_20, 100, -1, -1, 0, 2, 1, 1, 8, 
15776 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
15777    G__memfunc_setup("ChiSquare",901,G__G__MathMore_176_0_21, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
15778    G__memfunc_setup("FDist",474,G__G__MathMore_176_0_22, 100, -1, -1, 0, 2, 1, 1, 8, 
15779 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
15780    G__memfunc_setup("tDist",520,G__G__MathMore_176_0_23, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
15781    G__memfunc_setup("Dir2D",405,G__G__MathMore_176_0_24, 121, -1, -1, 0, 2, 1, 1, 8, 
15782 "d - - 1 - x d - - 1 - y", (char*)NULL, (void*) NULL, 0);
15783    G__memfunc_setup("Dir3D",406,G__G__MathMore_176_0_25, 121, -1, -1, 0, 3, 1, 1, 8, 
15784 "d - - 1 - x d - - 1 - y "
15785 "d - - 1 - z", (char*)NULL, (void*) NULL, 0);
15786    G__memfunc_setup("Poisson",747,G__G__MathMore_176_0_26, 104, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
15787    G__memfunc_setup("Binomial",811,G__G__MathMore_176_0_27, 104, -1, -1, 0, 2, 1, 1, 8, 
15788 "d - - 0 - p h - - 0 - n", (char*)NULL, (void*) NULL, 0);
15789    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_176_0_28, 104, -1, -1, 0, 2, 1, 1, 8, 
15790 "d - - 0 - p d - - 0 - n", (char*)NULL, (void*) NULL, 0);
15791    G__memfunc_setup("Multinomial",1163,G__G__MathMore_176_0_29, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 8, 
15792 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
15793    G__memfunc_setup("SetType",718,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'ROOT::Math::GSLRngWrapper' - 0 - r", (char*)NULL, (void*) NULL, 0);
15794    // automatic copy constructor
15795    G__memfunc_setup("GSLRandomEngine", 1437, G__G__MathMore_176_0_31, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRandomEngine' - 11 - -", (char*) NULL, (void*) NULL, 0);
15796    // automatic destructor
15797    G__memfunc_setup("~GSLRandomEngine", 1563, G__G__MathMore_176_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15798    // automatic assignment operator
15799    G__memfunc_setup("operator=", 937, G__G__MathMore_176_0_33, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRandomEngine' - 11 - -", (char*) NULL, (void*) NULL, 0);
15800    G__tag_memfunc_reset();
15801 }
15802 
15803 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngMT(void) {
15804    /* ROOT::Math::GSLRngMT */
15805    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT));
15806    G__memfunc_setup("GSLRngMT",686,G__G__MathMore_181_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15807    // automatic copy constructor
15808    G__memfunc_setup("GSLRngMT", 686, G__G__MathMore_181_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
15809    // automatic destructor
15810    G__memfunc_setup("~GSLRngMT", 812, G__G__MathMore_181_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15811    // automatic assignment operator
15812    G__memfunc_setup("operator=", 937, G__G__MathMore_181_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngMT' - 11 - -", (char*) NULL, (void*) NULL, 0);
15813    G__tag_memfunc_reset();
15814 }
15815 
15816 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLux(void) {
15817    /* ROOT::Math::GSLRngRanLux */
15818    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux));
15819    G__memfunc_setup("GSLRngRanLux",1127,G__G__MathMore_182_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15820    // automatic copy constructor
15821    G__memfunc_setup("GSLRngRanLux", 1127, G__G__MathMore_182_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLux' - 11 - -", (char*) NULL, (void*) NULL, 0);
15822    // automatic destructor
15823    G__memfunc_setup("~GSLRngRanLux", 1253, G__G__MathMore_182_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15824    // automatic assignment operator
15825    G__memfunc_setup("operator=", 937, G__G__MathMore_182_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLux' - 11 - -", (char*) NULL, (void*) NULL, 0);
15826    G__tag_memfunc_reset();
15827 }
15828 
15829 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxS1(void) {
15830    /* ROOT::Math::GSLRngRanLuxS1 */
15831    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1));
15832    G__memfunc_setup("GSLRngRanLuxS1",1259,G__G__MathMore_183_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15833    // automatic copy constructor
15834    G__memfunc_setup("GSLRngRanLuxS1", 1259, G__G__MathMore_183_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxS1' - 11 - -", (char*) NULL, (void*) NULL, 0);
15835    // automatic destructor
15836    G__memfunc_setup("~GSLRngRanLuxS1", 1385, G__G__MathMore_183_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15837    // automatic assignment operator
15838    G__memfunc_setup("operator=", 937, G__G__MathMore_183_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxS1' - 11 - -", (char*) NULL, (void*) NULL, 0);
15839    G__tag_memfunc_reset();
15840 }
15841 
15842 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxS2(void) {
15843    /* ROOT::Math::GSLRngRanLuxS2 */
15844    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2));
15845    G__memfunc_setup("GSLRngRanLuxS2",1260,G__G__MathMore_184_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15846    // automatic copy constructor
15847    G__memfunc_setup("GSLRngRanLuxS2", 1260, G__G__MathMore_184_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxS2' - 11 - -", (char*) NULL, (void*) NULL, 0);
15848    // automatic destructor
15849    G__memfunc_setup("~GSLRngRanLuxS2", 1386, G__G__MathMore_184_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15850    // automatic assignment operator
15851    G__memfunc_setup("operator=", 937, G__G__MathMore_184_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxS2' - 11 - -", (char*) NULL, (void*) NULL, 0);
15852    G__tag_memfunc_reset();
15853 }
15854 
15855 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxD1(void) {
15856    /* ROOT::Math::GSLRngRanLuxD1 */
15857    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1));
15858    G__memfunc_setup("GSLRngRanLuxD1",1244,G__G__MathMore_185_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15859    // automatic copy constructor
15860    G__memfunc_setup("GSLRngRanLuxD1", 1244, G__G__MathMore_185_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxD1' - 11 - -", (char*) NULL, (void*) NULL, 0);
15861    // automatic destructor
15862    G__memfunc_setup("~GSLRngRanLuxD1", 1370, G__G__MathMore_185_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15863    // automatic assignment operator
15864    G__memfunc_setup("operator=", 937, G__G__MathMore_185_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxD1' - 11 - -", (char*) NULL, (void*) NULL, 0);
15865    G__tag_memfunc_reset();
15866 }
15867 
15868 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxD2(void) {
15869    /* ROOT::Math::GSLRngRanLuxD2 */
15870    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2));
15871    G__memfunc_setup("GSLRngRanLuxD2",1245,G__G__MathMore_186_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15872    // automatic copy constructor
15873    G__memfunc_setup("GSLRngRanLuxD2", 1245, G__G__MathMore_186_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxD2' - 11 - -", (char*) NULL, (void*) NULL, 0);
15874    // automatic destructor
15875    G__memfunc_setup("~GSLRngRanLuxD2", 1371, G__G__MathMore_186_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15876    // automatic assignment operator
15877    G__memfunc_setup("operator=", 937, G__G__MathMore_186_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngRanLuxD2' - 11 - -", (char*) NULL, (void*) NULL, 0);
15878    G__tag_memfunc_reset();
15879 }
15880 
15881 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngTaus(void) {
15882    /* ROOT::Math::GSLRngTaus */
15883    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus));
15884    G__memfunc_setup("GSLRngTaus",938,G__G__MathMore_187_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15885    // automatic copy constructor
15886    G__memfunc_setup("GSLRngTaus", 938, G__G__MathMore_187_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngTaus' - 11 - -", (char*) NULL, (void*) NULL, 0);
15887    // automatic destructor
15888    G__memfunc_setup("~GSLRngTaus", 1064, G__G__MathMore_187_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15889    // automatic assignment operator
15890    G__memfunc_setup("operator=", 937, G__G__MathMore_187_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngTaus' - 11 - -", (char*) NULL, (void*) NULL, 0);
15891    G__tag_memfunc_reset();
15892 }
15893 
15894 static void G__setup_memfuncROOTcLcLMathcLcLGSLRngGFSR4(void) {
15895    /* ROOT::Math::GSLRngGFSR4 */
15896    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4));
15897    G__memfunc_setup("GSLRngGFSR4",883,G__G__MathMore_188_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15898    // automatic copy constructor
15899    G__memfunc_setup("GSLRngGFSR4", 883, G__G__MathMore_188_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngGFSR4' - 11 - -", (char*) NULL, (void*) NULL, 0);
15900    // automatic destructor
15901    G__memfunc_setup("~GSLRngGFSR4", 1009, G__G__MathMore_188_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15902    // automatic assignment operator
15903    G__memfunc_setup("operator=", 937, G__G__MathMore_188_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLRngGFSR4' - 11 - -", (char*) NULL, (void*) NULL, 0);
15904    G__tag_memfunc_reset();
15905 }
15906 
15907 static void G__setup_memfuncROOTcLcLMathcLcLKelvinFunctions(void) {
15908    /* ROOT::Math::KelvinFunctions */
15909    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions));
15910    G__memfunc_setup("Ber",281,G__G__MathMore_194_0_1, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::Ber) ), 0);
15911    G__memfunc_setup("Bei",272,G__G__MathMore_194_0_2, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::Bei) ), 0);
15912    G__memfunc_setup("Ker",290,G__G__MathMore_194_0_3, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::Ker) ), 0);
15913    G__memfunc_setup("Kei",281,G__G__MathMore_194_0_4, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::Kei) ), 0);
15914    G__memfunc_setup("DBer",349,G__G__MathMore_194_0_5, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::DBer) ), 0);
15915    G__memfunc_setup("DBei",340,G__G__MathMore_194_0_6, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::DBei) ), 0);
15916    G__memfunc_setup("DKer",358,G__G__MathMore_194_0_7, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::DKer) ), 0);
15917    G__memfunc_setup("DKei",349,G__G__MathMore_194_0_8, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::DKei) ), 0);
15918    G__memfunc_setup("F1",119,G__G__MathMore_194_0_9, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::F1) ), 0);
15919    G__memfunc_setup("F2",120,G__G__MathMore_194_0_10, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::F2) ), 0);
15920    G__memfunc_setup("G1",120,G__G__MathMore_194_0_11, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::G1) ), 0);
15921    G__memfunc_setup("G2",121,G__G__MathMore_194_0_12, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::G2) ), 0);
15922    G__memfunc_setup("M",77,G__G__MathMore_194_0_13, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::M) ), 0);
15923    G__memfunc_setup("Theta",502,G__G__MathMore_194_0_14, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::Theta) ), 0);
15924    G__memfunc_setup("N",78,G__G__MathMore_194_0_15, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::N) ), 0);
15925    G__memfunc_setup("Phi",289,G__G__MathMore_194_0_16, 100, -1, -1, 0, 1, 3, 1, 0, "d - - 0 - x", (char*)NULL, (void*) G__func2void( (double (*)(double))(&ROOT::Math::KelvinFunctions::Phi) ), 0);
15926    // automatic default constructor
15927    G__memfunc_setup("KelvinFunctions", 1570, G__G__MathMore_194_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
15928    // automatic copy constructor
15929    G__memfunc_setup("KelvinFunctions", 1570, G__G__MathMore_194_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::KelvinFunctions' - 11 - -", (char*) NULL, (void*) NULL, 0);
15930    // automatic destructor
15931    G__memfunc_setup("~KelvinFunctions", 1696, G__G__MathMore_194_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15932    // automatic assignment operator
15933    G__memfunc_setup("operator=", 937, G__G__MathMore_194_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::KelvinFunctions' - 11 - -", (char*) NULL, (void*) NULL, 0);
15934    G__tag_memfunc_reset();
15935 }
15936 
15937 static void G__setup_memfuncROOTcLcLMathcLcLGSLMinimizer(void) {
15938    /* ROOT::Math::GSLMinimizer */
15939    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer));
15940    G__memfunc_setup("GSLMinimizer",1178,G__G__MathMore_207_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer), -1, 0, 1, 1, 1, 0, "i 'ROOT::Math::EGSLMinimizerType' - 0 'ROOT::Math::kConjugateFR' type", (char*)NULL, (void*) NULL, 0);
15941    G__memfunc_setup("GSLMinimizer",1178,G__G__MathMore_207_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer), -1, 0, 1, 1, 1, 0, "C - - 10 - type", (char*)NULL, (void*) NULL, 0);
15942    G__memfunc_setup("GSLMinimizer",1178,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLMinimizer' - 11 - -", (char*)NULL, (void*) NULL, 0);
15943    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLMinimizer' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
15944    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
15945    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IGradientFunctionMultiDim' 'ROOT::Math::IMultiGradFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
15946    G__memfunc_setup("SetVariable",1106,(G__InterfaceMethod) NULL,103, -1, -1, 0, 4, 1, 1, 0, 
15947 "h - - 0 - ivar u 'string' - 11 - name "
15948 "d - - 0 - val d - - 0 - step", (char*)NULL, (void*) NULL, 1);
15949    G__memfunc_setup("SetLowerLimitedVariable",2339,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
15950 "h - - 0 - ivar u 'string' - 11 - name "
15951 "d - - 0 - val d - - 0 - step "
15952 "d - - 0 - lower", (char*)NULL, (void*) NULL, 1);
15953    G__memfunc_setup("SetUpperLimitedVariable",2342,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
15954 "h - - 0 - ivar u 'string' - 11 - name "
15955 "d - - 0 - val d - - 0 - step "
15956 "d - - 0 - upper", (char*)NULL, (void*) NULL, 1);
15957    G__memfunc_setup("SetLimitedVariable",1818,(G__InterfaceMethod) NULL,103, -1, -1, 0, 6, 1, 1, 0, 
15958 "h - - 0 - ivar u 'string' - 11 - name "
15959 "d - - 0 - val d - - 0 - step "
15960 "d - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 1);
15961    G__memfunc_setup("SetFixedVariable",1602,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
15962 "h - - 0 - - u 'string' - 11 - - "
15963 "d - - 0 - -", (char*)NULL, (void*) NULL, 1);
15964    G__memfunc_setup("SetVariableValue",1615,(G__InterfaceMethod) NULL,103, -1, -1, 0, 2, 1, 1, 0, 
15965 "h - - 0 - ivar d - - 0 - val", (char*)NULL, (void*) NULL, 1);
15966    G__memfunc_setup("SetVariableValues",1730,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
15967    G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
15968    G__memfunc_setup("MinValue",801,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15969    G__memfunc_setup("Edm",278,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", "not impl. }", (void*) NULL, 1);
15970    G__memfunc_setup("X",88,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15971    G__memfunc_setup("MinGradient",1106,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15972    G__memfunc_setup("NCalls",573,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15973    G__memfunc_setup("NDim",360,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15974    G__memfunc_setup("NFree",464,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15975    G__memfunc_setup("ProvidesError",1366,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15976    G__memfunc_setup("Errors",637,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
15977    G__memfunc_setup("CovMatrix",925,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
15978 "h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 1);
15979    G__memfunc_setup("ObjFunction",1121,G__G__MathMore_207_0_25, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim), G__defined_typename("ROOT::Math::IMultiGradFunction"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15980    G__memfunc_setup("TransformFunction",1794,G__G__MathMore_207_0_26, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinimTransformFunction), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
15981    // automatic destructor
15982    G__memfunc_setup("~GSLMinimizer", 1304, G__G__MathMore_207_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
15983    G__tag_memfunc_reset();
15984 }
15985 
15986 static void G__setup_memfuncROOTcLcLMathcLcLLSResidualFunc(void) {
15987    /* ROOT::Math::LSResidualFunc */
15988    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc));
15989    G__memfunc_setup("LSResidualFunc",1380,G__G__MathMore_230_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
15990    G__memfunc_setup("LSResidualFunc",1380,G__G__MathMore_230_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc), -1, 0, 2, 1, 1, 0, 
15991 "u 'ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>' 'ROOT::Math::FitMethodFunction' 11 - func h - - 0 - i", (char*)NULL, (void*) NULL, 0);
15992    G__memfunc_setup("LSResidualFunc",1380,G__G__MathMore_230_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::LSResidualFunc' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
15993    G__memfunc_setup("operator=",937,G__G__MathMore_230_0_4, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::LSResidualFunc' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
15994    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Math::IMultiGenFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15995    G__memfunc_setup("NDim",360,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
15996    G__memfunc_setup("Gradient",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
15997 "D - - 10 - x D - - 0 - g", (char*)NULL, (void*) NULL, 1);
15998    G__memfunc_setup("FdF",240,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
15999 "D - - 10 - x d - - 1 - f "
16000 "D - - 0 - g", (char*)NULL, (void*) NULL, 1);
16001    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
16002    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
16003 "D - - 10 - x h - - 0 - icoord", (char*)NULL, (void*) NULL, 1);
16004    // automatic destructor
16005    G__memfunc_setup("~LSResidualFunc", 1506, G__G__MathMore_230_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16006    G__tag_memfunc_reset();
16007 }
16008 
16009 static void G__setup_memfuncROOTcLcLMathcLcLGSLNLSMinimizer(void) {
16010    /* ROOT::Math::GSLNLSMinimizer */
16011    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer));
16012    G__memfunc_setup("GSLNLSMinimizer",1415,G__G__MathMore_231_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer), -1, 0, 1, 1, 1, 0, "i - - 0 '0' type", (char*)NULL, (void*) NULL, 0);
16013    G__memfunc_setup("GSLNLSMinimizer",1415,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLNLSMinimizer' - 11 - -", (char*)NULL, (void*) NULL, 0);
16014    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLNLSMinimizer' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
16015    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
16016    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IGradientFunctionMultiDim' 'ROOT::Math::IMultiGradFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
16017    G__memfunc_setup("SetVariable",1106,(G__InterfaceMethod) NULL,103, -1, -1, 0, 4, 1, 1, 0, 
16018 "h - - 0 - ivar u 'string' - 11 - name "
16019 "d - - 0 - val d - - 0 - step", (char*)NULL, (void*) NULL, 1);
16020    G__memfunc_setup("SetLowerLimitedVariable",2339,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
16021 "h - - 0 - ivar u 'string' - 11 - name "
16022 "d - - 0 - val d - - 0 - step "
16023 "d - - 0 - lower", (char*)NULL, (void*) NULL, 1);
16024    G__memfunc_setup("SetUpperLimitedVariable",2342,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
16025 "h - - 0 - ivar u 'string' - 11 - name "
16026 "d - - 0 - val d - - 0 - step "
16027 "d - - 0 - upper", (char*)NULL, (void*) NULL, 1);
16028    G__memfunc_setup("SetLimitedVariable",1818,(G__InterfaceMethod) NULL,103, -1, -1, 0, 6, 1, 1, 0, 
16029 "h - - 0 - ivar u 'string' - 11 - name "
16030 "d - - 0 - val d - - 0 - step "
16031 "d - - 0 - lower d - - 0 - upper", (char*)NULL, (void*) NULL, 1);
16032    G__memfunc_setup("SetFixedVariable",1602,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
16033 "h - - 0 - ivar u 'string' - 11 - name "
16034 "d - - 0 - val", (char*)NULL, (void*) NULL, 1);
16035    G__memfunc_setup("SetVariableValue",1615,(G__InterfaceMethod) NULL,103, -1, -1, 0, 2, 1, 1, 0, 
16036 "h - - 0 - ivar d - - 0 - val", (char*)NULL, (void*) NULL, 1);
16037    G__memfunc_setup("SetVariableValues",1730,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
16038    G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16039    G__memfunc_setup("MinValue",801,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16040    G__memfunc_setup("Edm",278,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", "not impl. }", (void*) NULL, 1);
16041    G__memfunc_setup("X",88,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16042    G__memfunc_setup("MinGradient",1106,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16043    G__memfunc_setup("NCalls",573,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16044    G__memfunc_setup("NDim",360,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16045    G__memfunc_setup("NFree",464,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16046    G__memfunc_setup("ProvidesError",1366,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16047    G__memfunc_setup("Errors",637,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16048    G__memfunc_setup("CovMatrix",925,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
16049 "h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 1);
16050    G__memfunc_setup("CovMatrixStatus",1569,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16051    // automatic destructor
16052    G__memfunc_setup("~GSLNLSMinimizer", 1541, G__G__MathMore_231_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16053    G__tag_memfunc_reset();
16054 }
16055 
16056 static void G__setup_memfuncROOTcLcLMathcLcLGSLSimAnFunc(void) {
16057    /* ROOT::Math::GSLSimAnFunc */
16058    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc));
16059    G__memfunc_setup("GSLSimAnFunc",1098,G__G__MathMore_236_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc), -1, 0, 2, 1, 1, 0, 
16060 "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - func D - - 10 - x", (char*)NULL, (void*) NULL, 0);
16061    G__memfunc_setup("GSLSimAnFunc",1098,G__G__MathMore_236_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc), -1, 0, 3, 1, 1, 0, 
16062 "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - func D - - 10 - x "
16063 "D - - 10 - scale", (char*)NULL, (void*) NULL, 0);
16064    G__memfunc_setup("GSLSimAnFunc",1098,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
16065    G__memfunc_setup("FastCopy",809,G__G__MathMore_236_0_4, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLSimAnFunc' - 11 - f", (char*)NULL, (void*) NULL, 1);
16066    G__memfunc_setup("Clone",497,G__G__MathMore_236_0_5, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16067    G__memfunc_setup("Energy",618,G__G__MathMore_236_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16068    G__memfunc_setup("Step",412,G__G__MathMore_236_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
16069 "u 'ROOT::Math::GSLRandomEngine' - 11 - r d - - 0 - maxstep", (char*)NULL, (void*) NULL, 1);
16070    G__memfunc_setup("Distance",811,G__G__MathMore_236_0_8, 100, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Math::GSLSimAnFunc' - 11 - func", (char*)NULL, (void*) NULL, 1);
16071    G__memfunc_setup("Print",525,G__G__MathMore_236_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16072    G__memfunc_setup("SetX",388,G__G__MathMore_236_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - x", (char*)NULL, (void*) NULL, 0);
16073    G__memfunc_setup("NDim",360,G__G__MathMore_236_0_11, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16074    G__memfunc_setup("X",88,G__G__MathMore_236_0_12, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
16075    G__memfunc_setup("X",88,G__G__MathMore_236_0_13, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16076    G__memfunc_setup("Scale",488,G__G__MathMore_236_0_14, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
16077    G__memfunc_setup("SetX",388,G__G__MathMore_236_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
16078 "h - - 0 - i d - - 0 - x", (char*)NULL, (void*) NULL, 0);
16079    // automatic copy constructor
16080    G__memfunc_setup("GSLSimAnFunc", 1098, G__G__MathMore_236_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLSimAnFunc' - 11 - -", (char*) NULL, (void*) NULL, 0);
16081    // automatic destructor
16082    G__memfunc_setup("~GSLSimAnFunc", 1224, G__G__MathMore_236_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16083    G__tag_memfunc_reset();
16084 }
16085 
16086 static void G__setup_memfuncROOTcLcLMathcLcLGSLSimAnParams(void) {
16087    /* ROOT::Math::GSLSimAnParams */
16088    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams));
16089    G__memfunc_setup("GSLSimAnParams",1314,G__G__MathMore_237_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16090    // automatic copy constructor
16091    G__memfunc_setup("GSLSimAnParams", 1314, G__G__MathMore_237_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::GSLSimAnParams' - 11 - -", (char*) NULL, (void*) NULL, 0);
16092    // automatic destructor
16093    G__memfunc_setup("~GSLSimAnParams", 1440, G__G__MathMore_237_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16094    // automatic assignment operator
16095    G__memfunc_setup("operator=", 937, G__G__MathMore_237_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::GSLSimAnParams' - 11 - -", (char*) NULL, (void*) NULL, 0);
16096    G__tag_memfunc_reset();
16097 }
16098 
16099 static void G__setup_memfuncROOTcLcLMathcLcLGSLSimAnnealing(void) {
16100    /* ROOT::Math::GSLSimAnnealing */
16101    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing));
16102    G__memfunc_setup("GSLSimAnnealing",1436,G__G__MathMore_238_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16103    G__memfunc_setup("GSLSimAnnealing",1436,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLSimAnnealing' - 11 - -", (char*)NULL, (void*) NULL, 0);
16104    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLSimAnnealing' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
16105    G__memfunc_setup("Solve",521,G__G__MathMore_238_0_4, 105, -1, -1, 0, 5, 1, 1, 0, 
16106 "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - func D - - 10 - x0 "
16107 "D - - 10 - scale D - - 0 - xmin "
16108 "g - - 0 'false' debug", (char*)NULL, (void*) NULL, 0);
16109    G__memfunc_setup("Solve",521,G__G__MathMore_238_0_5, 105, -1, -1, 0, 2, 1, 1, 0, 
16110 "u 'ROOT::Math::GSLSimAnFunc' - 1 - func g - - 0 'false' debug", (char*)NULL, (void*) NULL, 0);
16111    G__memfunc_setup("Params",612,G__G__MathMore_238_0_6, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16112    G__memfunc_setup("Params",612,G__G__MathMore_238_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
16113    // automatic destructor
16114    G__memfunc_setup("~GSLSimAnnealing", 1562, G__G__MathMore_238_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16115    G__tag_memfunc_reset();
16116 }
16117 
16118 static void G__setup_memfuncROOTcLcLMathcLcLGSLSimAnMinimizer(void) {
16119    /* ROOT::Math::GSLSimAnMinimizer */
16120    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer));
16121    G__memfunc_setup("GSLSimAnMinimizer",1650,G__G__MathMore_239_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer), -1, 0, 1, 1, 1, 0, "i - - 0 '0' type", (char*)NULL, (void*) NULL, 0);
16122    G__memfunc_setup("GSLSimAnMinimizer",1650,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer), -1, 0, 1, 1, 4, 0, "u 'ROOT::Math::GSLSimAnMinimizer' - 11 - -", (char*)NULL, (void*) NULL, 0);
16123    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer), -1, 1, 1, 1, 4, 0, "u 'ROOT::Math::GSLSimAnMinimizer' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
16124    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
16125    G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IGradientFunctionMultiDim' 'ROOT::Math::IMultiGradFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
16126    G__memfunc_setup("SetVariable",1106,(G__InterfaceMethod) NULL,103, -1, -1, 0, 4, 1, 1, 0, 
16127 "h - - 0 - ivar u 'string' - 11 - name "
16128 "d - - 0 - val d - - 0 - step", (char*)NULL, (void*) NULL, 1);
16129    G__memfunc_setup("SetFixedVariable",1602,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
16130 "h - - 0 - - u 'string' - 11 - - "
16131 "d - - 0 - -", (char*)NULL, (void*) NULL, 1);
16132    G__memfunc_setup("SetLowerLimitedVariable",2339,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
16133 "h - - 0 - ivar u 'string' - 11 - name "
16134 "d - - 0 - val d - - 0 - step "
16135 "d - - 0 - lower", (char*)NULL, (void*) NULL, 1);
16136    G__memfunc_setup("SetUpperLimitedVariable",2342,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
16137 "h - - 0 - ivar u 'string' - 11 - name "
16138 "d - - 0 - val d - - 0 - step "
16139 "d - - 0 - upper", (char*)NULL, (void*) NULL, 1);
16140    G__memfunc_setup("SetLimitedVariable",1818,(G__InterfaceMethod) NULL,103, -1, -1, 0, 6, 1, 1, 0, 
16141 "h - - 0 - ivar u 'string' - 11 - name "
16142 "d - - 0 - val d - - 0 - step "
16143 "d - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 1);
16144    G__memfunc_setup("SetVariableValue",1615,(G__InterfaceMethod) NULL,103, -1, -1, 0, 2, 1, 1, 0, 
16145 "h - - 0 - ivar d - - 0 - val", (char*)NULL, (void*) NULL, 1);
16146    G__memfunc_setup("SetVariableValues",1730,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
16147    G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
16148    G__memfunc_setup("MinValue",801,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16149    G__memfunc_setup("Edm",278,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", "not impl. }", (void*) NULL, 1);
16150    G__memfunc_setup("X",88,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16151    G__memfunc_setup("MinGradient",1106,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", "not impl.  ", (void*) NULL, 1);
16152    G__memfunc_setup("NCalls",573,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", "not yet ipl.  ", (void*) NULL, 1);
16153    G__memfunc_setup("NDim",360,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16154    G__memfunc_setup("NFree",464,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16155    G__memfunc_setup("ProvidesError",1366,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16156    G__memfunc_setup("Errors",637,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16157    G__memfunc_setup("CovMatrix",925,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
16158 "h - - 0 - - h - - 0 - -", (char*)NULL, (void*) NULL, 1);
16159    // automatic destructor
16160    G__memfunc_setup("~GSLSimAnMinimizer", 1776, G__G__MathMore_239_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16161    G__tag_memfunc_reset();
16162 }
16163 
16164 static void G__setup_memfuncROOTcLcLMathcLcLVavilov(void) {
16165    /* ROOT::Math::Vavilov */
16166    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov));
16167    G__memfunc_setup("Pdf",282,G__G__MathMore_240_0_2, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 3);
16168    G__memfunc_setup("Pdf",282,G__G__MathMore_240_0_3, 100, -1, -1, 0, 3, 1, 1, 0, 
16169 "d - - 0 - x d - - 0 - kappa "
16170 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 3);
16171    G__memfunc_setup("Cdf",269,G__G__MathMore_240_0_4, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 3);
16172    G__memfunc_setup("Cdf",269,G__G__MathMore_240_0_5, 100, -1, -1, 0, 3, 1, 1, 0, 
16173 "d - - 0 - x d - - 0 - kappa "
16174 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 3);
16175    G__memfunc_setup("Cdf_c",463,G__G__MathMore_240_0_6, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 3);
16176    G__memfunc_setup("Cdf_c",463,G__G__MathMore_240_0_7, 100, -1, -1, 0, 3, 1, 1, 0, 
16177 "d - - 0 - x d - - 0 - kappa "
16178 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 3);
16179    G__memfunc_setup("Quantile",835,G__G__MathMore_240_0_8, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - z", (char*)NULL, (void*) NULL, 3);
16180    G__memfunc_setup("Quantile",835,G__G__MathMore_240_0_9, 100, -1, -1, 0, 3, 1, 1, 0, 
16181 "d - - 0 - z d - - 0 - kappa "
16182 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 3);
16183    G__memfunc_setup("Quantile_c",1029,G__G__MathMore_240_0_10, 100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - z", (char*)NULL, (void*) NULL, 3);
16184    G__memfunc_setup("Quantile_c",1029,G__G__MathMore_240_0_11, 100, -1, -1, 0, 3, 1, 1, 0, 
16185 "d - - 0 - z d - - 0 - kappa "
16186 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 3);
16187    G__memfunc_setup("SetKappaBeta2",1223,G__G__MathMore_240_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
16188 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) NULL, 3);
16189    G__memfunc_setup("GetLambdaMin",1157,G__G__MathMore_240_0_13, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
16190    G__memfunc_setup("GetLambdaMax",1159,G__G__MathMore_240_0_14, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
16191    G__memfunc_setup("GetKappa",781,G__G__MathMore_240_0_15, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
16192    G__memfunc_setup("GetBeta2",718,G__G__MathMore_240_0_16, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
16193    G__memfunc_setup("Mode",389,G__G__MathMore_240_0_17, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16194    G__memfunc_setup("Mode",389,G__G__MathMore_240_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16195 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16196    G__memfunc_setup("Mean",385,G__G__MathMore_240_0_19, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16197    G__memfunc_setup("Variance",809,G__G__MathMore_240_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16198    G__memfunc_setup("Skewness",851,G__G__MathMore_240_0_21, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16199    G__memfunc_setup("Kurtosis",868,G__G__MathMore_240_0_22, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16200    G__memfunc_setup("Mean",385,G__G__MathMore_240_0_23, 100, -1, -1, 0, 2, 3, 1, 0, 
16201 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::Vavilov::Mean) ), 0);
16202    G__memfunc_setup("Variance",809,G__G__MathMore_240_0_24, 100, -1, -1, 0, 2, 3, 1, 0, 
16203 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::Vavilov::Variance) ), 0);
16204    G__memfunc_setup("Skewness",851,G__G__MathMore_240_0_25, 100, -1, -1, 0, 2, 3, 1, 0, 
16205 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::Vavilov::Skewness) ), 0);
16206    G__memfunc_setup("Kurtosis",868,G__G__MathMore_240_0_26, 100, -1, -1, 0, 2, 3, 1, 0, 
16207 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (double (*)(double, double))(&ROOT::Math::Vavilov::Kurtosis) ), 0);
16208    // automatic destructor
16209    G__memfunc_setup("~Vavilov", 869, G__G__MathMore_240_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16210    // automatic assignment operator
16211    G__memfunc_setup("operator=", 937, G__G__MathMore_240_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Vavilov' - 11 - -", (char*) NULL, (void*) NULL, 0);
16212    G__tag_memfunc_reset();
16213 }
16214 
16215 static void G__setup_memfuncROOTcLcLMathcLcLVavilovAccurate(void) {
16216    /* ROOT::Math::VavilovAccurate */
16217    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate));
16218    G__memfunc_setup("VavilovAccurate",1551,G__G__MathMore_241_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate), -1, 0, 4, 1, 1, 0, 
16219 "d - - 0 '1' kappa d - - 0 '1' beta2 "
16220 "d - - 0 '5E-4' epsilonPM d - - 0 '1E-5' epsilon", (char*)NULL, (void*) NULL, 0);
16221    G__memfunc_setup("Pdf",282,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16222    G__memfunc_setup("Pdf",282,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16223 "d - - 0 - x d - - 0 - kappa "
16224 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16225    G__memfunc_setup("Cdf",269,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16226    G__memfunc_setup("Cdf",269,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16227 "d - - 0 - x d - - 0 - kappa "
16228 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16229    G__memfunc_setup("Cdf_c",463,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16230    G__memfunc_setup("Cdf_c",463,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16231 "d - - 0 - x d - - 0 - kappa "
16232 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16233    G__memfunc_setup("Quantile",835,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - z", (char*)NULL, (void*) NULL, 1);
16234    G__memfunc_setup("Quantile",835,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16235 "d - - 0 - z d - - 0 - kappa "
16236 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16237    G__memfunc_setup("Quantile_c",1029,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - z", (char*)NULL, (void*) NULL, 1);
16238    G__memfunc_setup("Quantile_c",1029,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16239 "d - - 0 - z d - - 0 - kappa "
16240 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16241    G__memfunc_setup("SetKappaBeta2",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
16242 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16243    G__memfunc_setup("Set",300,G__G__MathMore_241_0_13, 121, -1, -1, 0, 4, 1, 1, 0, 
16244 "d - - 0 - kappa d - - 0 - beta2 "
16245 "d - - 0 '5E-4' epsilonPM d - - 0 '1E-5' epsilon", (char*)NULL, (void*) NULL, 0);
16246    G__memfunc_setup("GetLambdaMin",1157,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16247    G__memfunc_setup("GetLambdaMax",1159,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16248    G__memfunc_setup("GetKappa",781,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16249    G__memfunc_setup("GetBeta2",718,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16250    G__memfunc_setup("Mode",389,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16251    G__memfunc_setup("Mode",389,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 0, 
16252 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16253    G__memfunc_setup("GetEpsilonPM",1175,G__G__MathMore_241_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16254    G__memfunc_setup("GetEpsilon",1018,G__G__MathMore_241_0_21, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16255    G__memfunc_setup("GetNTerms",889,G__G__MathMore_241_0_22, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16256    G__memfunc_setup("GetInstance",1109,G__G__MathMore_241_0_23, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ROOT::Math::VavilovAccurate* (*)())(&ROOT::Math::VavilovAccurate::GetInstance) ), 0);
16257    G__memfunc_setup("GetInstance",1109,G__G__MathMore_241_0_24, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate), -1, 0, 2, 3, 1, 0, 
16258 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (ROOT::Math::VavilovAccurate* (*)(double, double))(&ROOT::Math::VavilovAccurate::GetInstance) ), 0);
16259    G__memfunc_setup("InitQuantile",1239,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
16260    G__memfunc_setup("G116f1",374,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
16261    G__memfunc_setup("G116f2",375,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
16262    G__memfunc_setup("Rzero",530,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 6, 1, 4, 8, 
16263 "d - - 0 - a d - - 0 - b "
16264 "d - - 1 - x0 d - - 0 - eps "
16265 "i - - 0 - mxf 1 - 'double (*)(double)const' 0 - f", (char*)NULL, (void*) NULL, 0);
16266    G__memfunc_setup("E1plLog",628,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 3, 4, 0, "d - - 0 - x", "Calculates log(|x|)+E_1(x)", (void*) NULL, 0);
16267    // automatic copy constructor
16268    G__memfunc_setup("VavilovAccurate", 1551, G__G__MathMore_241_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccurate' - 11 - -", (char*) NULL, (void*) NULL, 0);
16269    // automatic destructor
16270    G__memfunc_setup("~VavilovAccurate", 1677, G__G__MathMore_241_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16271    // automatic assignment operator
16272    G__memfunc_setup("operator=", 937, G__G__MathMore_241_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccurate' - 11 - -", (char*) NULL, (void*) NULL, 0);
16273    G__tag_memfunc_reset();
16274 }
16275 
16276 static void G__setup_memfuncROOTcLcLMathcLcLVavilovAccuratePdf(void) {
16277    /* ROOT::Math::VavilovAccuratePdf */
16278    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf));
16279    G__memfunc_setup("VavilovAccuratePdf",1833,G__G__MathMore_243_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16280    G__memfunc_setup("VavilovAccuratePdf",1833,G__G__MathMore_243_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf), -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 0);
16281    G__memfunc_setup("Parameters",1044,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16282    G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 1);
16283    G__memfunc_setup("NPar",369,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16284    G__memfunc_setup("ParameterName",1314,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 1);
16285    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16286    G__memfunc_setup("DoEvalPar",862,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
16287 "d - - 0 - x D - - 10 - p", (char*)NULL, (void*) NULL, 1);
16288    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16289    // automatic copy constructor
16290    G__memfunc_setup("VavilovAccuratePdf", 1833, G__G__MathMore_243_0_10, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccuratePdf' - 11 - -", (char*) NULL, (void*) NULL, 0);
16291    // automatic destructor
16292    G__memfunc_setup("~VavilovAccuratePdf", 1959, G__G__MathMore_243_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16293    // automatic assignment operator
16294    G__memfunc_setup("operator=", 937, G__G__MathMore_243_0_12, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccuratePdf' - 11 - -", (char*) NULL, (void*) NULL, 0);
16295    G__tag_memfunc_reset();
16296 }
16297 
16298 static void G__setup_memfuncROOTcLcLMathcLcLVavilovAccurateCdf(void) {
16299    /* ROOT::Math::VavilovAccurateCdf */
16300    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf));
16301    G__memfunc_setup("VavilovAccurateCdf",1820,G__G__MathMore_244_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16302    G__memfunc_setup("VavilovAccurateCdf",1820,G__G__MathMore_244_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf), -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 0);
16303    G__memfunc_setup("Parameters",1044,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16304    G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 1);
16305    G__memfunc_setup("NPar",369,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16306    G__memfunc_setup("ParameterName",1314,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 1);
16307    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16308    G__memfunc_setup("DoEvalPar",862,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
16309 "d - - 0 - x D - - 10 - p", (char*)NULL, (void*) NULL, 1);
16310    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16311    // automatic copy constructor
16312    G__memfunc_setup("VavilovAccurateCdf", 1820, G__G__MathMore_244_0_10, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccurateCdf' - 11 - -", (char*) NULL, (void*) NULL, 0);
16313    // automatic destructor
16314    G__memfunc_setup("~VavilovAccurateCdf", 1946, G__G__MathMore_244_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16315    // automatic assignment operator
16316    G__memfunc_setup("operator=", 937, G__G__MathMore_244_0_12, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccurateCdf' - 11 - -", (char*) NULL, (void*) NULL, 0);
16317    G__tag_memfunc_reset();
16318 }
16319 
16320 static void G__setup_memfuncROOTcLcLMathcLcLVavilovAccurateQuantile(void) {
16321    /* ROOT::Math::VavilovAccurateQuantile */
16322    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile));
16323    G__memfunc_setup("VavilovAccurateQuantile",2386,G__G__MathMore_245_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16324    G__memfunc_setup("VavilovAccurateQuantile",2386,G__G__MathMore_245_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile), -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 0);
16325    G__memfunc_setup("Parameters",1044,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
16326    G__memfunc_setup("SetParameters",1344,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - p", (char*)NULL, (void*) NULL, 1);
16327    G__memfunc_setup("NPar",369,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16328    G__memfunc_setup("ParameterName",1314,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 1);
16329    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16330    G__memfunc_setup("DoEvalPar",862,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
16331 "d - - 0 - x D - - 10 - p", (char*)NULL, (void*) NULL, 1);
16332    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16333    // automatic copy constructor
16334    G__memfunc_setup("VavilovAccurateQuantile", 2386, G__G__MathMore_245_0_10, (int) ('i'), 
16335 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccurateQuantile' - 11 - -", (char*) NULL, (void*) NULL, 0);
16336    // automatic destructor
16337    G__memfunc_setup("~VavilovAccurateQuantile", 2512, G__G__MathMore_245_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16338    // automatic assignment operator
16339    G__memfunc_setup("operator=", 937, G__G__MathMore_245_0_12, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::VavilovAccurateQuantile' - 11 - -", (char*) NULL, (void*) NULL, 0);
16340    G__tag_memfunc_reset();
16341 }
16342 
16343 static void G__setup_memfuncROOTcLcLMathcLcLVavilovFast(void) {
16344    /* ROOT::Math::VavilovFast */
16345    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast));
16346    G__memfunc_setup("VavilovFast",1141,G__G__MathMore_246_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast), -1, 0, 2, 1, 1, 0, 
16347 "d - - 0 '1' kappa d - - 0 '1' beta2", (char*)NULL, (void*) NULL, 0);
16348    G__memfunc_setup("Pdf",282,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16349    G__memfunc_setup("Pdf",282,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16350 "d - - 0 - x d - - 0 - kappa "
16351 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16352    G__memfunc_setup("Cdf",269,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16353    G__memfunc_setup("Cdf",269,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16354 "d - - 0 - x d - - 0 - kappa "
16355 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16356    G__memfunc_setup("Cdf_c",463,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - x", (char*)NULL, (void*) NULL, 1);
16357    G__memfunc_setup("Cdf_c",463,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16358 "d - - 0 - x d - - 0 - kappa "
16359 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16360    G__memfunc_setup("Quantile",835,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - z", (char*)NULL, (void*) NULL, 1);
16361    G__memfunc_setup("Quantile",835,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16362 "d - - 0 - z d - - 0 - kappa "
16363 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16364    G__memfunc_setup("Quantile_c",1029,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "d - - 0 - z", (char*)NULL, (void*) NULL, 1);
16365    G__memfunc_setup("Quantile_c",1029,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 0, 
16366 "d - - 0 - z d - - 0 - kappa "
16367 "d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16368    G__memfunc_setup("SetKappaBeta2",1223,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
16369 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) NULL, 1);
16370    G__memfunc_setup("GetLambdaMin",1157,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16371    G__memfunc_setup("GetLambdaMax",1159,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16372    G__memfunc_setup("GetKappa",781,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16373    G__memfunc_setup("GetBeta2",718,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16374    G__memfunc_setup("GetInstance",1109,G__G__MathMore_246_0_17, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (ROOT::Math::VavilovFast* (*)())(&ROOT::Math::VavilovFast::GetInstance) ), 0);
16375    G__memfunc_setup("GetInstance",1109,G__G__MathMore_246_0_18, 85, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast), -1, 0, 2, 3, 1, 0, 
16376 "d - - 0 - kappa d - - 0 - beta2", (char*)NULL, (void*) G__func2void( (ROOT::Math::VavilovFast* (*)(double, double))(&ROOT::Math::VavilovFast::GetInstance) ), 0);
16377    // automatic copy constructor
16378    G__memfunc_setup("VavilovFast", 1141, G__G__MathMore_246_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::VavilovFast' - 11 - -", (char*) NULL, (void*) NULL, 0);
16379    // automatic destructor
16380    G__memfunc_setup("~VavilovFast", 1267, G__G__MathMore_246_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16381    // automatic assignment operator
16382    G__memfunc_setup("operator=", 937, G__G__MathMore_246_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::VavilovFast' - 11 - -", (char*) NULL, (void*) NULL, 0);
16383    G__tag_memfunc_reset();
16384 }
16385 
16386 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR(void) {
16387    /* ROOT::Math::Random<ROOT::Math::GSLRngMT> */
16388    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR));
16389    G__memfunc_setup("Random<ROOT::Math::GSLRngMT>",2367,G__G__MathMore_247_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16390    G__memfunc_setup("Random<ROOT::Math::GSLRngMT>",2367,G__G__MathMore_247_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16391    G__memfunc_setup("Random<ROOT::Math::GSLRngMT>",2367,G__G__MathMore_247_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngMT' - 11 - e", (char*)NULL, (void*) NULL, 0);
16392    G__memfunc_setup("Uniform",736,G__G__MathMore_247_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16393    G__memfunc_setup("Rndm",401,G__G__MathMore_247_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16394    G__memfunc_setup("RndmArray",912,G__G__MathMore_247_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16395 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16396    G__memfunc_setup("Type",418,G__G__MathMore_247_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16397    G__memfunc_setup("EngineSize",1009,G__G__MathMore_247_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16398    G__memfunc_setup("SetSeed",685,G__G__MathMore_247_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16399    G__memfunc_setup("Gaus",400,G__G__MathMore_247_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16400 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16401    G__memfunc_setup("GausBM",543,G__G__MathMore_247_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16402 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16403    G__memfunc_setup("GausR",482,G__G__MathMore_247_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16404 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16405    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_247_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16406 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16407    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_247_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16408 "d - - 0 - sigmaX d - - 0 - sigmaY "
16409 "d - - 0 - rho d - - 1 - x "
16410 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16411    G__memfunc_setup("Exp",301,G__G__MathMore_247_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16412    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_247_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16413 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16414    G__memfunc_setup("Landau",597,G__G__MathMore_247_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16415 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16416    G__memfunc_setup("Gamma",483,G__G__MathMore_247_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16417 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16418    G__memfunc_setup("LogNormal",907,G__G__MathMore_247_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16419 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16420    G__memfunc_setup("ChiSquare",901,G__G__MathMore_247_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16421    G__memfunc_setup("FDist",474,G__G__MathMore_247_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16422 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16423    G__memfunc_setup("tDist",520,G__G__MathMore_247_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16424    G__memfunc_setup("Circle",594,G__G__MathMore_247_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16425 "d - - 1 - x d - - 1 - y "
16426 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16427    G__memfunc_setup("Sphere",615,G__G__MathMore_247_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16428 "d - - 1 - x d - - 1 - y "
16429 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16430    G__memfunc_setup("Poisson",747,G__G__MathMore_247_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16431    G__memfunc_setup("Binomial",811,G__G__MathMore_247_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16432 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16433    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_247_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16434 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16435    G__memfunc_setup("Multinomial",1163,G__G__MathMore_247_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16436 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16437    // automatic copy constructor
16438    G__memfunc_setup("Random<ROOT::Math::GSLRngMT>", 2367, G__G__MathMore_247_0_29, (int) ('i'), 
16439 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngMT>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16440    // automatic destructor
16441    G__memfunc_setup("~Random<ROOT::Math::GSLRngMT>", 2493, G__G__MathMore_247_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16442    // automatic assignment operator
16443    G__memfunc_setup("operator=", 937, G__G__MathMore_247_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngMT>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16444    G__tag_memfunc_reset();
16445 }
16446 
16447 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR(void) {
16448    /* ROOT::Math::Random<ROOT::Math::GSLRngTaus> */
16449    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR));
16450    G__memfunc_setup("Random<ROOT::Math::GSLRngTaus>",2619,G__G__MathMore_248_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16451    G__memfunc_setup("Random<ROOT::Math::GSLRngTaus>",2619,G__G__MathMore_248_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16452    G__memfunc_setup("Random<ROOT::Math::GSLRngTaus>",2619,G__G__MathMore_248_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngTaus' - 11 - e", (char*)NULL, (void*) NULL, 0);
16453    G__memfunc_setup("Uniform",736,G__G__MathMore_248_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16454    G__memfunc_setup("Rndm",401,G__G__MathMore_248_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16455    G__memfunc_setup("RndmArray",912,G__G__MathMore_248_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16456 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16457    G__memfunc_setup("Type",418,G__G__MathMore_248_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16458    G__memfunc_setup("EngineSize",1009,G__G__MathMore_248_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16459    G__memfunc_setup("SetSeed",685,G__G__MathMore_248_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16460    G__memfunc_setup("Gaus",400,G__G__MathMore_248_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16461 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16462    G__memfunc_setup("GausBM",543,G__G__MathMore_248_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16463 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16464    G__memfunc_setup("GausR",482,G__G__MathMore_248_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16465 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16466    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_248_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16467 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16468    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_248_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16469 "d - - 0 - sigmaX d - - 0 - sigmaY "
16470 "d - - 0 - rho d - - 1 - x "
16471 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16472    G__memfunc_setup("Exp",301,G__G__MathMore_248_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16473    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_248_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16474 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16475    G__memfunc_setup("Landau",597,G__G__MathMore_248_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16476 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16477    G__memfunc_setup("Gamma",483,G__G__MathMore_248_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16478 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16479    G__memfunc_setup("LogNormal",907,G__G__MathMore_248_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16480 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16481    G__memfunc_setup("ChiSquare",901,G__G__MathMore_248_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16482    G__memfunc_setup("FDist",474,G__G__MathMore_248_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16483 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16484    G__memfunc_setup("tDist",520,G__G__MathMore_248_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16485    G__memfunc_setup("Circle",594,G__G__MathMore_248_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16486 "d - - 1 - x d - - 1 - y "
16487 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16488    G__memfunc_setup("Sphere",615,G__G__MathMore_248_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16489 "d - - 1 - x d - - 1 - y "
16490 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16491    G__memfunc_setup("Poisson",747,G__G__MathMore_248_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16492    G__memfunc_setup("Binomial",811,G__G__MathMore_248_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16493 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16494    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_248_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16495 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16496    G__memfunc_setup("Multinomial",1163,G__G__MathMore_248_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16497 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16498    // automatic copy constructor
16499    G__memfunc_setup("Random<ROOT::Math::GSLRngTaus>", 2619, G__G__MathMore_248_0_29, (int) ('i'), 
16500 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngTaus>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16501    // automatic destructor
16502    G__memfunc_setup("~Random<ROOT::Math::GSLRngTaus>", 2745, G__G__MathMore_248_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16503    // automatic assignment operator
16504    G__memfunc_setup("operator=", 937, G__G__MathMore_248_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngTaus>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16505    G__tag_memfunc_reset();
16506 }
16507 
16508 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR(void) {
16509    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLux> */
16510    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR));
16511    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLux>",2808,G__G__MathMore_249_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16512    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLux>",2808,G__G__MathMore_249_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16513    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLux>",2808,G__G__MathMore_249_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngRanLux' - 11 - e", (char*)NULL, (void*) NULL, 0);
16514    G__memfunc_setup("Uniform",736,G__G__MathMore_249_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16515    G__memfunc_setup("Rndm",401,G__G__MathMore_249_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16516    G__memfunc_setup("RndmArray",912,G__G__MathMore_249_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16517 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16518    G__memfunc_setup("Type",418,G__G__MathMore_249_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16519    G__memfunc_setup("EngineSize",1009,G__G__MathMore_249_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16520    G__memfunc_setup("SetSeed",685,G__G__MathMore_249_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16521    G__memfunc_setup("Gaus",400,G__G__MathMore_249_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16522 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16523    G__memfunc_setup("GausBM",543,G__G__MathMore_249_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16524 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16525    G__memfunc_setup("GausR",482,G__G__MathMore_249_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16526 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16527    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_249_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16528 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16529    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_249_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16530 "d - - 0 - sigmaX d - - 0 - sigmaY "
16531 "d - - 0 - rho d - - 1 - x "
16532 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16533    G__memfunc_setup("Exp",301,G__G__MathMore_249_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16534    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_249_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16535 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16536    G__memfunc_setup("Landau",597,G__G__MathMore_249_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16537 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16538    G__memfunc_setup("Gamma",483,G__G__MathMore_249_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16539 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16540    G__memfunc_setup("LogNormal",907,G__G__MathMore_249_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16541 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16542    G__memfunc_setup("ChiSquare",901,G__G__MathMore_249_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16543    G__memfunc_setup("FDist",474,G__G__MathMore_249_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16544 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16545    G__memfunc_setup("tDist",520,G__G__MathMore_249_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16546    G__memfunc_setup("Circle",594,G__G__MathMore_249_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16547 "d - - 1 - x d - - 1 - y "
16548 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16549    G__memfunc_setup("Sphere",615,G__G__MathMore_249_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16550 "d - - 1 - x d - - 1 - y "
16551 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16552    G__memfunc_setup("Poisson",747,G__G__MathMore_249_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16553    G__memfunc_setup("Binomial",811,G__G__MathMore_249_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16554 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16555    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_249_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16556 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16557    G__memfunc_setup("Multinomial",1163,G__G__MathMore_249_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16558 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16559    // automatic copy constructor
16560    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLux>", 2808, G__G__MathMore_249_0_29, (int) ('i'), 
16561 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLux>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16562    // automatic destructor
16563    G__memfunc_setup("~Random<ROOT::Math::GSLRngRanLux>", 2934, G__G__MathMore_249_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16564    // automatic assignment operator
16565    G__memfunc_setup("operator=", 937, G__G__MathMore_249_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLux>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16566    G__tag_memfunc_reset();
16567 }
16568 
16569 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR(void) {
16570    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1> */
16571    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR));
16572    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS1>",2940,G__G__MathMore_250_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16573    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS1>",2940,G__G__MathMore_250_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16574    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS1>",2940,G__G__MathMore_250_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngRanLuxS1' - 11 - e", (char*)NULL, (void*) NULL, 0);
16575    G__memfunc_setup("Uniform",736,G__G__MathMore_250_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16576    G__memfunc_setup("Rndm",401,G__G__MathMore_250_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16577    G__memfunc_setup("RndmArray",912,G__G__MathMore_250_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16578 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16579    G__memfunc_setup("Type",418,G__G__MathMore_250_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16580    G__memfunc_setup("EngineSize",1009,G__G__MathMore_250_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16581    G__memfunc_setup("SetSeed",685,G__G__MathMore_250_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16582    G__memfunc_setup("Gaus",400,G__G__MathMore_250_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16583 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16584    G__memfunc_setup("GausBM",543,G__G__MathMore_250_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16585 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16586    G__memfunc_setup("GausR",482,G__G__MathMore_250_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16587 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16588    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_250_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16589 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16590    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_250_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16591 "d - - 0 - sigmaX d - - 0 - sigmaY "
16592 "d - - 0 - rho d - - 1 - x "
16593 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16594    G__memfunc_setup("Exp",301,G__G__MathMore_250_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16595    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_250_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16596 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16597    G__memfunc_setup("Landau",597,G__G__MathMore_250_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16598 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16599    G__memfunc_setup("Gamma",483,G__G__MathMore_250_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16600 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16601    G__memfunc_setup("LogNormal",907,G__G__MathMore_250_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16602 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16603    G__memfunc_setup("ChiSquare",901,G__G__MathMore_250_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16604    G__memfunc_setup("FDist",474,G__G__MathMore_250_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16605 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16606    G__memfunc_setup("tDist",520,G__G__MathMore_250_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16607    G__memfunc_setup("Circle",594,G__G__MathMore_250_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16608 "d - - 1 - x d - - 1 - y "
16609 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16610    G__memfunc_setup("Sphere",615,G__G__MathMore_250_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16611 "d - - 1 - x d - - 1 - y "
16612 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16613    G__memfunc_setup("Poisson",747,G__G__MathMore_250_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16614    G__memfunc_setup("Binomial",811,G__G__MathMore_250_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16615 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16616    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_250_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16617 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16618    G__memfunc_setup("Multinomial",1163,G__G__MathMore_250_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16619 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16620    // automatic copy constructor
16621    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS1>", 2940, G__G__MathMore_250_0_29, (int) ('i'), 
16622 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16623    // automatic destructor
16624    G__memfunc_setup("~Random<ROOT::Math::GSLRngRanLuxS1>", 3066, G__G__MathMore_250_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16625    // automatic assignment operator
16626    G__memfunc_setup("operator=", 937, G__G__MathMore_250_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16627    G__tag_memfunc_reset();
16628 }
16629 
16630 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR(void) {
16631    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2> */
16632    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR));
16633    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS2>",2941,G__G__MathMore_251_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16634    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS2>",2941,G__G__MathMore_251_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16635    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS2>",2941,G__G__MathMore_251_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngRanLuxS2' - 11 - e", (char*)NULL, (void*) NULL, 0);
16636    G__memfunc_setup("Uniform",736,G__G__MathMore_251_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16637    G__memfunc_setup("Rndm",401,G__G__MathMore_251_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16638    G__memfunc_setup("RndmArray",912,G__G__MathMore_251_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16639 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16640    G__memfunc_setup("Type",418,G__G__MathMore_251_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16641    G__memfunc_setup("EngineSize",1009,G__G__MathMore_251_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16642    G__memfunc_setup("SetSeed",685,G__G__MathMore_251_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16643    G__memfunc_setup("Gaus",400,G__G__MathMore_251_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16644 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16645    G__memfunc_setup("GausBM",543,G__G__MathMore_251_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16646 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16647    G__memfunc_setup("GausR",482,G__G__MathMore_251_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16648 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16649    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_251_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16650 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16651    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_251_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16652 "d - - 0 - sigmaX d - - 0 - sigmaY "
16653 "d - - 0 - rho d - - 1 - x "
16654 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16655    G__memfunc_setup("Exp",301,G__G__MathMore_251_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16656    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_251_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16657 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16658    G__memfunc_setup("Landau",597,G__G__MathMore_251_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16659 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16660    G__memfunc_setup("Gamma",483,G__G__MathMore_251_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16661 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16662    G__memfunc_setup("LogNormal",907,G__G__MathMore_251_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16663 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16664    G__memfunc_setup("ChiSquare",901,G__G__MathMore_251_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16665    G__memfunc_setup("FDist",474,G__G__MathMore_251_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16666 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16667    G__memfunc_setup("tDist",520,G__G__MathMore_251_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16668    G__memfunc_setup("Circle",594,G__G__MathMore_251_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16669 "d - - 1 - x d - - 1 - y "
16670 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16671    G__memfunc_setup("Sphere",615,G__G__MathMore_251_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16672 "d - - 1 - x d - - 1 - y "
16673 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16674    G__memfunc_setup("Poisson",747,G__G__MathMore_251_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16675    G__memfunc_setup("Binomial",811,G__G__MathMore_251_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16676 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16677    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_251_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16678 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16679    G__memfunc_setup("Multinomial",1163,G__G__MathMore_251_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16680 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16681    // automatic copy constructor
16682    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxS2>", 2941, G__G__MathMore_251_0_29, (int) ('i'), 
16683 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16684    // automatic destructor
16685    G__memfunc_setup("~Random<ROOT::Math::GSLRngRanLuxS2>", 3067, G__G__MathMore_251_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16686    // automatic assignment operator
16687    G__memfunc_setup("operator=", 937, G__G__MathMore_251_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16688    G__tag_memfunc_reset();
16689 }
16690 
16691 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR(void) {
16692    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1> */
16693    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR));
16694    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD1>",2925,G__G__MathMore_252_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16695    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD1>",2925,G__G__MathMore_252_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16696    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD1>",2925,G__G__MathMore_252_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngRanLuxD1' - 11 - e", (char*)NULL, (void*) NULL, 0);
16697    G__memfunc_setup("Uniform",736,G__G__MathMore_252_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16698    G__memfunc_setup("Rndm",401,G__G__MathMore_252_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16699    G__memfunc_setup("RndmArray",912,G__G__MathMore_252_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16700 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16701    G__memfunc_setup("Type",418,G__G__MathMore_252_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16702    G__memfunc_setup("EngineSize",1009,G__G__MathMore_252_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16703    G__memfunc_setup("SetSeed",685,G__G__MathMore_252_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16704    G__memfunc_setup("Gaus",400,G__G__MathMore_252_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16705 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16706    G__memfunc_setup("GausBM",543,G__G__MathMore_252_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16707 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16708    G__memfunc_setup("GausR",482,G__G__MathMore_252_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16709 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16710    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_252_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16711 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16712    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_252_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16713 "d - - 0 - sigmaX d - - 0 - sigmaY "
16714 "d - - 0 - rho d - - 1 - x "
16715 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16716    G__memfunc_setup("Exp",301,G__G__MathMore_252_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16717    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_252_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16718 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16719    G__memfunc_setup("Landau",597,G__G__MathMore_252_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16720 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16721    G__memfunc_setup("Gamma",483,G__G__MathMore_252_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16722 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16723    G__memfunc_setup("LogNormal",907,G__G__MathMore_252_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16724 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16725    G__memfunc_setup("ChiSquare",901,G__G__MathMore_252_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16726    G__memfunc_setup("FDist",474,G__G__MathMore_252_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16727 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16728    G__memfunc_setup("tDist",520,G__G__MathMore_252_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16729    G__memfunc_setup("Circle",594,G__G__MathMore_252_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16730 "d - - 1 - x d - - 1 - y "
16731 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16732    G__memfunc_setup("Sphere",615,G__G__MathMore_252_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16733 "d - - 1 - x d - - 1 - y "
16734 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16735    G__memfunc_setup("Poisson",747,G__G__MathMore_252_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16736    G__memfunc_setup("Binomial",811,G__G__MathMore_252_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16737 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16738    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_252_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16739 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16740    G__memfunc_setup("Multinomial",1163,G__G__MathMore_252_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16741 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16742    // automatic copy constructor
16743    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD1>", 2925, G__G__MathMore_252_0_29, (int) ('i'), 
16744 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16745    // automatic destructor
16746    G__memfunc_setup("~Random<ROOT::Math::GSLRngRanLuxD1>", 3051, G__G__MathMore_252_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16747    // automatic assignment operator
16748    G__memfunc_setup("operator=", 937, G__G__MathMore_252_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16749    G__tag_memfunc_reset();
16750 }
16751 
16752 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR(void) {
16753    /* ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2> */
16754    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR));
16755    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD2>",2926,G__G__MathMore_253_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16756    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD2>",2926,G__G__MathMore_253_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16757    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD2>",2926,G__G__MathMore_253_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngRanLuxD2' - 11 - e", (char*)NULL, (void*) NULL, 0);
16758    G__memfunc_setup("Uniform",736,G__G__MathMore_253_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16759    G__memfunc_setup("Rndm",401,G__G__MathMore_253_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16760    G__memfunc_setup("RndmArray",912,G__G__MathMore_253_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16761 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16762    G__memfunc_setup("Type",418,G__G__MathMore_253_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16763    G__memfunc_setup("EngineSize",1009,G__G__MathMore_253_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16764    G__memfunc_setup("SetSeed",685,G__G__MathMore_253_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16765    G__memfunc_setup("Gaus",400,G__G__MathMore_253_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16766 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16767    G__memfunc_setup("GausBM",543,G__G__MathMore_253_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16768 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16769    G__memfunc_setup("GausR",482,G__G__MathMore_253_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16770 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16771    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_253_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16772 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16773    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_253_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16774 "d - - 0 - sigmaX d - - 0 - sigmaY "
16775 "d - - 0 - rho d - - 1 - x "
16776 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16777    G__memfunc_setup("Exp",301,G__G__MathMore_253_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16778    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_253_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16779 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16780    G__memfunc_setup("Landau",597,G__G__MathMore_253_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16781 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16782    G__memfunc_setup("Gamma",483,G__G__MathMore_253_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16783 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16784    G__memfunc_setup("LogNormal",907,G__G__MathMore_253_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16785 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16786    G__memfunc_setup("ChiSquare",901,G__G__MathMore_253_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16787    G__memfunc_setup("FDist",474,G__G__MathMore_253_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16788 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16789    G__memfunc_setup("tDist",520,G__G__MathMore_253_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16790    G__memfunc_setup("Circle",594,G__G__MathMore_253_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16791 "d - - 1 - x d - - 1 - y "
16792 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16793    G__memfunc_setup("Sphere",615,G__G__MathMore_253_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16794 "d - - 1 - x d - - 1 - y "
16795 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16796    G__memfunc_setup("Poisson",747,G__G__MathMore_253_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16797    G__memfunc_setup("Binomial",811,G__G__MathMore_253_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16798 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16799    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_253_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16800 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16801    G__memfunc_setup("Multinomial",1163,G__G__MathMore_253_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16802 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16803    // automatic copy constructor
16804    G__memfunc_setup("Random<ROOT::Math::GSLRngRanLuxD2>", 2926, G__G__MathMore_253_0_29, (int) ('i'), 
16805 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16806    // automatic destructor
16807    G__memfunc_setup("~Random<ROOT::Math::GSLRngRanLuxD2>", 3052, G__G__MathMore_253_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16808    // automatic assignment operator
16809    G__memfunc_setup("operator=", 937, G__G__MathMore_253_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16810    G__tag_memfunc_reset();
16811 }
16812 
16813 static void G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR(void) {
16814    /* ROOT::Math::Random<ROOT::Math::GSLRngGFSR4> */
16815    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR));
16816    G__memfunc_setup("Random<ROOT::Math::GSLRngGFSR4>",2564,G__G__MathMore_254_0_1, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16817    G__memfunc_setup("Random<ROOT::Math::GSLRngGFSR4>",2564,G__G__MathMore_254_0_2, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR), -1, 0, 1, 5, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16818    G__memfunc_setup("Random<ROOT::Math::GSLRngGFSR4>",2564,G__G__MathMore_254_0_3, 105, G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR), -1, 0, 1, 5, 1, 0, "u 'ROOT::Math::GSLRngGFSR4' - 11 - e", (char*)NULL, (void*) NULL, 0);
16819    G__memfunc_setup("Uniform",736,G__G__MathMore_254_0_4, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 '1.0' x", (char*)NULL, (void*) NULL, 0);
16820    G__memfunc_setup("Rndm",401,G__G__MathMore_254_0_5, 100, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16821    G__memfunc_setup("RndmArray",912,G__G__MathMore_254_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
16822 "i - - 0 - n D - - 0 - array", (char*)NULL, (void*) NULL, 0);
16823    G__memfunc_setup("Type",418,G__G__MathMore_254_0_7, 117, G__get_linked_tagnum(&G__G__MathMoreLN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16824    G__memfunc_setup("EngineSize",1009,G__G__MathMore_254_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16825    G__memfunc_setup("SetSeed",685,G__G__MathMore_254_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - seed", (char*)NULL, (void*) NULL, 0);
16826    G__memfunc_setup("Gaus",400,G__G__MathMore_254_0_10, 100, -1, -1, 0, 2, 1, 1, 0, 
16827 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16828    G__memfunc_setup("GausBM",543,G__G__MathMore_254_0_11, 100, -1, -1, 0, 2, 1, 1, 0, 
16829 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16830    G__memfunc_setup("GausR",482,G__G__MathMore_254_0_12, 100, -1, -1, 0, 2, 1, 1, 0, 
16831 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16832    G__memfunc_setup("GaussianTail",1221,G__G__MathMore_254_0_13, 100, -1, -1, 0, 2, 1, 1, 0, 
16833 "d - - 0 - a d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16834    G__memfunc_setup("Gaussian2D",945,G__G__MathMore_254_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
16835 "d - - 0 - sigmaX d - - 0 - sigmaY "
16836 "d - - 0 - rho d - - 1 - x "
16837 "d - - 1 - y", (char*)NULL, (void*) NULL, 0);
16838    G__memfunc_setup("Exp",301,G__G__MathMore_254_0_15, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - tau", (char*)NULL, (void*) NULL, 0);
16839    G__memfunc_setup("BreitWigner",1122,G__G__MathMore_254_0_16, 100, -1, -1, 0, 2, 1, 1, 0, 
16840 "d - - 0 '0.' mean d - - 0 '1' gamma", (char*)NULL, (void*) NULL, 0);
16841    G__memfunc_setup("Landau",597,G__G__MathMore_254_0_17, 100, -1, -1, 0, 2, 1, 1, 0, 
16842 "d - - 0 '0' mean d - - 0 '1' sigma", (char*)NULL, (void*) NULL, 0);
16843    G__memfunc_setup("Gamma",483,G__G__MathMore_254_0_18, 100, -1, -1, 0, 2, 1, 1, 0, 
16844 "d - - 0 - a d - - 0 - b", (char*)NULL, (void*) NULL, 0);
16845    G__memfunc_setup("LogNormal",907,G__G__MathMore_254_0_19, 100, -1, -1, 0, 2, 1, 1, 0, 
16846 "d - - 0 - zeta d - - 0 - sigma", (char*)NULL, (void*) NULL, 0);
16847    G__memfunc_setup("ChiSquare",901,G__G__MathMore_254_0_20, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16848    G__memfunc_setup("FDist",474,G__G__MathMore_254_0_21, 100, -1, -1, 0, 2, 1, 1, 0, 
16849 "d - - 0 - nu1 d - - 0 - nu2", (char*)NULL, (void*) NULL, 0);
16850    G__memfunc_setup("tDist",520,G__G__MathMore_254_0_22, 100, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - nu", (char*)NULL, (void*) NULL, 0);
16851    G__memfunc_setup("Circle",594,G__G__MathMore_254_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
16852 "d - - 1 - x d - - 1 - y "
16853 "d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16854    G__memfunc_setup("Sphere",615,G__G__MathMore_254_0_24, 121, -1, -1, 0, 4, 1, 1, 0, 
16855 "d - - 1 - x d - - 1 - y "
16856 "d - - 1 - z d - - 0 '1' r", (char*)NULL, (void*) NULL, 0);
16857    G__memfunc_setup("Poisson",747,G__G__MathMore_254_0_25, 104, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mu", (char*)NULL, (void*) NULL, 0);
16858    G__memfunc_setup("Binomial",811,G__G__MathMore_254_0_26, 104, -1, -1, 0, 2, 1, 1, 0, 
16859 "h - - 0 - ntot d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16860    G__memfunc_setup("NegativeBinomial",1630,G__G__MathMore_254_0_27, 104, -1, -1, 0, 2, 1, 1, 0, 
16861 "d - - 0 - n d - - 0 - prob", (char*)NULL, (void*) NULL, 0);
16862    G__memfunc_setup("Multinomial",1163,G__G__MathMore_254_0_28, 117, G__get_linked_tagnum(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 0, 2, 1, 1, 0, 
16863 "h - - 0 - ntot u 'vector<double,allocator<double> >' 'vector<double>' 11 - p", (char*)NULL, (void*) NULL, 0);
16864    // automatic copy constructor
16865    G__memfunc_setup("Random<ROOT::Math::GSLRngGFSR4>", 2564, G__G__MathMore_254_0_29, (int) ('i'), 
16866 G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16867    // automatic destructor
16868    G__memfunc_setup("~Random<ROOT::Math::GSLRngGFSR4>", 2690, G__G__MathMore_254_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16869    // automatic assignment operator
16870    G__memfunc_setup("operator=", 937, G__G__MathMore_254_0_31, (int) ('u'), G__get_linked_tagnum(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR), -1, 1, 1, 1, 1, 0, "u 'ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>' - 11 - -", (char*) NULL, (void*) NULL, 0);
16871    G__tag_memfunc_reset();
16872 }
16873 
16874 
16875 /*********************************************************
16876 * Member function information setup
16877 *********************************************************/
16878 extern "C" void G__cpp_setup_memfuncG__MathMore() {
16879 }
16880 
16881 /*********************************************************
16882 * Global variable information setup for each class
16883 *********************************************************/
16884 static void G__cpp_setup_global0() {
16885 
16886    /* Setting up global variables */
16887    G__resetplocal();
16888 
16889 }
16890 
16891 static void G__cpp_setup_global1() {
16892    G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"ROOT_Math_PdfFuncMathMore=0",1,(char*)NULL);
16893    G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"ROOT_Math_QuantFuncMathMore=0",1,(char*)NULL);
16894    G__memvar_setup((void*)G__PVOID,112,0,0,-1,-1,-1,1,"ROOT_Math_SpecFuncMathMore=0",1,(char*)NULL);
16895 }
16896 
16897 static void G__cpp_setup_global2() {
16898 
16899    G__resetglobalenv();
16900 }
16901 extern "C" void G__cpp_setup_globalG__MathMore() {
16902   G__cpp_setup_global0();
16903   G__cpp_setup_global1();
16904   G__cpp_setup_global2();
16905 }
16906 
16907 /*********************************************************
16908 * Global function information setup for each class
16909 *********************************************************/
16910 static void G__cpp_setup_func0() {
16911    G__lastifuncposition();
16912 
16913 }
16914 
16915 static void G__cpp_setup_func1() {
16916 }
16917 
16918 static void G__cpp_setup_func2() {
16919 }
16920 
16921 static void G__cpp_setup_func3() {
16922 }
16923 
16924 static void G__cpp_setup_func4() {
16925 }
16926 
16927 static void G__cpp_setup_func5() {
16928 }
16929 
16930 static void G__cpp_setup_func6() {
16931 }
16932 
16933 static void G__cpp_setup_func7() {
16934 
16935    G__resetifuncposition();
16936 }
16937 
16938 extern "C" void G__cpp_setup_funcG__MathMore() {
16939   G__cpp_setup_func0();
16940   G__cpp_setup_func1();
16941   G__cpp_setup_func2();
16942   G__cpp_setup_func3();
16943   G__cpp_setup_func4();
16944   G__cpp_setup_func5();
16945   G__cpp_setup_func6();
16946   G__cpp_setup_func7();
16947 }
16948 
16949 /*********************************************************
16950 * Class,struct,union,enum tag information setup
16951 *********************************************************/
16952 /* Setup class/struct taginfo */
16953 G__linked_taginfo G__G__MathMoreLN_type_info = { "type_info" , 99 , -1 };
16954 G__linked_taginfo G__G__MathMoreLN_TClass = { "TClass" , 99 , -1 };
16955 G__linked_taginfo G__G__MathMoreLN_TNamed = { "TNamed" , 99 , -1 };
16956 G__linked_taginfo G__G__MathMoreLN_TVirtualIsAProxy = { "TVirtualIsAProxy" , 99 , -1 };
16957 G__linked_taginfo G__G__MathMoreLN_ROOT = { "ROOT" , 110 , -1 };
16958 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLTInitBehavior = { "ROOT::TInitBehavior" , 99 , -1 };
16959 G__linked_taginfo G__G__MathMoreLN_string = { "string" , 99 , -1 };
16960 G__linked_taginfo G__G__MathMoreLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
16961 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
16962 G__linked_taginfo G__G__MathMoreLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
16963 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
16964 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMath = { "ROOT::Math" , 110 , -1 };
16965 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathMore = { "ROOT::MathMore" , 110 , -1 };
16966 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim = { "ROOT::Math::IBaseFunctionOneDim" , 99 , -1 };
16967 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionOneDim = { "ROOT::Math::IGradientFunctionOneDim" , 99 , -1 };
16968 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim = { "ROOT::Math::IBaseFunctionMultiDim" , 99 , -1 };
16969 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim = { "ROOT::Math::IGradientFunctionMultiDim" , 99 , -1 };
16970 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientMultiDim = { "ROOT::Math::IGradientMultiDim" , 99 , -1 };
16971 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientOneDim = { "ROOT::Math::IGradientOneDim" , 99 , -1 };
16972 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim = { "ROOT::Math::IParametricFunctionOneDim" , 99 , -1 };
16973 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim = { "ROOT::Math::IParametricGradFunctionOneDim" , 99 , -1 };
16974 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim = { "ROOT::Math::IParametricFunctionMultiDim" , 99 , -1 };
16975 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim = { "ROOT::Math::IParametricGradFunctionMultiDim" , 99 , -1 };
16976 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam = { "ROOT::Math::IBaseParam" , 99 , -1 };
16977 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial = { "ROOT::Math::Polynomial" , 99 , -1 };
16978 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR = { "ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>" , 99 , -1 };
16979 G__linked_taginfo G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
16980 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
16981 G__linked_taginfo G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR = { "vector<complex<double>,allocator<complex<double> > >" , 99 , -1 };
16982 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<complex<double>,allocator<complex<double> > >::iterator>" , 99 , -1 };
16983 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLDerivator = { "ROOT::Math::GSLDerivator" , 99 , -1 };
16984 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator = { "ROOT::Math::Derivator" , 99 , -1 };
16985 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolation = { "ROOT::Math::Interpolation" , 110 , -1 };
16986 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolationcLcLType = { "ROOT::Math::Interpolation::Type" , 101 , -1 };
16987 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLInterpolator = { "ROOT::Math::GSLInterpolator" , 99 , -1 };
16988 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator = { "ROOT::Math::Interpolator" , 99 , -1 };
16989 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod = { "ROOT::Math::IRootFinderMethod" , 99 , -1 };
16990 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFSolver = { "ROOT::Math::GSLRootFSolver" , 99 , -1 };
16991 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionWrapper = { "ROOT::Math::GSLFunctionWrapper" , 99 , -1 };
16992 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder = { "ROOT::Math::GSLRootFinder" , 99 , -1 };
16993 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFdFSolver = { "ROOT::Math::GSLRootFdFSolver" , 99 , -1 };
16994 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionDerivWrapper = { "ROOT::Math::GSLFunctionDerivWrapper" , 99 , -1 };
16995 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv = { "ROOT::Math::GSLRootFinderDeriv" , 99 , -1 };
16996 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRoots = { "ROOT::Math::Roots" , 110 , -1 };
16997 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection = { "ROOT::Math::Roots::Bisection" , 99 , -1 };
16998 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos = { "ROOT::Math::Roots::FalsePos" , 99 , -1 };
16999 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent = { "ROOT::Math::Roots::Brent" , 99 , -1 };
17000 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton = { "ROOT::Math::Roots::Newton" , 99 , -1 };
17001 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant = { "ROOT::Math::Roots::Secant" , 99 , -1 };
17002 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson = { "ROOT::Math::Roots::Steffenson" , 99 , -1 };
17003 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDim = { "ROOT::Math::IntegrationOneDim" , 110 , -1 };
17004 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDimcLcLType = { "ROOT::Math::IntegrationOneDim::Type" , 101 , -1 };
17005 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDim = { "ROOT::Math::IntegrationMultiDim" , 110 , -1 };
17006 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDimcLcLType = { "ROOT::Math::IntegrationMultiDim::Type" , 101 , -1 };
17007 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIOptions = { "ROOT::Math::IOptions" , 99 , -1 };
17008 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorOneDimOptions = { "ROOT::Math::IntegratorOneDimOptions" , 99 , -1 };
17009 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorMultiDimOptions = { "ROOT::Math::IntegratorMultiDimOptions" , 99 , -1 };
17010 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegrator = { "ROOT::Math::VirtualIntegrator" , 99 , -1 };
17011 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorOneDim = { "ROOT::Math::VirtualIntegratorOneDim" , 99 , -1 };
17012 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorMultiDim = { "ROOT::Math::VirtualIntegratorMultiDim" , 99 , -1 };
17013 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegration = { "ROOT::Math::Integration" , 110 , -1 };
17014 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule = { "ROOT::Math::Integration::GKRule" , 101 , -1 };
17015 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrationWorkspace = { "ROOT::Math::GSLIntegrationWorkspace" , 99 , -1 };
17016 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator = { "ROOT::Math::GSLIntegrator" , 99 , -1 };
17017 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLMCIntegration = { "ROOT::Math::MCIntegration" , 110 , -1 };
17018 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLMCIntegrationcLcLMode = { "ROOT::Math::MCIntegration::Mode" , 101 , -1 };
17019 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters = { "ROOT::Math::VegasParameters" , 115 , -1 };
17020 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters = { "ROOT::Math::MiserParameters" , 115 , -1 };
17021 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrationWorkspace = { "ROOT::Math::GSLMCIntegrationWorkspace" , 99 , -1 };
17022 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMonteFunctionWrapper = { "ROOT::Math::GSLMonteFunctionWrapper" , 99 , -1 };
17023 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngWrapper = { "ROOT::Math::GSLRngWrapper" , 99 , -1 };
17024 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator = { "ROOT::Math::GSLMCIntegrator" , 99 , -1 };
17025 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLIMinimizer1D = { "ROOT::Math::IMinimizer1D" , 99 , -1 };
17026 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1D = { "ROOT::Math::Minim1D" , 110 , -1 };
17027 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1DcLcLType = { "ROOT::Math::Minim1D::Type" , 101 , -1 };
17028 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSL1DMinimizerWrapper = { "ROOT::Math::GSL1DMinimizerWrapper" , 99 , -1 };
17029 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D = { "ROOT::Math::GSLMinimizer1D" , 99 , -1 };
17030 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLChebSeries = { "ROOT::Math::GSLChebSeries" , 99 , -1 };
17031 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev = { "ROOT::Math::Chebyshev" , 99 , -1 };
17032 G__linked_taginfo G__G__MathMoreLN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
17033 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine = { "ROOT::Math::GSLRandomEngine" , 99 , -1 };
17034 G__linked_taginfo G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
17035 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
17036 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT = { "ROOT::Math::GSLRngMT" , 99 , -1 };
17037 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux = { "ROOT::Math::GSLRngRanLux" , 99 , -1 };
17038 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1 = { "ROOT::Math::GSLRngRanLuxS1" , 99 , -1 };
17039 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2 = { "ROOT::Math::GSLRngRanLuxS2" , 99 , -1 };
17040 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1 = { "ROOT::Math::GSLRngRanLuxD1" , 99 , -1 };
17041 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2 = { "ROOT::Math::GSLRngRanLuxD2" , 99 , -1 };
17042 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus = { "ROOT::Math::GSLRngTaus" , 99 , -1 };
17043 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4 = { "ROOT::Math::GSLRngGFSR4" , 99 , -1 };
17044 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions = { "ROOT::Math::KelvinFunctions" , 99 , -1 };
17045 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLMinimizer = { "ROOT::Math::Minimizer" , 99 , -1 };
17046 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType = { "ROOT::Math::EMinimVariableType" , 101 , -1 };
17047 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType = { "ROOT::Math::EGSLMinimizerType" , 101 , -1 };
17048 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiMinimizer = { "ROOT::Math::GSLMultiMinimizer" , 99 , -1 };
17049 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLMinimTransformFunction = { "ROOT::Math::MinimTransformFunction" , 99 , -1 };
17050 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer = { "ROOT::Math::GSLMinimizer" , 99 , -1 };
17051 G__linked_taginfo G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
17052 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
17053 G__linked_taginfo G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR = { "vector<ROOT::Math::EMinimVariableType,allocator<ROOT::Math::EMinimVariableType> >" , 99 , -1 };
17054 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Math::EMinimVariableType,allocator<ROOT::Math::EMinimVariableType> >::iterator>" , 99 , -1 };
17055 G__linked_taginfo G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR = { "map<unsigned int,pair<double,double>,less<unsigned int>,allocator<pair<const unsigned int,pair<double,double> > > >" , 99 , -1 };
17056 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
17057 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim>" , 99 , -1 };
17058 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiFit = { "ROOT::Math::GSLMultiFit" , 99 , -1 };
17059 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc = { "ROOT::Math::LSResidualFunc" , 99 , -1 };
17060 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer = { "ROOT::Math::GSLNLSMinimizer" , 99 , -1 };
17061 G__linked_taginfo G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR = { "vector<ROOT::Math::LSResidualFunc,allocator<ROOT::Math::LSResidualFunc> >" , 99 , -1 };
17062 G__linked_taginfo G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Math::LSResidualFunc,allocator<ROOT::Math::LSResidualFunc> >::iterator>" , 99 , -1 };
17063 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc = { "ROOT::Math::GSLSimAnFunc" , 99 , -1 };
17064 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams = { "ROOT::Math::GSLSimAnParams" , 115 , -1 };
17065 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing = { "ROOT::Math::GSLSimAnnealing" , 99 , -1 };
17066 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer = { "ROOT::Math::GSLSimAnMinimizer" , 99 , -1 };
17067 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov = { "ROOT::Math::Vavilov" , 99 , -1 };
17068 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate = { "ROOT::Math::VavilovAccurate" , 99 , -1 };
17069 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratecLcLdA = { "ROOT::Math::VavilovAccurate::$" , 101 , -1 };
17070 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf = { "ROOT::Math::VavilovAccuratePdf" , 99 , -1 };
17071 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf = { "ROOT::Math::VavilovAccurateCdf" , 99 , -1 };
17072 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile = { "ROOT::Math::VavilovAccurateQuantile" , 99 , -1 };
17073 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast = { "ROOT::Math::VavilovFast" , 99 , -1 };
17074 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR = { "ROOT::Math::Random<ROOT::Math::GSLRngMT>" , 99 , -1 };
17075 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR = { "ROOT::Math::Random<ROOT::Math::GSLRngTaus>" , 99 , -1 };
17076 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR = { "ROOT::Math::Random<ROOT::Math::GSLRngRanLux>" , 99 , -1 };
17077 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR = { "ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>" , 99 , -1 };
17078 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR = { "ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>" , 99 , -1 };
17079 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR = { "ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>" , 99 , -1 };
17080 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR = { "ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>" , 99 , -1 };
17081 G__linked_taginfo G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR = { "ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>" , 99 , -1 };
17082 
17083 /* Reset class/struct taginfo */
17084 extern "C" void G__cpp_reset_tagtableG__MathMore() {
17085   G__G__MathMoreLN_type_info.tagnum = -1 ;
17086   G__G__MathMoreLN_TClass.tagnum = -1 ;
17087   G__G__MathMoreLN_TNamed.tagnum = -1 ;
17088   G__G__MathMoreLN_TVirtualIsAProxy.tagnum = -1 ;
17089   G__G__MathMoreLN_ROOT.tagnum = -1 ;
17090   G__G__MathMoreLN_ROOTcLcLTInitBehavior.tagnum = -1 ;
17091   G__G__MathMoreLN_string.tagnum = -1 ;
17092   G__G__MathMoreLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
17093   G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
17094   G__G__MathMoreLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
17095   G__G__MathMoreLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
17096   G__G__MathMoreLN_ROOTcLcLMath.tagnum = -1 ;
17097   G__G__MathMoreLN_ROOTcLcLMathMore.tagnum = -1 ;
17098   G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim.tagnum = -1 ;
17099   G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionOneDim.tagnum = -1 ;
17100   G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim.tagnum = -1 ;
17101   G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim.tagnum = -1 ;
17102   G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientMultiDim.tagnum = -1 ;
17103   G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientOneDim.tagnum = -1 ;
17104   G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim.tagnum = -1 ;
17105   G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim.tagnum = -1 ;
17106   G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim.tagnum = -1 ;
17107   G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim.tagnum = -1 ;
17108   G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam.tagnum = -1 ;
17109   G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial.tagnum = -1 ;
17110   G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR.tagnum = -1 ;
17111   G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
17112   G__G__MathMoreLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
17113   G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR.tagnum = -1 ;
17114   G__G__MathMoreLN_reverse_iteratorlEvectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
17115   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLDerivator.tagnum = -1 ;
17116   G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator.tagnum = -1 ;
17117   G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolation.tagnum = -1 ;
17118   G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolationcLcLType.tagnum = -1 ;
17119   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLInterpolator.tagnum = -1 ;
17120   G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator.tagnum = -1 ;
17121   G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod.tagnum = -1 ;
17122   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFSolver.tagnum = -1 ;
17123   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionWrapper.tagnum = -1 ;
17124   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder.tagnum = -1 ;
17125   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFdFSolver.tagnum = -1 ;
17126   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionDerivWrapper.tagnum = -1 ;
17127   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv.tagnum = -1 ;
17128   G__G__MathMoreLN_ROOTcLcLMathcLcLRoots.tagnum = -1 ;
17129   G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection.tagnum = -1 ;
17130   G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos.tagnum = -1 ;
17131   G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent.tagnum = -1 ;
17132   G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton.tagnum = -1 ;
17133   G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant.tagnum = -1 ;
17134   G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson.tagnum = -1 ;
17135   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDim.tagnum = -1 ;
17136   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDimcLcLType.tagnum = -1 ;
17137   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDim.tagnum = -1 ;
17138   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDimcLcLType.tagnum = -1 ;
17139   G__G__MathMoreLN_ROOTcLcLMathcLcLIOptions.tagnum = -1 ;
17140   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorOneDimOptions.tagnum = -1 ;
17141   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorMultiDimOptions.tagnum = -1 ;
17142   G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegrator.tagnum = -1 ;
17143   G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorOneDim.tagnum = -1 ;
17144   G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorMultiDim.tagnum = -1 ;
17145   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegration.tagnum = -1 ;
17146   G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule.tagnum = -1 ;
17147   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrationWorkspace.tagnum = -1 ;
17148   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator.tagnum = -1 ;
17149   G__G__MathMoreLN_ROOTcLcLMathcLcLMCIntegration.tagnum = -1 ;
17150   G__G__MathMoreLN_ROOTcLcLMathcLcLMCIntegrationcLcLMode.tagnum = -1 ;
17151   G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters.tagnum = -1 ;
17152   G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters.tagnum = -1 ;
17153   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrationWorkspace.tagnum = -1 ;
17154   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMonteFunctionWrapper.tagnum = -1 ;
17155   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngWrapper.tagnum = -1 ;
17156   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator.tagnum = -1 ;
17157   G__G__MathMoreLN_ROOTcLcLMathcLcLIMinimizer1D.tagnum = -1 ;
17158   G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1D.tagnum = -1 ;
17159   G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1DcLcLType.tagnum = -1 ;
17160   G__G__MathMoreLN_ROOTcLcLMathcLcLGSL1DMinimizerWrapper.tagnum = -1 ;
17161   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D.tagnum = -1 ;
17162   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLChebSeries.tagnum = -1 ;
17163   G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev.tagnum = -1 ;
17164   G__G__MathMoreLN_pairlEdoublecOdoublegR.tagnum = -1 ;
17165   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine.tagnum = -1 ;
17166   G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
17167   G__G__MathMoreLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
17168   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT.tagnum = -1 ;
17169   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux.tagnum = -1 ;
17170   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1.tagnum = -1 ;
17171   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2.tagnum = -1 ;
17172   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1.tagnum = -1 ;
17173   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2.tagnum = -1 ;
17174   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus.tagnum = -1 ;
17175   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4.tagnum = -1 ;
17176   G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions.tagnum = -1 ;
17177   G__G__MathMoreLN_ROOTcLcLMathcLcLMinimizer.tagnum = -1 ;
17178   G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType.tagnum = -1 ;
17179   G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType.tagnum = -1 ;
17180   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiMinimizer.tagnum = -1 ;
17181   G__G__MathMoreLN_ROOTcLcLMathcLcLMinimTransformFunction.tagnum = -1 ;
17182   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer.tagnum = -1 ;
17183   G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
17184   G__G__MathMoreLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
17185   G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR.tagnum = -1 ;
17186   G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgRcLcLiteratorgR.tagnum = -1 ;
17187   G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR.tagnum = -1 ;
17188   G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
17189   G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR.tagnum = -1 ;
17190   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiFit.tagnum = -1 ;
17191   G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc.tagnum = -1 ;
17192   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer.tagnum = -1 ;
17193   G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR.tagnum = -1 ;
17194   G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgRcLcLiteratorgR.tagnum = -1 ;
17195   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc.tagnum = -1 ;
17196   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams.tagnum = -1 ;
17197   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing.tagnum = -1 ;
17198   G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer.tagnum = -1 ;
17199   G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov.tagnum = -1 ;
17200   G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate.tagnum = -1 ;
17201   G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratecLcLdA.tagnum = -1 ;
17202   G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf.tagnum = -1 ;
17203   G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf.tagnum = -1 ;
17204   G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile.tagnum = -1 ;
17205   G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast.tagnum = -1 ;
17206   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR.tagnum = -1 ;
17207   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR.tagnum = -1 ;
17208   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR.tagnum = -1 ;
17209   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR.tagnum = -1 ;
17210   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR.tagnum = -1 ;
17211   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR.tagnum = -1 ;
17212   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR.tagnum = -1 ;
17213   G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR.tagnum = -1 ;
17214 }
17215 
17216 
17217 extern "C" void G__cpp_setup_tagtableG__MathMore() {
17218 
17219    /* Setting up class,struct,union tag entry */
17220    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_type_info);
17221    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_TClass);
17222    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_TNamed);
17223    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_TVirtualIsAProxy);
17224    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOT),0,-1,0,(char*)NULL,G__setup_memvarROOT,G__setup_memfuncROOT);
17225    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLTInitBehavior);
17226    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_string);
17227    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
17228    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
17229    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
17230    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
17231    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMath),0,-1,0,(char*)NULL,G__setup_memvarROOTcLcLMath,G__setup_memfuncROOTcLcLMath);
17232    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathMore),0,-1,0,(char*)NULL,G__setup_memvarROOTcLcLMathMore,G__setup_memfuncROOTcLcLMathMore);
17233    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionOneDim);
17234    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionOneDim);
17235    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim);
17236    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim);
17237    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientMultiDim);
17238    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIGradientOneDim);
17239    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionOneDim);
17240    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim);
17241    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim);
17242    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim);
17243    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIBaseParam);
17244    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLPolynomial),sizeof(ROOT::Math::Polynomial),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLPolynomial,G__setup_memfuncROOTcLcLMathcLcLPolynomial);
17245    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR),sizeof(ROOT::Math::ParamFunction<ROOT::Math::IParametricGradFunctionOneDim>),-1,263427,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR,G__setup_memfuncROOTcLcLMathcLcLParamFunctionlEROOTcLcLMathcLcLIParametricGradFunctionOneDimgR);
17246    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
17247    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
17248    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgR);
17249    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlEcomplexlEdoublegRcOallocatorlEcomplexlEdoublegRsPgRsPgRcLcLiteratorgR);
17250    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLDerivator);
17251    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLDerivator),sizeof(ROOT::Math::Derivator),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLDerivator,G__setup_memfuncROOTcLcLMathcLcLDerivator);
17252    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolation);
17253    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolationcLcLType);
17254    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLInterpolator);
17255    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLInterpolator),sizeof(ROOT::Math::Interpolator),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLInterpolator,G__setup_memfuncROOTcLcLMathcLcLInterpolator);
17256    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIRootFinderMethod);
17257    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFSolver);
17258    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionWrapper);
17259    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinder),sizeof(ROOT::Math::GSLRootFinder),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRootFinder,G__setup_memfuncROOTcLcLMathcLcLGSLRootFinder);
17260    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFdFSolver);
17261    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLFunctionDerivWrapper);
17262    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRootFinderDeriv),sizeof(ROOT::Math::GSLRootFinderDeriv),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRootFinderDeriv,G__setup_memfuncROOTcLcLMathcLcLGSLRootFinderDeriv);
17263    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRoots),0,-1,0,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRoots,G__setup_memfuncROOTcLcLMathcLcLRoots);
17264    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBisection),sizeof(ROOT::Math::Roots::Bisection),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRootscLcLBisection,G__setup_memfuncROOTcLcLMathcLcLRootscLcLBisection);
17265    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLFalsePos),sizeof(ROOT::Math::Roots::FalsePos),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRootscLcLFalsePos,G__setup_memfuncROOTcLcLMathcLcLRootscLcLFalsePos);
17266    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLBrent),sizeof(ROOT::Math::Roots::Brent),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRootscLcLBrent,G__setup_memfuncROOTcLcLMathcLcLRootscLcLBrent);
17267    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLNewton),sizeof(ROOT::Math::Roots::Newton),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRootscLcLNewton,G__setup_memfuncROOTcLcLMathcLcLRootscLcLNewton);
17268    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSecant),sizeof(ROOT::Math::Roots::Secant),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRootscLcLSecant,G__setup_memfuncROOTcLcLMathcLcLRootscLcLSecant);
17269    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRootscLcLSteffenson),sizeof(ROOT::Math::Roots::Steffenson),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRootscLcLSteffenson,G__setup_memfuncROOTcLcLMathcLcLRootscLcLSteffenson);
17270    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDim);
17271    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationOneDimcLcLType);
17272    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDim);
17273    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationMultiDimcLcLType);
17274    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIOptions);
17275    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorOneDimOptions);
17276    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegratorMultiDimOptions);
17277    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegrator);
17278    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorOneDim);
17279    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVirtualIntegratorMultiDim);
17280    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegration),0,-1,0,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLIntegration,G__setup_memfuncROOTcLcLMathcLcLIntegration);
17281    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIntegrationcLcLGKRule);
17282    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrationWorkspace);
17283    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLIntegrator),sizeof(ROOT::Math::GSLIntegrator),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLIntegrator,G__setup_memfuncROOTcLcLMathcLcLGSLIntegrator);
17284    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLMCIntegration);
17285    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLMCIntegrationcLcLMode);
17286    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVegasParameters),sizeof(ROOT::Math::VegasParameters),-1,297216,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLVegasParameters,G__setup_memfuncROOTcLcLMathcLcLVegasParameters);
17287    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLMiserParameters),sizeof(ROOT::Math::MiserParameters),-1,297216,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLMiserParameters,G__setup_memfuncROOTcLcLMathcLcLMiserParameters);
17288    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrationWorkspace);
17289    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMonteFunctionWrapper);
17290    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngWrapper);
17291    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMCIntegrator),sizeof(ROOT::Math::GSLMCIntegrator),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLMCIntegrator,G__setup_memfuncROOTcLcLMathcLcLGSLMCIntegrator);
17292    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLIMinimizer1D);
17293    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1D),0,-1,0,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLMinim1D,G__setup_memfuncROOTcLcLMathcLcLMinim1D);
17294    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinim1DcLcLType);
17295    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSL1DMinimizerWrapper);
17296    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer1D),sizeof(ROOT::Math::GSLMinimizer1D),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLMinimizer1D,G__setup_memfuncROOTcLcLMathcLcLGSLMinimizer1D);
17297    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLChebSeries);
17298    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLChebyshev),sizeof(ROOT::Math::Chebyshev),-1,298496,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLChebyshev,G__setup_memfuncROOTcLcLMathcLcLChebyshev);
17299    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_pairlEdoublecOdoublegR);
17300    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRandomEngine),sizeof(ROOT::Math::GSLRandomEngine),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRandomEngine,G__setup_memfuncROOTcLcLMathcLcLGSLRandomEngine);
17301    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
17302    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
17303    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngMT),sizeof(ROOT::Math::GSLRngMT),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngMT,G__setup_memfuncROOTcLcLMathcLcLGSLRngMT);
17304    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLux),sizeof(ROOT::Math::GSLRngRanLux),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngRanLux,G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLux);
17305    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS1),sizeof(ROOT::Math::GSLRngRanLuxS1),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxS1,G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxS1);
17306    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxS2),sizeof(ROOT::Math::GSLRngRanLuxS2),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxS2,G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxS2);
17307    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD1),sizeof(ROOT::Math::GSLRngRanLuxD1),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxD1,G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxD1);
17308    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngRanLuxD2),sizeof(ROOT::Math::GSLRngRanLuxD2),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngRanLuxD2,G__setup_memfuncROOTcLcLMathcLcLGSLRngRanLuxD2);
17309    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngTaus),sizeof(ROOT::Math::GSLRngTaus),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngTaus,G__setup_memfuncROOTcLcLMathcLcLGSLRngTaus);
17310    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLRngGFSR4),sizeof(ROOT::Math::GSLRngGFSR4),-1,295168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLRngGFSR4,G__setup_memfuncROOTcLcLMathcLcLGSLRngGFSR4);
17311    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLKelvinFunctions),sizeof(ROOT::Math::KelvinFunctions),-1,263168,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLKelvinFunctions,G__setup_memfuncROOTcLcLMathcLcLKelvinFunctions);
17312    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinimizer);
17313    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLEMinimVariableType);
17314    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLEGSLMinimizerType);
17315    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiMinimizer);
17316    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLMinimTransformFunction);
17317    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMinimizer),sizeof(ROOT::Math::GSLMinimizer),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLMinimizer,G__setup_memfuncROOTcLcLMathcLcLGSLMinimizer);
17318    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlEstringcOallocatorlEstringgRsPgR);
17319    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
17320    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgR);
17321    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLEMinimVariableTypecOallocatorlEROOTcLcLMathcLcLEMinimVariableTypegRsPgRcLcLiteratorgR);
17322    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR);
17323    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
17324    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
17325    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLMultiFit);
17326    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLLSResidualFunc),sizeof(ROOT::Math::LSResidualFunc),-1,101120,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLLSResidualFunc,G__setup_memfuncROOTcLcLMathcLcLLSResidualFunc);
17327    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLNLSMinimizer),sizeof(ROOT::Math::GSLNLSMinimizer),-1,69376,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLNLSMinimizer,G__setup_memfuncROOTcLcLMathcLcLGSLNLSMinimizer);
17328    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_vectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgR);
17329    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_reverse_iteratorlEvectorlEROOTcLcLMathcLcLLSResidualFunccOallocatorlEROOTcLcLMathcLcLLSResidualFuncgRsPgRcLcLiteratorgR);
17330    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnFunc),sizeof(ROOT::Math::GSLSimAnFunc),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLSimAnFunc,G__setup_memfuncROOTcLcLMathcLcLGSLSimAnFunc);
17331    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnParams),sizeof(ROOT::Math::GSLSimAnParams),-1,262400,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLSimAnParams,G__setup_memfuncROOTcLcLMathcLcLGSLSimAnParams);
17332    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnnealing),sizeof(ROOT::Math::GSLSimAnnealing),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLSimAnnealing,G__setup_memfuncROOTcLcLMathcLcLGSLSimAnnealing);
17333    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLGSLSimAnMinimizer),sizeof(ROOT::Math::GSLSimAnMinimizer),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLGSLSimAnMinimizer,G__setup_memfuncROOTcLcLMathcLcLGSLSimAnMinimizer);
17334    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilov),sizeof(ROOT::Math::Vavilov),-1,263439,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLVavilov,G__setup_memfuncROOTcLcLMathcLcLVavilov);
17335    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurate),sizeof(ROOT::Math::VavilovAccurate),-1,263424,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLVavilovAccurate,G__setup_memfuncROOTcLcLMathcLcLVavilovAccurate);
17336    G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratecLcLdA);
17337    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccuratePdf),sizeof(ROOT::Math::VavilovAccuratePdf),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLVavilovAccuratePdf,G__setup_memfuncROOTcLcLMathcLcLVavilovAccuratePdf);
17338    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateCdf),sizeof(ROOT::Math::VavilovAccurateCdf),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLVavilovAccurateCdf,G__setup_memfuncROOTcLcLMathcLcLVavilovAccurateCdf);
17339    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovAccurateQuantile),sizeof(ROOT::Math::VavilovAccurateQuantile),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLVavilovAccurateQuantile,G__setup_memfuncROOTcLcLMathcLcLVavilovAccurateQuantile);
17340    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLVavilovFast),sizeof(ROOT::Math::VavilovFast),-1,263424,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLVavilovFast,G__setup_memfuncROOTcLcLMathcLcLVavilovFast);
17341    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngMT>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngMTgR);
17342    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngTaus>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngTausgR);
17343    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLux>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxgR);
17344    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS1>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS1gR);
17345    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxS2>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxS2gR);
17346    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD1>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD1gR);
17347    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngRanLuxD2>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngRanLuxD2gR);
17348    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathMoreLN_ROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR),sizeof(ROOT::Math::Random<ROOT::Math::GSLRngGFSR4>),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR,G__setup_memfuncROOTcLcLMathcLcLRandomlEROOTcLcLMathcLcLGSLRngGFSR4gR);
17349 }
17350 extern "C" void G__cpp_setupG__MathMore(void) {
17351   G__check_setup_version(30051515,"G__cpp_setupG__MathMore()");
17352   G__set_cpp_environmentG__MathMore();
17353   G__cpp_setup_tagtableG__MathMore();
17354 
17355   G__cpp_setup_inheritanceG__MathMore();
17356 
17357   G__cpp_setup_typetableG__MathMore();
17358 
17359   G__cpp_setup_memvarG__MathMore();
17360 
17361   G__cpp_setup_memfuncG__MathMore();
17362   G__cpp_setup_globalG__MathMore();
17363   G__cpp_setup_funcG__MathMore();
17364 
17365    if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__MathMore();
17366   return;
17367 }
17368 class G__cpp_setup_initG__MathMore {
17369   public:
17370     G__cpp_setup_initG__MathMore() { G__add_setup_func("G__MathMore",(G__incsetup)(&G__cpp_setupG__MathMore)); G__call_setup_funcs(); }
17371    ~G__cpp_setup_initG__MathMore() { G__remove_setup_func("G__MathMore"); }
17372 };
17373 G__cpp_setup_initG__MathMore G__cpp_setup_initializerG__MathMore;
17374