/* Copyright 2005, Numerical Algorithms Group Ltd, Oxford, UK.

   ***** Marks 15 - 21. *****

   Header file to enable the NAG library of Fortran routines to be called from
   within a C program.

   Author: Mike Dewar, University of Bath

   Version 2.1 by Malcolm Cohen, Numerical Algorithms Group Ltd., Oxford.
   Mark 21 version compiled by Ian Hounam,
   Numerical Algorithms Group Ltd., Oxford, April 2005.

*/

#ifndef NAG_FTN_INCLUDED
#define NAG_FTN_INCLUDED
#ifndef NAG_GRAPH_INCLUDED
typedef struct { double re,im; } Complex;
#endif

#if defined(__STDC__) && !defined(AVOID_CONST)
#define CONST const
#else
#define CONST
#endif

#ifdef __cplusplus
extern "C" {
#endif

extern void a00aaf_(
#ifdef __STDC__
void
#endif
);

extern int a00acf_(
#ifdef __STDC__
void
#endif
);

extern void a02aaf_(
#ifdef __STDC__
  CONST double *xxr,
  CONST double *xxi,
  double *yr,
  double *yi
#endif
);

extern double a02abf_(
#ifdef __STDC__
  CONST double *xxr,
  CONST double *xxi
#endif
);

extern void a02acf_(
#ifdef __STDC__
  CONST double *xxr,
  CONST double *xxi,
  CONST double *yyr,
  CONST double *yyi,
  double *zr,
  double *zi
#endif
);

extern void c02aef_(
#ifdef __STDC__
  double a[],
  int *n,
  double rez[],
  double imz[],
  double *tol,
  int *ifail
#endif
);

extern void c02aff_(
#ifdef __STDC__
  CONST double a[] /* 2 dimension */,
  CONST int *n,
  CONST int *scale,
  double z[] /* 2 dimension */,
  double work[],
  int *ifail
#endif
);

extern void c02agf_(
#ifdef __STDC__
  CONST double a[],
  CONST int *n,
  CONST int *scale,
  double z[] /* 2 dimension */,
  double work[],
  int *ifail
#endif
);

extern void c02ahf_(
#ifdef __STDC__
  CONST double *ar,
  CONST double *ai,
  CONST double *br,
  CONST double *bi,
  CONST double *cr,
  CONST double *ci,
  double zsm[],
  double zlg[],
  int *ifail
#endif
);

extern void c02ajf_(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST double *c,
  double zsm[],
  double zlg[],
  int *ifail
#endif
);

extern void c05adf_(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST double *eps,
  CONST double *eta,
  double (*f)(double *),
  double *x,
  int *ifail
#endif
);

extern void c05agf_(
#ifdef __STDC__
  double *x,
  CONST double *hh,
  CONST double *eps,
  CONST double *eta,
  double (*f)(double *),
  double *a,
  double *b,
  int *ifail
#endif
);

extern void c05ajf_(
#ifdef __STDC__
  double *x,
  CONST double *eps,
  CONST double *eta,
  double (*f)(double *),
  CONST int *nfmax,
  int *ifail
#endif
);

extern void c05avf_(
#ifdef __STDC__
  double *x,
  double *fx,
  double *h,
  CONST double *boundl,
  CONST double *boundu,
  double *a,
  double c[],
  int *ind,
  int *ifail
#endif
);

extern void c05axf_(
#ifdef __STDC__
  double *x,
  CONST double *fx,
  CONST double *tol,
  CONST int *ir,
  CONST double *scale,
  double c[],
  int *ind,
  int *ifail
#endif
);

extern void c05azf_(
#ifdef __STDC__
  double *x,
  double *y,
  double *fx,
  CONST double *tolx,
  CONST int *ir,
  double c[],
  int *ind,
  int *ifail
#endif
);

extern void c02akf_(
#ifdef __STDC__
  CONST double *u,
  CONST double *r,
  CONST double *s,
  CONST double *t,
  double zeror[],
  double zeroi[],
  double errest[],
  int *ifail
#endif
);

extern void c02alf_(
#ifdef __STDC__
  CONST double *e,
  CONST double *a,
  CONST double *b,
  CONST double *c,
  CONST double *d,
  double zeror[],
  double zeroi[],
  double errest[],
  int *ifail
#endif
);

extern void c02amf_(
#ifdef __STDC__
  CONST Complex *u,
  CONST Complex *r,
  CONST Complex *s,
  CONST Complex *t,
  double zeror[],
  double zeroi[],
  double errest[],
  int *ifail
#endif
);

extern void c02anf_(
#ifdef __STDC__
  CONST Complex *e,
  CONST Complex *a,
  CONST Complex *b,
  CONST Complex *c,
  CONST Complex *d,
  double zeror[],
  double zeroi[],
  double errest[],
  int *ifail
#endif
);

extern void c05nbf_(
#ifdef __STDC__
  void (*fcn)(int *, double[], double[], int *),
  CONST int *n,
  double x[],
  double fvec[],
  CONST double *tol,
  double wa[],
  CONST int *lwa,
  int *ifail
#endif
);

extern void c05ncf_(
#ifdef __STDC__
  void (*fcn)(int *, double[], double[], int *),
  CONST int *n,
  double x[],
  double fvec[],
  CONST double *xtol,
  CONST int *maxfev,
  CONST int *ml,
  CONST int *mu,
  CONST double *epsfcn,
  double diag[],
  CONST int *mode,
  CONST double *factor,
  CONST int *nprint,
  int *nfev,
  double fjac[] /* 2 dimension */,
  CONST int *ldfjac,
  double r[],
  CONST int *lr,
  double qtf[],
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void c05ndf_(
#ifdef __STDC__
  int *irevcm,
  CONST int *n,
  double x[],
  double fvec[],
  CONST double *xtol,
  CONST int *ml,
  CONST int *mu,
  CONST double *epsfcn,
  double diag[],
  CONST int *mode,
  CONST double *factor,
  double fjac[] /* 2 dimension */,
  CONST int *ldfjac,
  double r[],
  CONST int *lr,
  double qtf[],
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void c05pbf_(
#ifdef __STDC__
  void (*fcn)(int *, double[], double[], double[], int *, int *),
  CONST int *n,
  double x[],
  double fvec[],
  double fjac[] /* 2 dimension */,
  CONST int *ldfjac,
  CONST double *tol,
  double wa[],
  CONST int *lwa,
  int *ifail
#endif
);

extern void c05pcf_(
#ifdef __STDC__
  void (*fcn)(int *, double[], double[], double[], int *, int *),
  CONST int *n,
  double x[],
  double fvec[],
  double fjac[] /* 2 dimension */,
  CONST int *ldfjac,
  CONST double *xtol,
  CONST int *maxfev,
  double diag[],
  CONST int *mode,
  CONST double *factor,
  CONST int *nprint,
  int *nfev,
  int *njev,
  double r[],
  CONST int *lr,
  double qtf[],
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void c05pdf_(
#ifdef __STDC__
  int *irevcm,
  CONST int *n,
  double x[],
  double fvec[],
  double fjac[] /* 2 dimension */,
  CONST int *ldfjac,
  CONST double *xtol,
  double diag[],
  CONST int *mode,
  CONST double *factor,
  double r[],
  CONST int *lr,
  double qtf[],
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void c05pda_(
#ifdef __STDC__
  int *irevcm,
  CONST int *n,
  double x[],
  double fvec[],
  double fjac[] /* 2 dimension */,
  CONST int *ldfjac,
  CONST double *xtol,
  double diag[],
  CONST int *mode,
  CONST double *factor,
  double r[],
  CONST int *lr,
  double qtf[],
  double w[] /* 2 dimension */,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

extern void c05zaf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double x[],
  CONST double fvec[],
  CONST double fjac[] /* 2 dimension */,
  CONST int *ldfjac,
  double xp[],
  CONST double fvecp[],
  CONST int *mode,
  double err[]
#endif
);

extern void c06baf_(
#ifdef __STDC__
  CONST double *seqn,
  int *ncall,
  double *result,
  double *abserr,
  double work[],
  CONST int *iwork,
  int *ifail
#endif
);

extern double c06dbf_(
#ifdef __STDC__
  CONST double *x,
  CONST double c[],
  CONST int *n,
  CONST int *s
#endif
);

extern void c06eaf_(
#ifdef __STDC__
  double x[],
  CONST int *pts,
  int *ifail
#endif
);

extern void c06ebf_(
#ifdef __STDC__
  double x[],
  CONST int *pts,
  int *ifail
#endif
);

extern void c06ecf_(
#ifdef __STDC__
  double x[],
  double y[],
  CONST int *pts,
  int *ifail
#endif
);

extern void c06ekf_(
#ifdef __STDC__
  CONST int *job,
  double x[],
  double y[],
  CONST int *n,
  int *ifail
#endif
);

extern void c06faf_(
#ifdef __STDC__
  double x[],
  CONST int *pts,
  double work[],
  int *ifail
#endif
);

extern void c06fbf_(
#ifdef __STDC__
  double x[],
  CONST int *pts,
  double work[],
  int *ifail
#endif
);

extern void c06fcf_(
#ifdef __STDC__
  double x[],
  double y[],
  CONST int *pts,
  double work[],
  int *ifail
#endif
);

extern void c06fff_(
#ifdef __STDC__
  CONST int *ndim,
  CONST int *l,
  CONST int nd[],
  CONST int *n,
  double x[],
  double y[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void c06fjf_(
#ifdef __STDC__
  CONST int *ndim,
  CONST int nd[],
  CONST int *n,
  double x[],
  double y[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void c06fkf_(
#ifdef __STDC__
  CONST int *job,
  double x[],
  double y[],
  CONST int *n,
  double work[],
  int *ifail
#endif
);

extern void c06fpf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  CONST char init[],
  double trig[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06fqf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  CONST char init[],
  double trig[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06frf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  double y[],
  CONST char init[],
  double trig[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06fuf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  double y[],
  CONST char init[],
  double trigm[],
  double trign[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06fxf_(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST int *n3,
  double x[],
  double y[],
  CONST char init[],
  double trign1[],
  double trign2[],
  double trign3[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06gbf_(
#ifdef __STDC__
  double x[],
  CONST int *pts,
  int *ifail
#endif
);

extern void c06gcf_(
#ifdef __STDC__
  double y[],
  CONST int *pts,
  int *ifail
#endif
);

extern void c06gqf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  int *ifail
#endif
);

extern void c06gsf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double x[],
  double u[],
  double v[],
  int *ifail
#endif
);

extern void c06haf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST char init[],
  double trig[],
  double work[] /* 2 dimension */,
  int *ifail,
  CONST int length_1
#endif
);

extern void c06hbf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST char init[],
  double trig[],
  double work[] /* 2 dimension */,
  int *ifail,
  CONST int length_1
#endif
);

extern void c06hcf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST char init[],
  double trig[],
  double work[] /* 2 dimension */,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void c06hdf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST char init[],
  double trig[],
  double work[] /* 2 dimension */,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void c06laf_(
#ifdef __STDC__
  void (*fun)(double *, double *, double *, double *),
  CONST int *n,
  CONST double t[],
  double valinv[],
  double errest[],
  CONST double *relerr,
  CONST double *alphab,
  CONST double *tfac,
  CONST int *mxterm,
  int *nterms,
  int *na,
  double *alow,
  double *ahigh,
  int *nfeval,
  double work[],
  int *ifail
#endif
);

extern void c06lbf_(
#ifdef __STDC__
  void (*f)(Complex *,Complex *),
  CONST double *sigma0,
  double *sigma,
  double *b,
  CONST double *epstol,
  CONST int *mmax,
  int *m,
  double acoef[],
  double errvec[],
  int *ifail
#endif
);

extern void c06lcf_(
#ifdef __STDC__
  CONST double *t,
  CONST double *sigma,
  CONST double *b,
  CONST int *m,
  CONST double acoef[],
  CONST double errvec[],
  double *finv,
  int *ifail
#endif
);

extern void c06paf_(
#ifdef __STDC__
  CONST char direct[],
  double x[],
  CONST int *n,
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06pcf_(
#ifdef __STDC__
  CONST char direct[],
  Complex x[],
  CONST int *n,
  Complex work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06pff_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *ndim,
  CONST int *l,
  CONST int nd[],
  CONST int *n,
  Complex x[],
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void c06pjf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *ndim,
  CONST int nd[],
  CONST int *n,
  Complex x[],
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void c06pkf_(
#ifdef __STDC__
  CONST int *job,
  Complex x[],
  Complex y[],
  CONST int *n,
  Complex work[],
  int *ifail
#endif
);

extern void c06ppf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06pqf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *n,
  CONST int *m,
  double x[] /* 2 dimension */,
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06prf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  Complex x[],
  Complex work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06psf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *n,
  CONST int *m,
  Complex x[],
  Complex work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06puf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  Complex x[],
  Complex work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06pxf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  CONST int *p,
  Complex x[],
  Complex work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06raf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  double work[],
  int *ifail
#endif
);

extern void c06rbf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  double work[],
  int *ifail
#endif
);

extern void c06rcf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void c06rdf_(
#ifdef __STDC__
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  double x[] /* 2 dimension */,
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern double d01ahf_(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST double *epr,
  int *npts,
  double *relerr,
  double (*f)(double *),
  CONST int *nl,
  int *ifail
#endif
);

extern void d01ajf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *b,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01akf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *b,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01alf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *b,
  CONST int *npts,
  CONST double points[],
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01amf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *bound,
  CONST int *inf,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01anf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *b,
  CONST double *omega,
  CONST int *key,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01apf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *b,
  CONST double *alfa,
  CONST double *beta,
  CONST int *key,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01aqf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *b,
  CONST double *c,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01arf_(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  double (*f)(double *),
  CONST double *relacc,
  CONST double *absacc,
  CONST int *maxrul,
  CONST int *iparm,
  double *acc,
  double *ans,
  int *n,
  double alpha[],
  int *ifail
#endif
);

extern void d01asf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *omega,
  CONST int *key,
  CONST double *epsabs,
  double *result,
  double *abserr,
  CONST int *limlst,
  int *lst,
  double erlst[],
  double rslst[],
  int ierlst[],
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01atf_(
#ifdef __STDC__
  void (*f)(double[], double[], int *),
  CONST double *a,
  CONST double *b,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d01auf_(
#ifdef __STDC__
  void (*f)(double[], double[], int *),
  CONST double *a,
  CONST double *b,
  CONST int *key,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern double d01baf_(
#ifdef __STDC__
  void (*wtfun)(double *, double *, int *, int *, double[], double[], int *),
  CONST double *a,
  CONST double *b,
  CONST int *npts,
  double (*fun)(double *),
  int *ifail
#endif
);

extern void d01baw_(
#ifdef __STDC__
  double *a,
  double *b,
  int *itype,
  int *npts,
  double weight[],
  double abscis[],
  int *ifail
#endif
);

extern void d01bax_(
#ifdef __STDC__
  double *a,
  double *b,
  int *itype,
  int *npts,
  double weight[],
  double abscis[],
  int *ifail
#endif
);

extern void d01bay_(
#ifdef __STDC__
  double *a,
  double *b,
  int *itype,
  int *npts,
  double weight[],
  double abscis[],
  int *ifail
#endif
);

extern void d01baz_(
#ifdef __STDC__
  double *a,
  double *b,
  int *itype,
  int *npts,
  double weight[],
  double abscis[],
  int *ifail
#endif
);

extern void d01bbf_(
#ifdef __STDC__
  void (*wtfun)(double *, double *, int *, int *, double[], double[], int *),
  CONST double *a,
  CONST double *b,
  CONST int *itype,
  CONST int *npts,
  CONST double weight[],
  CONST double abscis[],
  int *ifail
#endif
);

extern void d01bcf_(
#ifdef __STDC__
  CONST int *itype,
  CONST double *aa,
  CONST double *bb,
  CONST double *cc,
  CONST double *dd,
  CONST int *npnts,
  double weight[],
  double abscis[],
  int *ifail
#endif
);

extern void d01bdf_(
#ifdef __STDC__
  double (*f)(double *),
  CONST double *a,
  CONST double *b,
  CONST double *epsabs,
  CONST double *epsrel,
  double *result,
  double *abserr
#endif
);

extern void d01daf_(
#ifdef __STDC__
  CONST double *ya,
  CONST double *yb,
  double (*phi1)(double *),
  double (*phi2)(double *),
  double (*f)(double *, double *),
  CONST double *absacc,
  double *ans,
  int *npts,
  int *ifail
#endif
);

extern void d01eaf_(
#ifdef __STDC__
  CONST int *ndim,
  CONST double a[],
  CONST double b[],
  int *mincls,
  CONST int *maxcls,
  CONST int *nfun,
  void (*funsub)(int *, double[], int *, double[]),
  CONST double *absreq,
  CONST double *relreq,
  CONST int *lenwrk,
  double work[],
  double finest[],
  double absest[],
  int *ifail
#endif
);

extern double d01fbf_(
#ifdef __STDC__
  CONST int *ndim,
  CONST int nptvec[],
  CONST int *lwa,
  CONST double weight[],
  CONST double abscis[],
  double (*fun)(int *, double[]),
  int *ifail
#endif
);

extern void d01fcf_(
#ifdef __STDC__
  CONST int *ndim,
  CONST double a[],
  CONST double b[],
  int *minpts,
  CONST int *maxpts,
  double (*functn)(int *, double[]),
  CONST double *eps,
  double *acc,
  CONST int *lenwrk,
  double wrkstr[],
  double *finval,
  int *ifail
#endif
);

extern void d01fdf_(
#ifdef __STDC__
  CONST int *n,
  double (*f)(int *, double[]),
  CONST double *sigma,
  void (*region)(int *, double[], int *, double *, double *),
  CONST int *limit,
  CONST double *r0,
  CONST double *u,
  double *result,
  int *npts,
  int *ifail
#endif
);

extern void d01fdv_(
#ifdef __STDC__
  int *ndim,
  double x[],
  int *j,
  double *c,
  double *d
#endif
);

extern void d01gaf_(
#ifdef __STDC__
  CONST double x[],
  CONST double y[],
  CONST int *n,
  double *ans,
  double *er,
  int *ifail
#endif
);

extern void d01gbf_(
#ifdef __STDC__
  CONST int *numvar,
  CONST double a[],
  CONST double b[],
  int *minpts,
  CONST int *maxpts,
  double (*functn)(int *, double[]),
  CONST double *releps,
  double *relerr,
  CONST int *lenwrk,
  double wrkstr[],
  double *finval,
  int *ifail
#endif
);

extern void d01gcf_(
#ifdef __STDC__
  CONST int *n,
  double (*f)(int *, double[]),
  void (*region)(int *, double[], int *, double *, double *),
  CONST int *npts,
  double vk[],
  CONST int *nrand,
  CONST int *itrans,
  double *res,
  double *err,
  int *ifail
#endif
);

extern void d01gdf_(
#ifdef __STDC__
  CONST int *n,
  void (*vecfun)(int *, double[], double[], int *),
  void (*vecreg)(int *, double[], int *, double[], double[], int *),
  CONST int *npts,
  double vk[],
  CONST int *nrand,
  CONST int *itrans,
  double *res,
  double *err,
  int *ifail
#endif
);

extern void d01gyf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *npts,
  double vk[],
  int *ifail
#endif
);

extern void d01gzf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *np1,
  CONST int *np2,
  double vk[],
  int *ifail
#endif
);

extern void d01jaf_(
#ifdef __STDC__
  double (*f)(int *, double[]),
  CONST int *n,
  CONST double *radius,
  CONST double *epsa,
  CONST double *epsr,
  CONST int *method,
  CONST int *icoord,
  double *result,
  double *esterr,
  int *evals,
  int *ifail
#endif
);

extern void d01paf_(
#ifdef __STDC__
  CONST int *numvar,
  double vertex[] /* 2 dimension */,
  CONST int *iv1,
  CONST int *iv2,
  double (*intgnd)(int *, double[]),
  int *minord,
  CONST int *maxord,
  double intvls[],
  double *esterr,
  int *ifail
#endif
);

extern void d02agf_(
#ifdef __STDC__
  double *h,
  CONST double error[],
  CONST double parerr[],
  double param[],
  double c[] /* 2 dimension */,
  CONST int *n,
  CONST int *n1,
  CONST int *m1,
  void (*aux)(double[], double[], double *, double[]),
  void (*bcaux)(double[], double[], double[]),
  void (*raaux)(double *, double *, double *, double[]),
  void (*prsol)(double[], double *, int *, double[]),
  double mat[] /* 2 dimension */,
  CONST double copy[] /* 2 dimension */,
  double wspace[] /* 2 dimension */,
  double wspac1[],
  CONST double wspac2[],
  int *ifail
#endif
);

extern void d02baf_(
#ifdef __STDC__
  double *x,
  CONST double *xend,
  CONST int *n,
  double y[],
  double *tol,
  void (*fcn)(double *, double[], double[]),
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void d02bbf_(
#ifdef __STDC__
  double *x,
  CONST double *xend,
  CONST int *n,
  double y[],
  double *tol,
  CONST int *irelab,
  void (*fcn)(double *, double[], double[]),
  void (*output)(double *, double[]),
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void d02bdf_(
#ifdef __STDC__
  double *x,
  CONST double *xend,
  CONST int *n,
  double y[],
  CONST double *tol,
  CONST int *irelab,
  void (*fcn)(double *, double[], double[]),
  double *stiff,
  CONST double *ynorm,
  double w[] /* 2 dimension */,
  CONST int *iw,
  CONST int *m,
  void (*output)(double *, double[], double[], double *),
  int *ifail
#endif
);

extern void d02bgf_(
#ifdef __STDC__
  double *x,
  CONST double *xend,
  CONST int *n,
  double y[],
  double *tol,
  CONST double *hmax,
  CONST int *m,
  CONST double *val,
  void (*fcn)(double *, double[], double[]),
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void d02bhf_(
#ifdef __STDC__
  double *x,
  CONST double *xend,
  CONST int *n,
  double y[],
  double *tol,
  CONST int *irelab,
  CONST double *hmax,
  void (*fcn)(double *, double[], double[]),
  double (*g)(double *, double[]),
  double w[] /* 2 dimension */,
  int *ifail
#endif
);

extern void d02bjf_(
#ifdef __STDC__
  double *t,
  CONST double *tend,
  CONST int *neq,
  double y[],
  void (*fcn)(double *, double[], double[]),
  CONST double *tol,
  CONST char relabs[],
  void (*output)(double *, double[]),
  double (*g)(double *, double[]),
  double rwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d02bjx_(
#ifdef __STDC__
  double *rdum1,
  double rdum2[]
#endif
);

extern void d02caf_(
#ifdef __STDC__
  double *t,
  CONST double *tend,
  CONST int *neq,
  double y[],
  CONST double *tol,
  void (*fcn)(double *, double[], double[]),
  double rwork[],
  int *ifail
#endif
);

extern void d02cbf_(
#ifdef __STDC__
  double *t,
  CONST double *tend,
  CONST int *neq,
  double y[],
  CONST double *tol,
  CONST int *irelab,
  void (*fcn)(double *, double[], double[]),
  void (*output)(double *, double[]),
  double rwork[],
  int *ifail
#endif
);

extern void d02cgf_(
#ifdef __STDC__
  double *t,
  CONST double *tend,
  CONST int *neq,
  double y[],
  CONST double *tol,
  CONST double *hmax,
  CONST int *m,
  CONST double *val,
  void (*fcn)(double *, double[], double[]),
  double rwork[],
  int *ifail
#endif
);

extern void d02chf_(
#ifdef __STDC__
  double *t,
  CONST double *tend,
  CONST int *neq,
  double y[],
  CONST double *tol,
  CONST int *irelab,
  CONST double *hmax,
  void (*fcn)(double *, double[], double[]),
  double (*g)(double *, double[]),
  double rwork[],
  int *ifail
#endif
);

extern void d02cjf_(
#ifdef __STDC__
  double *t,
  CONST double *tend,
  CONST int *neq,
  double y[],
  void (*fcn)(double *, double[], double[]),
  CONST double *tol,
  CONST char relabs[],
  void (*output)(double *, double[]),
  double (*g)(double *, double[]),
  double rwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern double d02cjw_(
#ifdef __STDC__
  double *rdum1,
  double *rdum2
#endif
);

extern void d02cjx_(
#ifdef __STDC__
  double *rdum1,
  double *rdum2
#endif
);

extern void d02eaf_(
#ifdef __STDC__
  double *x,
  double *xend,
  CONST int *n,
  double y[],
  double *tol,
  void (*fcn)(double[], double[], double[]),
  double w[],
  CONST int *iw,
  int *ifail
#endif
);

extern void d02eaz_(
#ifdef __STDC__
  double *x,
  double y[],
  double pw[] /* 2 dimension */
#endif
);

extern void d02ebf_(
#ifdef __STDC__
  double *x,
  double *xend,
  CONST int *n,
  double y[],
  double *tol,
  CONST int *irelab,
  void (*fcn)(double[], double[], double[]),
  CONST int *mped,
  void (*pederv)(double[], double[], double[]),
  void (*output)(double *, double[]),
  double w[],
  CONST int *iw,
  int *ifail
#endif
);

extern void d02egf_(
#ifdef __STDC__
  double *x,
  double *xend,
  CONST int *n,
  double y[],
  double *tol,
  double *hmax,
  CONST int *m,
  CONST double *val,
  void (*fcn)(double[], double[], double[]),
  double w[],
  CONST int *iw,
  int *ifail
#endif
);

extern void d02ehf_(
#ifdef __STDC__
  double *x,
  double *xend,
  CONST int *n,
  double y[],
  double *tol,
  CONST int *irelab,
  double *hmax,
  void (*fcn)(double[], double[], double[]),
  CONST int *mped,
  void (*pederv)(double[], double[], double[]),
  double (*g)(double *, double[]),
  double w[],
  CONST int *iw,
  int *ifail
#endif
);

extern void d02ejf_(
#ifdef __STDC__
  double *x,
  double *xend,
  CONST int *n,
  double y[],
  void (*fcn)(double[], double[], double[]),
  void (*pederv)(double *, double[], double[]),
  double *tol,
  CONST char relabs[],
  void (*output)(double *, double[]),
  double (*g)(double *, double[]),
  double w[],
  CONST int *iw,
  int *ifail,
  CONST int length_1
#endif
);

extern double d02ejw_(
#ifdef __STDC__
  double *rdum1,
  double *rdum2
#endif
);

extern void d02ejx_(
#ifdef __STDC__
  double *rdum1,
  double *rdum2
#endif
);

extern void d02ejy_(
#ifdef __STDC__
  double *rdum1,
  double rdum2[],
  double rdum3[]
#endif
);

extern void d02gaf_(
#ifdef __STDC__
  CONST double u[] /* 2 dimension */,
  CONST double v[] /* 2 dimension */,
  CONST int *n,
  CONST double *a,
  CONST double *b,
  CONST double *tol,
  void (*fcn)(double *, double[], double[]),
  CONST int *mnp,
  double x[],
  double y[] /* 2 dimension */,
  int *np,
  double w[],
  CONST int *lw,
  int iw[],
  CONST int *liw,
  int *ifail
#endif
);

extern void d02gax_(
#ifdef __STDC__
  double *eps,
  double y[],
  double z[],
  double a[],
  int *m
#endif
);

extern void d02gay_(
#ifdef __STDC__
  double *eps,
  double y[],
  double z[],
  double a[] /* 2 dimension */,
  double b[] /* 2 dimension */,
  int *m
#endif
);

extern void d02gaz_(
#ifdef __STDC__
  double *x,
  double *eps,
  double y[],
  double f[],
  int *m
#endif
);

extern void d02gbf_(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST int *n,
  CONST double *tol,
  void (*fcnf)(double *, double[]),
  void (*fcng)(double *, double[]),
  double c[] /* 2 dimension */,
  double d[] /* 2 dimension */,
  double gam[],
  CONST int *mnp,
  double x[],
  double y[] /* 2 dimension */,
  int *np,
  double w[],
  CONST int *lw,
  int iw[],
  CONST int *liw,
  int *ifail
#endif
);

extern void d02haf_(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST double b[] /* 2 dimension */,
  CONST int *n,
  CONST double *x,
  CONST double *x1,
  CONST double *tol,
  void (*fcn)(double *, double[], double[]),
  double soln[] /* 2 dimension */,
  CONST int *m1,
  double w[] /* 2 dimension */,
  CONST int *iw,
  int *ifail
#endif
);

extern void d02hbf_(
#ifdef __STDC__
  double p[],
  CONST int *n1,
  CONST double pe[],
  CONST double e[],
  CONST int *n,
  double soln[] /* 2 dimension */,
  CONST int *m1,
  void (*fcn)(double *, double[], double[], double[]),
  void (*bc)(double[], double[], double[]),
  void (*range)(double[], double[], double[]),
  double w[] /* 2 dimension */,
  CONST int *iw,
  int *ifail
#endif
);

extern void d02hbw_(
#ifdef __STDC__
  double *z,
  double y[],
  int *n
#endif
);

extern void d02hbx_(
#ifdef __STDC__
  int *istate,
  int *iflag,
  int *ifail1,
  double p[],
  int *m,
  double f[],
  double *pnorm,
  double *pnorm1,
  double *eps,
  double d[]
#endif
);

extern int d02hby_(
#ifdef __STDC__
  double p[],
  int *m
#endif
);

extern void d02hbz_(
#ifdef __STDC__
  double e[],
  int *q,
  double p[],
  int *m
#endif
);

extern void d02jaf_(
#ifdef __STDC__
  CONST int *n,
  double (*cf)(int *, double *),
  void (*bc)(int *, int *, double *),
  CONST double *x0,
  CONST double *x1,
  CONST int *k1,
  CONST int *kp,
  double c[],
  double w[],
  CONST int *lw,
  int iw[],
  int *ifail
#endif
);

extern void d02jbf_(
#ifdef __STDC__
  CONST int *n,
  double (*cf)(int *, int *, double *),
  void (*bc)(int *, int *, double *),
  CONST double *x0,
  CONST double *x1,
  CONST int *k1,
  CONST int *kp,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double w[],
  CONST int *lw,
  int iw[],
  CONST int *liw,
  int *ifail
#endif
);

extern void d02kaf_(
#ifdef __STDC__
  CONST double *xl,
  CONST double *xr,
  void (*coeffn)(double *, double *, double *, double *, double *, int *),
  double bcond[] /* 2 dimension */,
  CONST int *k,
  CONST double *tol,
  double *elam,
  double *delam,
  void (*monit)(int *, int *, double *, double[]),
  int *ifail
#endif
);

extern void d02kay_(
#ifdef __STDC__
  int *nit,
  int *iflag,
  double *elam,
  double finfo[]
#endif
);

extern void d02kdf_(
#ifdef __STDC__
  CONST double xpoint[],
  CONST int *nxp,
  void (*coeffn)(double *, double *, double *, double *, double *, int *),
  void (*bdyval)(double *, double *, double *, double[], double[]),
  CONST int *k,
  CONST double *tol,
  double *elam,
  double *delam,
  double hmax[] /* 2 dimension */,
  int *maxit,
  CONST int *maxfun,
  void (*monit)(int *, int *, double *, double[]),
  int *ifail
#endif
);

extern void d02kdy_(
#ifdef __STDC__
  double *x,
  double *xend,
  int *n,
  double y[],
  double cin[],
  double *tol,
  void (*fcn)(int *, double *, double[], double[], void *, void *, int *, 
              double[]),
  double comm[],
  double _const[],
  double _cout[],
  double w[] /* 2 dimension */,
  int *iw,
  int *iw1,
  void (*coeffn)(),
  void (*coeff1)(),
  double arr[],
  int *m,
  int *ifail
#endif
);

extern void d02kef_(
#ifdef __STDC__
  CONST double xpoint[],
  CONST int *nxp,
  int *ic1,
  void (*coeffn)(double *, double *, double *, double *, double *, int *),
  void (*bdyval)(double *, double *, double *, double[], double[]),
  CONST int *k,
  CONST double *tol,
  double *elam,
  double *delam,
  double hmax[] /* 2 dimension */,
  int *maxit,
  CONST int *maxfun,
  void (*monit)(int *, int *, double *, double[]),
  void (*report)(double *, double[], int *),
  int *ifail
#endif
);

extern void d02laf_(
#ifdef __STDC__
  void (*f)(int *, double *, double[], double[]),
  CONST int *neq,
  double *t,
  CONST double *tend,
  double y[],
  double yp[],
  double ydp[],
  double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void d02lxf_(
#ifdef __STDC__
  CONST int *neq,
  CONST double *h,
  CONST double *tol,
  CONST double thres[],
  CONST double thresp[],
  CONST int *maxstp,
  int *start,
  CONST int *onestp,
  CONST int *high,
  double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void d02lyf_(
#ifdef __STDC__
  CONST int *neq,
  double *hnext,
  double *hused,
  double *hstart,
  int *nsucc,
  int *nfail,
  int *natt,
  double thres[],
  double thresp[],
  CONST double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void d02lzf_(
#ifdef __STDC__
  CONST int *neq,
  CONST double *t,
  CONST double y[],
  CONST double yp[],
  CONST int *nwant,
  CONST double *twant,
  double ywant[],
  double ypwant[],
  CONST double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void d02mvf_(
#ifdef __STDC__
  CONST int *neqmax,
  CONST int *ny2dim,
  CONST int *maxord,
  double _const[],
  CONST double *tcrit,
  CONST double *hmin,
  CONST double *hmax,
  CONST double *h0,
  CONST int *maxstp,
  CONST int *mxhnil,
  CONST char norm[],
  double rwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d02mzf_(
#ifdef __STDC__
  CONST double *tsol,
  double sol[],
  CONST int *m,
  CONST int *neqmax,
  CONST int *neq,
  CONST double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  CONST double rwork[],
  int *ifail
#endif
);

extern void d02nbf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  void (*fcn)(int *, double[], double[], double[], int *),
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  void (*jac)(int *, double[], double[], double[], double[], double[]),
  double wkjac[],
  CONST int *nwkjac,
  void (*monitr)(int *, int *, double[], double[], double[], double[], 
                 double[], double[], double[], double[], int *, int *, 
                 double[], double[], int *),
  CONST int *itask,
  CONST int *itrace,
  int *ifail
#endif
);

extern void d02nby_(
#ifdef __STDC__
  int *neq,
  int *neqmax,
  double *t,
  double *hlast,
  double *hnext,
  double y[],
  double ydot[],
  double ysave[] /* 2 dimension */,
  double r[],
  double acor[] /* 2 dimension */,
  int *imon,
  int *inln,
  double *hmin,
  double *hmax,
  int *nqu
#endif
);

extern void d02nbz_(
#ifdef __STDC__
  int *neq,
  double *t,
  double y[],
  double *h,
  double *d,
  double p[]
#endif
);

extern void d02ncf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  void (*fcn)(int *, double[], double[], double[], int *),
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  void (*jac)(int *, double[], double[], double[], double[], int *, int *, 
              double[]),
  double wkjac[],
  CONST int *nwkjac,
  int jacpvt[],
  CONST int *njcpvt,
  void (*monitr)(int *, int *, double[], double[], double[], double[], 
                 double[], double[], double[], double[], int *, int *, 
                 double[], double[], int *),
  CONST int *itask,
  CONST int *itrace,
  int *ifail
#endif
);

extern void d02ncz_(
#ifdef __STDC__
  int *neq,
  double *t,
  double y[],
  double *h,
  double *d,
  int *ml,
  int *mu,
  double p[]
#endif
);

extern void d02ndf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  void (*fcn)(int *, double[], double[], double[], int *),
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  void (*jac)(int *, double[], double[], double[], double[], int *, double[]),
  double wkjac[],
  CONST int *nwkjac,
  int jacpvt[],
  CONST int *njcpvt,
  void (*monitr)(int *, int *, double[], double[], double[], double[], 
                 double[], double[], double[], double[], int *, int *, 
                 double[], double[], int *),
  CONST int *itask,
  CONST int *itrace,
  int *ifail
#endif
);

extern void d02ndz_(
#ifdef __STDC__
  int *neq,
  double *t,
  double y[],
  double *h,
  double *d,
  int *j,
  double p[]
#endif
);

extern void d02ngf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  void (*resid)(int *, double[], double[], double[], double[], int *),
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  void (*jac)(int *, double[], double[], double[], double[], double[], 
              double[]),
  double wkjac[],
  CONST int *nwkjac,
  void (*monitr)(int *, int *, double[], double[], double[], double[], 
                 double[], double[], double[], double[], int *, int *, 
                 double[], double[], int *),
  int lderiv[],
  CONST int *itask,
  CONST int *itrace,
  int *ifail
#endif
);

extern void d02ngz_(
#ifdef __STDC__
  int *neq,
  double *t,
  double y[],
  double ydot[],
  double *h,
  double *d,
  double p[]
#endif
);

extern void d02nhf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  void (*resid)(int *, double[], double[], double[], double[], int *),
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  void (*jac)(int *, double[], double[], double[], double[], double[], int *, 
              int *, double[]),
  double wkjac[],
  CONST int *nwkjac,
  int jacpvt[],
  CONST int *njcpvt,
  void (*monitr)(int *, int *, double[], double[], double[], double[], 
                 double[], double[], double[], double[], int *, int *, 
                 double[], double[], int *),
  int lderiv[],
  CONST int *itask,
  CONST int *itrace,
  int *ifail
#endif
);

extern void d02nhz_(
#ifdef __STDC__
  int *neq,
  double *t,
  double y[],
  double ydot[],
  double *h,
  double *d,
  int *ml,
  int *mu,
  double p[]
#endif
);

extern void d02njf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  void (*resid)(int *, double[], double[], double[], double[], int *),
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  void (*jac)(int *, double[], double[], double[], double[], double[], int *, 
              double[]),
  double wkjac[],
  CONST int *nwkjac,
  int jacpvt[],
  CONST int *njcpvt,
  void (*monitr)(int *, int *, double[], double[], double[], double[], 
                 double[], double[], double[], double[], int *, int *, 
                 double[], double[], int *),
  int lderiv[],
  CONST int *itask,
  CONST int *itrace,
  int *ifail
#endif
);

extern void d02njz_(
#ifdef __STDC__
  int *neq,
  double *t,
  double y[],
  double ydot[],
  double *h,
  double *d,
  int *j,
  double p[]
#endif
);

extern void d02nmf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  double wkjac[],
  CONST int *nwkjac,
  int jacpvt[],
  CONST int *njcpvt,
  int *imon,
  int *inln,
  int *ires,
  int *irevcm,
  CONST int *itask,
  CONST int *jtrace,
  int *ifail
#endif
);

extern void d02nnf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *t,
  double *tout,
  double y[],
  double ydoti[],
  double rwork[],
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  int inform[],
  double ysave[] /* 2 dimension */,
  CONST int *ny2dim,
  double wkjac[],
  CONST int *nwkjac,
  int jacpvt[],
  CONST int *njcpvt,
  int *imon,
  int *inln,
  int *ires,
  int *irevcm,
  int lderiv[],
  CONST int *itask,
  CONST int *jtrace,
  int *ifail
#endif
);

extern void d02nrf_(
#ifdef __STDC__
  int *j,
  int *iplace,
  CONST int inform[]
#endif
);

extern void d02nsf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  CONST char jceval[],
  CONST int *nwkjac,
  double rwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d02ntf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  CONST char jceval[],
  CONST int *ml,
  CONST int *mu,
  CONST int *nwkjac,
  CONST int *njcpvt,
  double rwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d02nuf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  CONST char jceval[],
  CONST int *nwkjac,
  CONST int ia[],
  CONST int *nia,
  CONST int ja[],
  CONST int *nja,
  int jacpvt[],
  CONST int *njcpvt,
  CONST double *sens,
  CONST double *u,
  CONST double *eta,
  CONST int *lblock,
  CONST int *isplit,
  double rwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d02nvf_(
#ifdef __STDC__
  CONST int *neqmax,
  CONST int *ny2dim,
  CONST int *maxord,
  CONST char method[],
  CONST int *petzld,
  double _const[],
  CONST double *tcrit,
  CONST double *hmin,
  CONST double *hmax,
  CONST double *h0,
  CONST int *maxstp,
  CONST int *mxhnil,
  CONST char norm[],
  double rwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d02nwf_(
#ifdef __STDC__
  CONST int *neqmax,
  CONST int *ny2dim,
  CONST int *maxord,
  double _const[],
  CONST double *tcrit,
  CONST double *hmin,
  CONST double *hmax,
  CONST double *h0,
  CONST int *maxstp,
  CONST int *mxhnil,
  CONST char norm[],
  double rwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d02nxf_(
#ifdef __STDC__
  CONST int *icall,
  int *liwreq,
  int *liwusd,
  int *lrwreq,
  int *lrwusd,
  int *nlu,
  int *nnz,
  int *ngp,
  int *isplit,
  int *igrow,
  CONST int *lblock,
  int *nblock,
  CONST int inform[]
#endif
);

extern void d02nyf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int *neqmax,
  double *hu,
  double *h,
  double *tcur,
  double *tolsf,
  CONST double rwork[],
  int *nst,
  int *nre,
  int *nje,
  int *nqu,
  int *nq,
  int *niter,
  int *imxer,
  int algequ[],
  CONST int inform[],
  int *ifail
#endif
);

extern void d02nzf_(
#ifdef __STDC__
  CONST int *neqmax,
  CONST double *tcrit,
  CONST double *h,
  CONST double *hmin,
  CONST double *hmax,
  CONST int *maxstp,
  CONST int *maxhnl,
  double rwork[],
  int *ifail
#endif
);

extern void d02paf_(
#ifdef __STDC__
  double *x,
  CONST double *xend,
  CONST int *n,
  double y[],
  double cin[],
  CONST double *tol,
  void (*fcn)(double *, double[], double[]),
  double comm[],
  double _const[],
  double _cout[],
  double w[] /* 2 dimension */,
  CONST int *iw,
  CONST int *iw1,
  int *ifail
#endif
);

extern void d02pcf_(
#ifdef __STDC__
  void (*f)(double *, double[], double[]),
  CONST double *twant,
  double *tgot,
  double ygot[],
  double ypgot[],
  double ymax[],
  double work[],
  int *ifail
#endif
);

extern void d02pdf_(
#ifdef __STDC__
  void (*f)(double *, double[], double[]),
  double *tnow,
  double ynow[],
  double ypnow[],
  double work[],
  int *ifail
#endif
);

extern void d02pvf_(
#ifdef __STDC__
  CONST int *neq,
  CONST double *tstart,
  CONST double ystart[],
  CONST double *tend,
  CONST double *tol,
  CONST double thres[],
  CONST int *method,
  CONST char task[],
  CONST int *errass,
  CONST double *hstart,
  double work[],
  CONST int *lenwrk,
  int *ifail,
  CONST int length_1
#endif
);

extern void d02pwf_(
#ifdef __STDC__
  CONST double *tendnu,
  int *ifail
#endif
);

extern void d02pxf_(
#ifdef __STDC__
  CONST double *twant,
  CONST char reqest[],
  CONST int *nwant,
  double ywant[],
  double ypwant[],
  void (*f)(double *, double[], double[]),
  double work[],
  double wrkint[],
  CONST int *lenint,
  int *ifail,
  CONST int length_1
#endif
);

extern void d02pyf_(
#ifdef __STDC__
  int *totfcn,
  int *stpcst,
  double *waste,
  int *stpsok,
  double *hnext,
  int *ifail
#endif
);

extern void d02pzf_(
#ifdef __STDC__
  double rmserr[],
  double *errmax,
  double *terrmx,
  CONST double work[],
  int *ifail
#endif
);

extern void d02qdf_(
#ifdef __STDC__
  double *x,
  double *xend,
  CONST int *n,
  double y[],
  double cin[],
  CONST double rtol[],
  CONST double atol[],
  void (*fcn)(double[], double[], double[]),
  double comm[],
  double _const[],
  double _cout[],
  CONST char jacstr[],
  CONST int mbands[],
  void (*pederv)(double *, double[], double[]),
  double w[],
  CONST int *iw,
  int iwk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d02qff_(
#ifdef __STDC__
  void (*f)(int *, double *, double[], double[]),
  CONST int *neqf,
  double *t,
  double y[],
  CONST double *tout,
  double (*g)(int *, double *, double[], double[], int *),
  CONST int *neqg,
  int *root,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern double d02qfz_(
#ifdef __STDC__
  int *neqf,
  double *t,
  double y[],
  double yp[],
  int *k
#endif
);

extern void d02qgf_(
#ifdef __STDC__
  CONST int *neqf,
  double *t,
  double y[],
  CONST double *tout,
  CONST int *neqg,
  int *root,
  int *irevcm,
  double *trvcm,
  int *yrvcm,
  int *yprvcm,
  CONST double *grvcm,
  int *kgrvcm,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d02qqf_(
#ifdef __STDC__
  CONST double comm[],
  CONST double chk[],
  CONST int *n,
  double w[],
  CONST int *iw,
  int *ifail
#endif
);

extern void d02qwf_(
#ifdef __STDC__
  char statef[],
  CONST int *neqf,
  CONST int *vectol,
  CONST double atol[],
  CONST int *latol,
  CONST double rtol[],
  CONST int *lrtol,
  CONST int *onestp,
  CONST int *crit,
  CONST double *tcrit,
  CONST double *hmax,
  CONST int *maxstp,
  CONST int *neqg,
  int *alterg,
  CONST int *sophst,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void d02qxf_(
#ifdef __STDC__
  CONST int *neqf,
  double yp[],
  double *tcurr,
  double *hlast,
  double *hnext,
  int *odlast,
  int *odnext,
  int *nsucc,
  int *nfail,
  double *tolfac,
  int *badcmp,
  CONST double rwork[],
  CONST int *lrwork,
  CONST int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d02qyf_(
#ifdef __STDC__
  CONST int *neqg,
  int *index,
  int *type,
  int events[],
  double resids[],
  CONST double rwork[],
  CONST int *lrwork,
  CONST int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d02qzf_(
#ifdef __STDC__
  CONST int *neqf,
  CONST double *twant,
  CONST int *nwant,
  double ywant[],
  double ypwant[],
  CONST double rwork[],
  CONST int *lrwork,
  CONST int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d02raf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *nmax,
  int *n,
  CONST int *numbeg,
  CONST int *nummix,
  CONST double *tol,
  CONST int *init,
  double x[],
  double y[] /* 2 dimension */,
  CONST int *iy,
  double abt[],
  void (*fcn)(double *, double *, double[], double[], int *),
  void (*g)(double *, double[], double[], double[], int *),
  CONST int *ijac,
  void (*jacobf)(double *, double *, double[], double[], int *),
  void (*jacobg)(double *, double[], double[], double[], double[], int *),
  double *deleps,
  void (*jaceps)(double *, double *, double[], double[], int *),
  void (*jacgep)(double *, double[], double[], double[], int *),
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d02rar_(
#ifdef __STDC__
  int *m,
  int *n,
  int irn[],
  int *nirn,
  int ip[],
  int *nip,
  double h[],
  double x[],
  double f[],
  double hmax[],
  double *umin,
  double *uaim,
  double *umax,
  double *eps,
  double *eps1,
  int *adjust,
  double a[],
  int ig[],
  int *nig,
  double w[],
  int *nw,
  double z[],
  int *ind,
  int *ifail
#endif
);

extern void d02saf_(
#ifdef __STDC__
  double p[],
  CONST int *m,
  CONST int *n,
  CONST int *n1,
  CONST double pe[],
  double pf[],
  CONST double e[],
  double dp[],
  int *npoint,
  double wp[] /* 2 dimension */,
  CONST int *iwp,
  CONST int *icount,
  void (*range)(double[], int *, double[], int *),
  void (*bc)(double[], double[], double[], int *, int *),
  void (*fcn)(double *, double[], double[], int *, double[], int *, int *),
  void (*eqn)(double[], int *, double[], int *),
  int (*constr)(double[], int *),
  CONST double *ymax,
  void (*monit)(int *, int *, int *, double[], int *, double[], double *, 
                double *, double *, double[]),
  void (*prsol)(double *, double[], int *),
  double w[] /* 2 dimension */,
  CONST int *iw1,
  CONST int *iw2,
  int *ifail
#endif
);

extern void d02sas_(
#ifdef __STDC__
  int *istate,
  int *iflag,
  int *ifail1,
  double p[],
  int *m,
  double f[],
  double *pnorm,
  double *pnorm1,
  double *eps,
  double d[]
#endif
);

extern void d02sau_(
#ifdef __STDC__
  double p[],
  int *m,
  double a[] /* 2 dimension */,
  double e[],
  int *n,
  double x[],
  int *npoint,
  double h[],
  double hmax[],
  double hmin[],
  void (*fcn)(),
  void (*fcn1)(),
  void (*fcn2)(),
  void (*bc)(double[], double[], double[]),
  void (*bc1)(double[], double[], double[], int *, int *),
  double *ymax,
  double w[] /* 2 dimension */,
  int *iw,
  void (*prsol)(double *, double[], int *),
  double c[] /* 2 dimension */,
  int *m1,
  int *iflag
#endif
);

extern void d02sav_(
#ifdef __STDC__
  double p[],
  int *m,
  double a[] /* 2 dimension */,
  double b[] /* 2 dimension */,
  int *n,
  int *n1,
  double pe[],
  double pf[],
  double e[],
  double dp[],
  int *npoint,
  double wp[] /* 2 dimension */,
  int *iwp,
  double *x,
  double *x1,
  int *icount,
  void (*range)(double[], double[], double[]),
  void (*range1)(double[], int *, double[], int *),
  void (*bc)(double[], double[], double[]),
  void (*bc1)(double[], double[], double[], int *, int *),
  void (*fcn)(),
  void (*fcn1)(),
  void (*fcn2)(),
  void (*eqn)(double[], int *, double[], int *),
  int (*constr)(double[], int *),
  double *ymax,
  void (*monit)(int *, int *, int *, double[], int *, double[], double *, 
                double *, double *, double[]),
  void (*prsol)(double *, double[], int *),
  double c[] /* 2 dimension */,
  int *m1,
  double w[] /* 2 dimension */,
  int *iw1,
  int *iw2,
  int *ifail
#endif
);

extern void d02saw_(
#ifdef __STDC__
  double d[],
  double u[] /* 2 dimension */,
  double v[] /* 2 dimension */,
  double f[],
  double p[],
  double pf[],
  int *m,
  double a[] /* 2 dimension */,
  double b[] /* 2 dimension */,
  double dp[],
  double e[],
  int *n,
  int *n1,
  double w1[],
  double w2[],
  int *npoint,
  double *x,
  double *x1,
  double h[],
  double hmax[],
  double hmin[],
  void (*fcn)(),
  void (*fcn1)(),
  void (*fcn2)(),
  void (*eqn)(double[], int *, double[], int *),
  void (*bc)(double[], double[], double[]),
  void (*bc1)(double[], double[], double[], int *, int *),
  void (*range)(double[], double[], double[]),
  void (*range1)(double[], int *, double[], int *),
  int (*constr)(double[], int *),
  double *ymax,
  double w[] /* 2 dimension */,
  int *iw,
  int *iw2,
  int *iflag
#endif
);

extern void d02sax_(
#ifdef __STDC__
  double p[],
  int *n,
  double a[] /* 2 dimension */,
  double b[] /* 2 dimension */,
  double u[] /* 2 dimension */,
  double v[] /* 2 dimension */,
  double d[],
  int *iv,
  double errp[],
  double pf[],
  double f[],
  double w[] /* 2 dimension */,
  void (*monit)(int *, int *, int *, double[], int *, double[], double *, 
                double *, double *, double[])
#endif
);

extern void d02saz_(
#ifdef __STDC__
  double f[],
  double p[],
  int *m,
  double a[] /* 2 dimension */,
  double e[],
  int *n,
  int *n1,
  double x[],
  int *npoint,
  double h[],
  double hmax[],
  double hmin[],
  int *mark,
  void (*fcn)(),
  void (*fcn1)(),
  void (*fcn2)(),
  void (*eqn)(double[], int *, double[], int *),
  void (*bc)(double[], double[], double[]),
  void (*bc1)(double[], double[], double[], int *, int *),
  double *ymax,
  double w[] /* 2 dimension */,
  int *iw,
  int *iflag
#endif
);

extern void d02tgf_(
#ifdef __STDC__
  CONST int *n,
  CONST int m[],
  CONST int l[],
  CONST double *x0,
  CONST double *x1,
  CONST int *k1,
  CONST int *kp,
  double c[] /* 2 dimension */,
  CONST int *ic,
  void (*coeff)(double *, int *, double[], int *, int *, double *),
  void (*bdyc)(double *, int *, int *, double[], int *, int *, double *),
  double w[],
  CONST int *lw,
  int iw[],
  CONST int *liw,
  int *ifail
#endif
);

extern void d02tkf_(
#ifdef __STDC__
  void (*ffun)(double *, double[], int *, int[], double[]),
  void (*fjac)(double *, double[], int *, int[], double[]),
  void (*gafun)(double[], int *, int[], int *, double[]),
  void (*gbfun)(double[], int *, int[], int *, double[]),
  void (*gajac)(double[], int *, int[], int *, double[]),
  void (*gbjac)(double[], int *, int[], int *, double[]),
  void (*guess)(double *, int *, int[], double[], double[]),
  double work[],
  int iwork[],
  int *ifail
#endif
);

extern void d02tvf_(
#ifdef __STDC__
  CONST int *neq,
  CONST int m[],
  CONST int *nlbc,
  CONST int *nrbc,
  CONST int *ncol,
  CONST double tols[],
  CONST int *mxmesh,
  CONST int *nmesh,
  CONST double mesh[],
  CONST int ipmesh[],
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d02txf_(
#ifdef __STDC__
  CONST int *mxmesh,
  CONST int *nmesh,
  CONST double mesh[],
  CONST int ipmesh[],
  double rwork[],
  int iwork[],
  int *ifail
#endif
);

extern void d02tyf_(
#ifdef __STDC__
  CONST double *x,
  double y[] /* 2 dimension */,
  CONST int *neq,
  CONST int *mmax,
  double rwork[],
  CONST int iwork[],
  int *ifail
#endif
);

extern void d02tzf_(
#ifdef __STDC__
  CONST int *mxmesh,
  int *nmesh,
  double mesh[],
  int ipmesh[],
  double *ermx,
  int *iermx,
  int *ijermx,
  CONST double rwork[],
  CONST int iwork[],
  int *ifail
#endif
);

extern void d02xaf_(
#ifdef __STDC__
  CONST double *xsol,
  CONST double *x,
  CONST double _cout[],
  CONST int *n,
  CONST double y[],
  CONST double w[] /* 2 dimension */,
  CONST int *iw,
  double sol[],
  int *ifail
#endif
);

extern void d02xbf_(
#ifdef __STDC__
  CONST double *xsol,
  CONST double *x,
  CONST double _cout[],
  CONST int *n,
  CONST double y[],
  CONST double w[] /* 2 dimension */,
  CONST int *iw,
  CONST int *m,
  double *sol,
  int *ifail
#endif
);

extern void d02xjf_(
#ifdef __STDC__
  CONST double *xsol,
  double sol[],
  CONST int *m,
  CONST double w[] /* 2 dimension */,
  CONST int *neqmax,
  CONST int *iw,
  CONST int *neq,
  CONST double *x,
  CONST int *nq,
  CONST double *hu,
  CONST double *h,
  int *ifail
#endif
);

extern void d02xkf_(
#ifdef __STDC__
  CONST double *xsol,
  double sol[],
  CONST int *m,
  CONST double w[] /* 2 dimension */,
  CONST int *neqmax,
  CONST int *iw,
  CONST double w2[],
  CONST int *neq,
  CONST double *x,
  CONST int *nq,
  CONST double *hu,
  CONST double *h,
  int *ifail
#endif
);

extern void d02yaf_(
#ifdef __STDC__
  CONST double *x,
  CONST double *h,
  CONST int *n,
  double y[],
  void (*fcn)(double *, double[], double[]),
  double w[] /* 2 dimension */,
  CONST int *iw1,
  CONST int *iw2
#endif
);

extern double d02zaf_(
#ifdef __STDC__
  CONST int *n,
  CONST double v[],
  CONST double w[],
  int *ifail
#endif
);

extern void d03eaf_(
#ifdef __STDC__
  CONST int *stage1,
  CONST int *ext,
  CONST int *dorm,
  CONST int *n,
  CONST double *p,
  CONST double *q,
  CONST double x[],
  CONST double y[],
  CONST int *n1p1,
  double phi[],
  double phid[],
  double *alpha,
  double c[] /* 2 dimension */,
  CONST int *ic,
  CONST int *np4,
  int icint[],
  CONST int *np1,
  int *ifail
#endif
);

extern void d03ebf_(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST int *n1m,
  CONST double a[] /* 2 dimension */,
  CONST double b[] /* 2 dimension */,
  CONST double c[] /* 2 dimension */,
  CONST double d[] /* 2 dimension */,
  CONST double e[] /* 2 dimension */,
  CONST double q[] /* 2 dimension */,
  double t[] /* 2 dimension */,
  CONST double *aparam,
  CONST int *itmax,
  int *itcoun,
  int *itused,
  CONST int *ndir,
  CONST int *ixn,
  CONST int *iyn,
  CONST double *conres,
  CONST double *conchn,
  double resids[],
  double chngs[],
  double wrksp1[] /* 2 dimension */,
  double wrksp2[] /* 2 dimension */,
  double wrksp3[] /* 2 dimension */,
  int *ifail
#endif
);

extern void d03ecf_(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST int *n3,
  CONST int *n1m,
  CONST int *n2m,
  CONST double a[] /* 3 dimension */,
  CONST double b[] /* 3 dimension */,
  CONST double c[] /* 3 dimension */,
  CONST double d[] /* 3 dimension */,
  CONST double e[] /* 3 dimension */,
  CONST double f[] /* 3 dimension */,
  CONST double g[] /* 3 dimension */,
  CONST double q[] /* 3 dimension */,
  double t[] /* 3 dimension */,
  CONST double *aparam,
  CONST int *itmax,
  int *itcoun,
  int *itused,
  CONST int *ndir,
  CONST int *ixn,
  CONST int *iyn,
  CONST int *izn,
  CONST double *conres,
  CONST double *conchn,
  double resids[],
  double chngs[],
  double wrksp1[] /* 3 dimension */,
  double wrksp2[] /* 3 dimension */,
  double wrksp3[] /* 3 dimension */,
  double wrksp4[] /* 3 dimension */,
  int *ifail
#endif
);

extern void d03edf_(
#ifdef __STDC__
  CONST int *ngx,
  CONST int *ngy,
  CONST int *lda,
  double a[] /* 2 dimension */,
  double rhs[],
  double ub[],
  CONST int *maxit,
  CONST double *acc,
  double us[],
  double u[],
  CONST int *iout,
  int *numit,
  int *ifail
#endif
);

extern void d03eef_(
#ifdef __STDC__
  CONST double *xmin,
  CONST double *xmax,
  CONST double *ymin,
  CONST double *ymax,
  void (*pdef)(double *, double *, double *, double *, double *, double *, 
               double *, double *, double *),
  void (*bndy)(double *, double *, double *, double *, double *, int *),
  CONST int *ngx,
  CONST int *ngy,
  CONST int *lda,
  double a[] /* 2 dimension */,
  double rhs[],
  CONST char scheme[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d03faf_(
#ifdef __STDC__
  CONST double *xs,
  CONST double *xf,
  CONST int *l,
  CONST int *lbdcnd,
  CONST double bdxs[] /* 2 dimension */,
  CONST double bdxf[] /* 2 dimension */,
  CONST double *ys,
  CONST double *yf,
  CONST int *m,
  CONST int *mbdcnd,
  CONST double bdys[] /* 2 dimension */,
  CONST double bdyf[] /* 2 dimension */,
  CONST double *zs,
  CONST double *zf,
  CONST int *n,
  CONST int *nbdcnd,
  CONST double bdzs[] /* 2 dimension */,
  CONST double bdzf[] /* 2 dimension */,
  CONST double *lambda,
  CONST int *ldimf,
  CONST int *mdimf,
  double f[] /* 3 dimension */,
  double *pertrb,
  double w[],
  CONST int *lwrk,
  int *ifail
#endif
);

extern void d03maf_(
#ifdef __STDC__
  CONST double *h,
  CONST int *m,
  CONST int *n,
  CONST int *nb,
  int *npts,
  double places[] /* 2 dimension */,
  int index[] /* 2 dimension */,
  CONST int *idim,
  int (*in)(double *, double *),
  double dist[] /* 2 dimension */,
  CONST int *ld,
  int *ifail
#endif
);

extern void d03ncf_(
#ifdef __STDC__
  CONST int *kopt,
  CONST double *x,
  CONST char mesh[],
  CONST int *ns,
  double s[],
  CONST int *nt,
  double t[],
  CONST int tdpar[],
  CONST double r[],
  CONST double q[],
  CONST double sigma[],
  CONST double *alpha,
  CONST int *ntkeep,
  double f[] /* 2 dimension */,
  double theta[] /* 2 dimension */,
  double delta[] /* 2 dimension */,
  double gamma[] /* 2 dimension */,
  double lambda[] /* 2 dimension */,
  double rho[] /* 2 dimension */,
  CONST int *ldf,
  double work[],
  int iwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d03ndf_(
#ifdef __STDC__
  CONST int *kopt,
  CONST double *x,
  CONST double *s,
  CONST double *t,
  CONST double *tmat,
  CONST int tdpar[],
  CONST double r[],
  CONST double q[],
  CONST double sigma[],
  double *f,
  double *theta,
  double *delta,
  double *gamma,
  double *lambda,
  double *rho,
  int *ifail
#endif
);

extern void d03nef_(
#ifdef __STDC__
  CONST double *t0,
  CONST double *tmat,
  CONST int *ntd,
  CONST double td[],
  CONST double phid[],
  double phiav[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void d03paf_(
#ifdef __STDC__
  CONST int *m,
  CONST double *a,
  CONST double *b,
  double *ts,
  double *tout,
  double u[],
  CONST int *npts,
  CONST double *acc,
  double work[],
  CONST int *iwk,
  int *ind,
  int *ifail
#endif
);

extern void d03paz_(
#ifdef __STDC__
  int *npde,
  double x[],
  int *npts,
  double *ts,
  double *tlast,
  double u[] /* 2 dimension */,
  int *iu,
  double *tout,
  double *dt
#endif
);

extern void d03pbf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  void (*pdef)(int *, double *, double *, double[], double[], double[], 
               double[], double[]),
  void (*bndy)(int *, double *, double[], int *, double[], double[], double[]),
  CONST double *a,
  CONST double *b,
  double *ts,
  double *tout,
  double u[] /* 2 dimension */,
  CONST int *npts,
  CONST int *imesh,
  double x[],
  CONST double *acc,
  double work[],
  CONST int *iwk,
  int *ind,
  int *ifail
#endif
);

extern void d03pcf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], double[], 
                 double[], double[], int *),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *),
  double u[] /* 2 dimension */,
  CONST int *npts,
  double x[],
  CONST double *acc,
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail
#endif
);

extern void d03pca_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], double[], 
                 double[], double[], int *, int[], double[]),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, int[], double[]),
  double u[] /* 2 dimension */,
  CONST int *npts,
  double x[],
  CONST double *acc,
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int iuser[],
  double ruser[],
  char cwsav[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d03pck_(
#ifdef __STDC__
  int *npde,
  double *t,
  int *nv,
  double v[],
  double vdot[],
  int *nxi,
  double xi[],
  double u[] /* 2 dimension */,
  double ux[] /* 2 dimension */,
  double ri[] /* 2 dimension */,
  double uti[] /* 2 dimension */,
  double utxi[] /* 2 dimension */,
  double vres[],
  int *ires
#endif
);

extern void d53pck_(
#ifdef __STDC__
  int *npde,
  double *t,
  int *nv,
  double v[],
  double vdot[],
  int *nxi,
  double xi[],
  double u[] /* 2 dimension */,
  double ux[] /* 2 dimension */,
  double ri[] /* 2 dimension */,
  double uti[] /* 2 dimension */,
  double utxi[] /* 2 dimension */,
  double vres[],
  int *ires,
  int iuser[],
  double ruser[]
#endif
);

extern void d03pcl_(
#ifdef __STDC__
  double *time,
  int *nip,
  int *npde,
  double x[],
  double u[] /* 2 dimension */,
  double r[] /* 2 dimension */,
  int *maxnpt,
  double fmon[]
#endif
);

extern void d53pcl_(
#ifdef __STDC__
  double *time,
  int *nip,
  int *npde,
  double x[],
  double u[] /* 2 dimension */,
  double r[] /* 2 dimension */,
  double fmon[],
  int iuser[],
  double ruser[]
#endif
);

extern void d03pdf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double[], int *, double[], double[], 
                 double[], double[], double[], int *),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *),
  double u[] /* 2 dimension */,
  CONST int *nbkpts,
  CONST double xbkpts[],
  CONST int *npoly,
  CONST int *npts,
  double x[],
  void (*uinit)(int *, int *, double[], double[]),
  CONST double *acc,
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail
#endif
);

extern void d03pda_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double[], int *, double[], double[], 
                 double[], double[], double[], int *, int[], double[]),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, int[], double[]),
  double u[] /* 2 dimension */,
  CONST int *nbkpts,
  CONST double xbkpts[],
  CONST int *npoly,
  CONST int *npts,
  double x[],
  void (*uinit)(int *, int *, double[], double[], int[], double[]),
  CONST double *acc,
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int iuser[],
  double ruser[],
  char cwsav[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d03pef_(
#ifdef __STDC__
  CONST int *npde,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], double[], 
                 double[], int *),
  void (*bndary)(int *, double *, int *, int *, double[], double[], double[], 
                 int *),
  double u[] /* 2 dimension */,
  CONST int *npts,
  double x[],
  CONST int *nleft,
  CONST double *acc,
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail
#endif
);

extern void d03pek_(
#ifdef __STDC__
  int *npde,
  double *t,
  int *nv,
  double v[],
  double vdot[],
  int *nxi,
  double xi[],
  double u[] /* 2 dimension */,
  double ux[] /* 2 dimension */,
  double uti[] /* 2 dimension */,
  double vres[],
  int *ires
#endif
);

extern void d03pel_(
#ifdef __STDC__
  double *time,
  int *nip,
  int *npde,
  double x[],
  double u[] /* 2 dimension */,
  double fmon[]
#endif
);

extern void d03pff_(
#ifdef __STDC__
  CONST int *npde,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], double[], 
                 double[], double[], double[], int *),
  void (*numflx)(int *, double *, double *, double[], double[], double[], 
                 int *),
  void (*bndary)(int *, int *, double *, double[], double[], int *, double[], 
                 int *),
  double u[] /* 2 dimension */,
  CONST int *npts,
  double x[],
  CONST double acc[],
  CONST double *tsmax,
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail
#endif
);

extern void d03pfp_(
#ifdef __STDC__
  int *npde,
  double *t,
  double *x,
  double u[],
  double ux[],
  double p[] /* 2 dimension */,
  double c[],
  double d[],
  double s[],
  int *ires
#endif
);

extern void d03pgf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  void (*pdef)(int *, double[], double *, double[], double[], double[], 
               double[], double[]),
  void (*bndy)(int *, double *, double[], int *, double[], double[], double[]),
  double *ts,
  double *tout,
  double u[] /* 2 dimension */,
  CONST int *iu,
  CONST int *npts,
  double x[],
  CONST double *relerr,
  CONST double *abserr,
  CONST int *inorm,
  void (*montr)(int *, double[], int *, double *, double *, double[], int *, 
                double *, double *),
  CONST int *imon,
  int *iband,
  double work[],
  CONST int *iwk,
  int *ind,
  int *ifail
#endif
);

extern void d03phf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], int *),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], double[], int *),
  double u[],
  CONST int *npts,
  double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], double[], double[], 
                 int *),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  double algopt[],
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d03pha_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], int *, 
                 int[], double[]),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], double[], int *, int[], double[]),
  double u[],
  CONST int *npts,
  double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], double[], double[], 
                 int *, int[], double[]),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  CONST double algopt[],
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int iuser[],
  double ruser[],
  char cwsav[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void d03pjf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double[], int *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], int *),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], double[], int *),
  double u[],
  CONST int *nbkpts,
  CONST double xbkpts[],
  CONST int *npoly,
  CONST int *npts,
  double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], double[], double[], 
                 int *),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  void (*uvinit)(int *, int *, double[], double[], int *, double[]),
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  double algopt[],
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d03pja_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double[], int *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], int *, 
                 int[], double[]),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], double[], int *, int[], double[]),
  double u[],
  CONST int *nbkpts,
  CONST double xbkpts[],
  CONST int *npoly,
  CONST int *npts,
  double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], double[], double[], 
                 int *, int[], double[]),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  void (*uvinit)(int *, int *, double[], double[], int *, double[], int[], 
                 double[]),
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  CONST double algopt[],
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int iuser[],
  double ruser[],
  char cwsav[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void d03pkf_(
#ifdef __STDC__
  CONST int *npde,
  CONST double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], double[], 
                 int *, double[], double[], double[], int *),
  void (*bndary)(int *, double *, int *, int *, double[], double[], int *, 
                 double[], double[], double[], int *),
  CONST double u[],
  CONST int *npts,
  CONST double x[],
  CONST int *nleft,
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], int *),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  double algopt[],
  CONST double w[],
  CONST int *nw,
  CONST int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  CONST int *ind,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d03plf_(
#ifdef __STDC__
  CONST int *npde,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], double[], 
                 int *),
  void (*numflx)(int *, double *, double *, int *, double[], double[], 
                 double[], double[], int *),
  void (*bndary)(int *, int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], int *),
  double u[],
  CONST int *npts,
  double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], int *),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  double algopt[],
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d03plp_(
#ifdef __STDC__
  int *npde,
  double *t,
  double *x,
  double u[],
  double ux[],
  int *nv,
  double v[],
  double vdot[],
  double p[] /* 2 dimension */,
  double c[],
  double d[],
  double s[],
  int *ires
#endif
);

extern void d03ppf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  CONST double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], int *),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], double[], int *),
  void (*uvinit)(int *, int *, int *, double[], double[], double[], int *, 
                 double[]),
  CONST double u[],
  CONST int *npts,
  CONST double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], double[], double[], 
                 int *),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  double algopt[],
  CONST int *remesh,
  CONST int *nxfix,
  double xfix[],
  CONST int *nrmesh,
  CONST double *dxmesh,
  CONST double *trmesh,
  CONST int *ipminf,
  CONST double *xratio,
  CONST double *_const,
  void (*monffd)(double *, int *, int *, double[], double[], double[], 
                 double[]),
  CONST double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  CONST int *ind,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d03ppa_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], int *, 
                 int[], double[]),
  void (*bndary)(int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], double[], int *, int[], double[]),
  void (*uvinit)(int *, int *, int *, double[], double[], double[], int *, 
                 double[], int[], double[]),
  double u[],
  CONST int *npts,
  double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], double[], double[], 
                 int *, int[], double[]),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  CONST double algopt[],
  CONST int *remesh,
  CONST int *nxfix,
  CONST double xfix[],
  CONST int *nrmesh,
  CONST double *dxmesh,
  CONST double *trmesh,
  CONST int *ipminf,
  CONST double *xratio,
  CONST double *_const,
  void (*monffd)(double *, int *, int *, double[], double[], double[], 
                 double[], int[], double[]),
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int iuser[],
  double ruser[],
  char cwsav[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void d03prf_(
#ifdef __STDC__
  CONST int *npde,
  CONST double *ts,
  CONST double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], double[], 
                 int *, double[], double[], double[], int *),
  void (*bndary)(int *, double *, int *, int *, double[], double[], int *, 
                 double[], double[], double[], int *),
  void (*uvinit)(int *, int *, int *, double[], double[], double[], int *, 
                 double[]),
  CONST double u[],
  CONST int *npts,
  CONST double x[],
  CONST int *nleft,
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], int *),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  double algopt[],
  CONST int *remesh,
  CONST int *nxfix,
  double xfix[],
  CONST int *nrmesh,
  CONST double *dxmesh,
  CONST double *trmesh,
  CONST int *ipminf,
  CONST double *xratio,
  CONST double *_const,
  void (*monfkb)(double *, int *, int *, double[], double[], double[]),
  CONST double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  CONST int *ind,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d03psf_(
#ifdef __STDC__
  CONST int *npde,
  double *ts,
  double *tout,
  void (*pdedef)(int *, double *, double *, double[], double[], int *, 
                 double[], double[], double[], double[], double[], double[], 
                 int *),
  void (*numflx)(int *, double *, double *, int *, double[], double[], 
                 double[], double[], int *),
  void (*bndary)(int *, int *, double *, double[], double[], int *, double[], 
                 double[], int *, double[], int *),
  void (*uvinit)(int *, int *, int *, double[], double[], double[], int *, 
                 double[]),
  double u[],
  CONST int *npts,
  double x[],
  CONST int *ncode,
  void (*odedef)(int *, double *, int *, double[], double[], int *, double[], 
                 double[], double[], double[], double[], int *),
  CONST int *nxi,
  CONST double xi[],
  CONST int *neqn,
  CONST double rtol[],
  CONST double atol[],
  CONST int *itol,
  CONST char norm[],
  CONST char laopt[],
  double algopt[],
  int *remesh,
  CONST int *nxfix,
  double xfix[],
  CONST int *nrmesh,
  CONST double *dxmesh,
  CONST double *trmesh,
  CONST int *ipminf,
  CONST double *xratio,
  CONST double *_const,
  void (*monitf)(double *, int *, int *, double[], double[], double[]),
  double w[],
  CONST int *nw,
  int iw[],
  CONST int *niw,
  CONST int *itask,
  CONST int *itrace,
  int *ind,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void d03puf_(
#ifdef __STDC__
  CONST double uleft[],
  CONST double uright[],
  CONST double *gamma,
  double flux[],
  int *ifail
#endif
);

extern void d03pvf_(
#ifdef __STDC__
  CONST double uleft[],
  CONST double uright[],
  CONST double *gamma,
  CONST char path[],
  double flux[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d03pwf_(
#ifdef __STDC__
  CONST double uleft[],
  CONST double uright[],
  CONST double *gamma,
  double flux[],
  int *ifail
#endif
);

extern void d03pxf_(
#ifdef __STDC__
  CONST double uleft[],
  CONST double uright[],
  CONST double *gamma,
  double *tol,
  int *niter,
  double flux[],
  int *ifail
#endif
);

extern void d03pyf_(
#ifdef __STDC__
  CONST int *npde,
  CONST double u[],
  CONST int *nbkpts,
  CONST double xbkpts[],
  CONST int *npoly,
  CONST int *npts,
  CONST double xp[],
  CONST int *intpts,
  CONST int *itype,
  double uout[] /* 3 dimension */,
  double w[],
  CONST int *nw,
  int *ifail
#endif
);

extern void d03pzf_(
#ifdef __STDC__
  CONST int *npde,
  CONST int *m,
  CONST double u[] /* 2 dimension */,
  CONST int *npts,
  CONST double x[],
  CONST double xp[],
  CONST int *intpts,
  CONST int *itype,
  double uout[] /* 3 dimension */,
  int *ifail
#endif
);

extern void d03raf_(
#ifdef __STDC__
  CONST int *npde,
  double *ts,
  CONST double *tout,
  double dt[],
  double *xmin,
  double *xmax,
  double *ymin,
  double *ymax,
  CONST int *nx,
  CONST int *ny,
  CONST double *tols,
  CONST double *tolt,
  void (*pdedef)(int *, int *, double *, double[], double[], double[], 
                 double[], double[], double[], double[], double[], double[], 
                 double[]),
  void (*bndary)(int *, int *, double *, double[], double[], double[], 
                 double[], double[], double[], int *, int[], double[]),
  void (*pdeiv)(int *, int *, double *, double[], double[], double[]),
  void (*monitr)(int *, double *, double *, double *, int *, int *, int[], 
                 double[], double[], int[], double[], int *),
  int opti[],
  CONST double optr[] /* 2 dimension */,
  double rwk[],
  CONST int *lenrwk,
  int iwk[],
  CONST int *leniwk,
  int lwk[],
  CONST int *lenlwk,
  CONST int *itrace,
  int *ind,
  int *ifail
#endif
);

extern void d03rbf_(
#ifdef __STDC__
  CONST int *npde,
  double *ts,
  CONST double *tout,
  double dt[],
  CONST double *tols,
  CONST double *tolt,
  void (*inidom)(int *, double *, double *, double *, double *, int *, int *, 
                 int *, int *, int *, int *, int[], int[], int[], int[], int[], 
                 int[], int *),
  void (*pdedef)(int *, int *, double *, double[], double[], double[], 
                 double[], double[], double[], double[], double[], double[], 
                 double[]),
  void (*bndary)(int *, int *, double *, double[], double[], double[], 
                 double[], double[], double[], int *, int *, int[], int[], 
                 int[], double[]),
  void (*pdeiv)(int *, int *, double *, double[], double[], double[]),
  void (*monitr)(int *, double *, double *, double *, int *, int *, double *, 
                 double *, double *, double *, int[], int[], int[], double[], 
                 int *),
  int opti[],
  CONST double optr[] /* 2 dimension */,
  double rwk[],
  CONST int *lenrwk,
  int iwk[],
  CONST int *leniwk,
  int lwk[],
  CONST int *lenlwk,
  CONST int *itrace,
  int *ind,
  int *ifail
#endif
);

extern void d03ryf_(
#ifdef __STDC__
  CONST int *nx,
  CONST int *ny,
  CONST int *npts,
  CONST int *nrows,
  CONST int *nbnds,
  CONST int *nbpts,
  CONST int lrow[],
  CONST int irow[],
  CONST int icol[],
  CONST int llbnd[],
  CONST int ilbnd[],
  CONST int lbnd[],
  int iwk[],
  CONST int *leniwk,
  char pgrid[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d03rzf_(
#ifdef __STDC__
  CONST int *level,
  CONST int *nlev,
  CONST double *xmin,
  CONST double *ymin,
  CONST double *dxb,
  CONST double *dyb,
  CONST int lgrid[],
  CONST int istruc[],
  int *npts,
  double x[],
  double y[],
  CONST int *lenxy,
  int *ifail
#endif
);

extern void d03uaf_(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST int *n1m,
  CONST double a[] /* 2 dimension */,
  CONST double b[] /* 2 dimension */,
  CONST double c[] /* 2 dimension */,
  CONST double d[] /* 2 dimension */,
  CONST double e[] /* 2 dimension */,
  CONST double *aparam,
  CONST int *it,
  double r[] /* 2 dimension */,
  double wrksp1[] /* 2 dimension */,
  double wrksp2[] /* 2 dimension */,
  int *ifail
#endif
);

extern void d03ubf_(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST int *n3,
  CONST int *n1m,
  CONST int *n2m,
  CONST double a[] /* 3 dimension */,
  CONST double b[] /* 3 dimension */,
  CONST double c[] /* 3 dimension */,
  CONST double d[] /* 3 dimension */,
  CONST double e[] /* 3 dimension */,
  CONST double f[] /* 3 dimension */,
  CONST double g[] /* 3 dimension */,
  CONST double *aparam,
  CONST int *it,
  double r[] /* 3 dimension */,
  double wrksp1[] /* 3 dimension */,
  double wrksp2[] /* 3 dimension */,
  double wrksp3[] /* 3 dimension */,
  int *ifail
#endif
);

extern void d04aaf_(
#ifdef __STDC__
  CONST double *xval,
  CONST int *nder,
  CONST double *hbase,
  double der[],
  double erest[],
  double (*fun)(double *),
  int *ifail
#endif
);

extern void d05aaf_(
#ifdef __STDC__
  CONST double *lambda,
  CONST double *a,
  CONST double *b,
  double (*k1)(double *, double *),
  double (*k2)(double *, double *),
  double (*g)(double *),
  double f[],
  double c[],
  CONST int *n,
  CONST int *ind,
  double w1[] /* 2 dimension */,
  double w2[] /* 2 dimension */,
  double wd[],
  CONST int *nmax,
  CONST int *mn,
  int *ifail
#endif
);

extern void d05abf_(
#ifdef __STDC__
  double (*k)(double *, double *),
  double (*g)(double *),
  CONST double *lambda,
  CONST double *a,
  CONST double *b,
  CONST int *odorev,
  CONST int *ev,
  CONST int *n,
  double cm[] /* 2 dimension */,
  double f1[] /* 2 dimension */,
  double wk[] /* 2 dimension */,
  CONST int *nmax,
  CONST int *nt2p1,
  double f[],
  double c[],
  int *ifail
#endif
);

extern void d05baf_(
#ifdef __STDC__
  double (*ck)(double *),
  double (*cg)(double *, double[]),
  double (*cf)(double *),
  CONST char method[],
  CONST int *iorder,
  CONST double *alim,
  CONST double *tlim,
  double yn[],
  double errest[],
  CONST int *nout,
  CONST double *tol,
  CONST double *thresh,
  double work[],
  CONST int *iwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void d05bdf_(
#ifdef __STDC__
  double (*ck)(double *),
  double (*cf)(double *),
  double (*cg)(double *, double *),
  CONST char initwt[],
  CONST int *iorder,
  CONST double *tlim,
  CONST double *tolnl,
  CONST int *nmesh,
  double yn[],
  double work[],
  CONST int *lwk,
  int nct[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d05bef_(
#ifdef __STDC__
  double (*ck)(double *),
  double (*cf)(double *),
  double (*cg)(double *, double *),
  CONST char initwt[],
  CONST int *iorder,
  CONST double *tlim,
  CONST double *tolnl,
  CONST int *nmesh,
  double yn[],
  double work[],
  CONST int *lwk,
  int nct[],
  int *ifail,
  CONST int length_1
#endif
);

extern void d05bwf_(
#ifdef __STDC__
  CONST char method[],
  CONST int *iorder,
  double omega[],
  CONST int *nomg,
  int *lensw,
  double sw[] /* 2 dimension */,
  CONST int *ldsw,
  CONST int *nwt,
  int *ifail,
  CONST int length_1
#endif
);

extern void d05byf_(
#ifdef __STDC__
  CONST int *iorder,
  CONST int *iq,
  CONST int *lenfw,
  double wt[],
  double sw[] /* 2 dimension */,
  CONST int *ldsw,
  double work[],
  CONST int *lwk,
  int *ifail
#endif
);

extern void d06aaf_(
#ifdef __STDC__
  CONST int *nvb,
  CONST int *nvmax,
  CONST int *nedge,
  CONST int edge[] /* 2 dimension */,
  int *nv,
  int *nelt,
  double coor[] /* 2 dimension */,
  int conn[] /* 2 dimension */,
  CONST double bspace[],
  CONST int *smooth,
  CONST double *coef,
  CONST double *power,
  CONST int *itrace,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d06abf_(
#ifdef __STDC__
  CONST int *nvb,
  CONST int *nvint,
  CONST int *nvmax,
  CONST int *nedge,
  CONST int edge[] /* 2 dimension */,
  int *nv,
  int *nelt,
  double coor[] /* 2 dimension */,
  int conn[] /* 2 dimension */,
  CONST double weight[],
  CONST int *npropa,
  CONST int *itrace,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d06acf_(
#ifdef __STDC__
  CONST int *nvb,
  CONST int *nvint,
  CONST int *nvmax,
  CONST int *nedge,
  CONST int edge[] /* 2 dimension */,
  int *nv,
  int *nelt,
  double coor[] /* 2 dimension */,
  int conn[] /* 2 dimension */,
  CONST double weight[],
  CONST int *itrace,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d06baf_(
#ifdef __STDC__
  CONST int *nlines,
  CONST double coorch[] /* 2 dimension */,
  CONST int line[] /* 2 dimension */,
  double (*fbnd)(int *, double[], double[], double[], int[]),
  CONST double coorus[] /* 2 dimension */,
  CONST int *nus,
  CONST double rate[],
  CONST int *ncomp,
  CONST int nlcomp[],
  CONST int lcomp[],
  CONST int *nvmax,
  CONST int *nedmx,
  int *nvb,
  double coor[] /* 2 dimension */,
  int *nedge,
  int edge[] /* 2 dimension */,
  CONST int *itrace,
  double ruser[],
  int iuser[],
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void d06caf_(
#ifdef __STDC__
  CONST int *nv,
  CONST int *nelt,
  CONST int *nedge,
  double coor[] /* 2 dimension */,
  CONST int edge[] /* 2 dimension */,
  CONST int conn[] /* 2 dimension */,
  CONST int *nvfix,
  CONST int numfix[],
  CONST int *itrace,
  CONST int *nqint,
  int iwork[],
  CONST int *liwork,
  double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void d06cbf_(
#ifdef __STDC__
  CONST int *nv,
  CONST int *nelt,
  CONST int *nnzmax,
  CONST int conn[] /* 2 dimension */,
  int *nnz,
  int irow[],
  int icol[],
  int *ifail
#endif
);

extern void d06ccf_(
#ifdef __STDC__
  CONST int *nv,
  CONST int *nelt,
  CONST int *nedge,
  CONST int *nnzmax,
  int *nnz,
  double coor[] /* 2 dimension */,
  int edge[] /* 2 dimension */,
  int conn[] /* 2 dimension */,
  int irow[],
  int icol[],
  CONST int *itrace,
  int iwork[],
  CONST int *liwork,
  double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void d06daf_(
#ifdef __STDC__
  CONST int *nv,
  CONST int *nedge,
  CONST int *nelt,
  CONST int *ntrans,
  CONST int itype[],
  CONST double trans[] /* 2 dimension */,
  CONST double coori[] /* 2 dimension */,
  CONST int edgei[] /* 2 dimension */,
  CONST int conni[] /* 2 dimension */,
  double cooro[] /* 2 dimension */,
  int edgeo[] /* 2 dimension */,
  int conno[] /* 2 dimension */,
  CONST int *itrace,
  double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void d06dbf_(
#ifdef __STDC__
  CONST double *eps,
  CONST int *nv1,
  CONST int *nelt1,
  CONST int *nedge1,
  CONST double coor1[] /* 2 dimension */,
  CONST int edge1[] /* 2 dimension */,
  CONST int conn1[] /* 2 dimension */,
  CONST int reft1[],
  CONST int *nv2,
  CONST int *nelt2,
  CONST int *nedge2,
  CONST double coor2[] /* 2 dimension */,
  CONST int edge2[] /* 2 dimension */,
  CONST int conn2[] /* 2 dimension */,
  CONST int reft2[],
  int *nv3,
  int *nelt3,
  int *nedge3,
  double coor3[] /* 2 dimension */,
  int edge3[] /* 2 dimension */,
  int conn3[] /* 2 dimension */,
  int reft3[],
  CONST int *itrace,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void e01aaf_(
#ifdef __STDC__
  double a[],
  double b[],
  double c[],
  CONST int *n1,
  CONST int *n2,
  CONST int *n,
  CONST double *x
#endif
);

extern void e01abf_(
#ifdef __STDC__
  CONST int *n,
  CONST double *p,
  double a[],
  double g[],
  CONST int *n1,
  CONST int *n2,
  int *ifail
#endif
);

extern void e01aef_(
#ifdef __STDC__
  CONST int *m,
  CONST double *xmin,
  CONST double *xmax,
  CONST double x[],
  CONST double y[],
  CONST int ip[],
  CONST int *n,
  CONST int *itmin,
  CONST int *itmax,
  double a[],
  double wrk[],
  CONST int *lwrk,
  int iwrk[],
  CONST int *liwrk,
  int *ifail
#endif
);

extern void e01baf_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  double k[],
  double c[],
  CONST int *lck,
  double wrk[],
  CONST int *lwrk,
  int *ifail
#endif
);

extern void e01bef_(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double f[],
  double d[],
  int *ifail
#endif
);

extern void e01bff_(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double f[],
  CONST double d[],
  CONST int *m,
  CONST double px[],
  double pf[],
  int *ifail
#endif
);

extern void e01bgf_(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double f[],
  CONST double d[],
  CONST int *m,
  CONST double px[],
  double pf[],
  double pd[],
  int *ifail
#endif
);

extern void e01bhf_(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double f[],
  CONST double d[],
  CONST double *a,
  CONST double *b,
  double *pint,
  int *ifail
#endif
);

extern void e01daf_(
#ifdef __STDC__
  CONST int *mx,
  CONST int *my,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  int *px,
  int *py,
  double lamda[],
  double mu[],
  double c[],
  double wrk[],
  int *ifail
#endif
);

extern void e01raf_(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double f[],
  int *m,
  double a[],
  double u[],
  int iw[],
  int *ifail
#endif
);

extern void e01rbf_(
#ifdef __STDC__
  CONST int *m,
  CONST double a[],
  CONST double u[],
  CONST double *x,
  double *f,
  int *ifail
#endif
);

extern void e01saf_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  int triang[],
  double grads[] /* 2 dimension */,
  int *ifail
#endif
);

extern void e01sbf_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  CONST int triang[],
  CONST double grads[] /* 2 dimension */,
  CONST double *px,
  CONST double *py,
  double *pf,
  int *ifail
#endif
);

extern void e01sef_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  double *rnw,
  double *rnq,
  CONST int *nw,
  CONST int *nq,
  double fnodes[],
  int *minnq,
  double wrk[],
  int *ifail
#endif
);

extern void e01sff_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  CONST double *rnw,
  CONST double fnodes[] /* 2 dimension */,
  CONST double *px,
  CONST double *py,
  double *pf,
  int *ifail
#endif
);

extern void e01sgf_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  CONST int *nw,
  CONST int *nq,
  int iq[],
  CONST int *liq,
  double rq[],
  CONST int *lrq,
  int *ifail
#endif
);

extern void e01shf_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  CONST int iq[],
  CONST int *liq,
  CONST double rq[],
  CONST int *lrq,
  CONST int *n,
  CONST double u[],
  CONST double v[],
  double q[],
  double qx[],
  double qy[],
  int *ifail
#endif
);

extern void e01tgf_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double z[],
  CONST double f[],
  CONST int *nw,
  CONST int *nq,
  int iq[],
  CONST int *liq,
  double rq[],
  CONST int *lrq,
  int *ifail
#endif
);

extern void e01thf_(
#ifdef __STDC__
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double z[],
  CONST double f[],
  CONST int iq[],
  CONST int *liq,
  CONST double rq[],
  CONST int *lrq,
  CONST int *n,
  CONST double u[],
  CONST double v[],
  CONST double w[],
  double q[],
  double qx[],
  double qy[],
  double qz[],
  int *ifail
#endif
);

extern void e02acf_(
#ifdef __STDC__
  CONST double x[],
  CONST double y[],
  CONST int *n,
  double aa[],
  CONST int *m1,
  double *ref
#endif
);

extern void e02adf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *kplus1,
  CONST int *nrows,
  CONST double x[],
  CONST double y[],
  CONST double w[],
  double work1[] /* 2 dimension */,
  double work2[] /* 2 dimension */,
  double a[] /* 2 dimension */,
  double s[],
  int *ifail
#endif
);

extern void e02aef_(
#ifdef __STDC__
  CONST int *nplus1,
  CONST double a[],
  CONST double *xcap,
  double *p,
  int *ifail
#endif
);

extern void e02aff_(
#ifdef __STDC__
  CONST int *nplus1,
  CONST double f[],
  double a[],
  int *ifail
#endif
);

extern void e02agf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *kplus1,
  CONST int *nrows,
  CONST double *xmin,
  CONST double *xmax,
  CONST double x[],
  CONST double y[],
  CONST double w[],
  CONST int *mf,
  CONST double xf[],
  CONST double yf[],
  CONST int *lyf,
  CONST int ip[],
  double a[] /* 2 dimension */,
  double s[],
  int *np1,
  double wrk[],
  CONST int *lwrk,
  int iwrk[],
  CONST int *liwrk,
  int *ifail
#endif
);

extern void e02ahf_(
#ifdef __STDC__
  CONST int *np1,
  CONST double *xmin,
  CONST double *xmax,
  CONST double a[],
  CONST int *ia1,
  CONST int *la,
  double *patm1,
  double adif[],
  CONST int *iadif1,
  CONST int *ladif,
  int *ifail
#endif
);

extern void e02ajf_(
#ifdef __STDC__
  CONST int *np1,
  CONST double *xmin,
  CONST double *xmax,
  CONST double a[],
  CONST int *ia1,
  CONST int *la,
  CONST double *qatm1,
  double ain[],
  CONST int *iaint1,
  CONST int *laint,
  int *ifail
#endif
);

extern void e02akf_(
#ifdef __STDC__
  CONST int *np1,
  CONST double *xmin,
  CONST double *xmax,
  CONST double a[],
  CONST int *ia1,
  CONST int *la,
  CONST double *x,
  double *result,
  int *ifail
#endif
);

extern void e02baf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *ncap7,
  CONST double x[],
  CONST double y[],
  CONST double w[],
  double k[],
  double work1[],
  double work2[] /* 2 dimension */,
  double c[],
  double *ss,
  int *ifail
#endif
);

extern void e02bbf_(
#ifdef __STDC__
  CONST int *ncap7,
  CONST double k[],
  CONST double c[],
  CONST double *x,
  double *s,
  int *ifail
#endif
);

extern void e02bcf_(
#ifdef __STDC__
  CONST int *ncap7,
  CONST double k[],
  CONST double c[],
  CONST double *x,
  CONST int *left,
  double s[],
  int *ifail
#endif
);

extern void e02bdf_(
#ifdef __STDC__
  CONST int *ncap7,
  CONST double k[],
  CONST double c[],
  double *defint,
  int *ifail
#endif
);

extern void e02bef_(
#ifdef __STDC__
  CONST char start[],
  CONST int *m,
  CONST double x[],
  CONST double y[],
  CONST double w[],
  CONST double *s,
  CONST int *nest,
  int *n,
  double k[],
  double c[],
  double *fp,
  double wrk[],
  CONST int *lwrk,
  int iwrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void e02caf_(
#ifdef __STDC__
  CONST int m[],
  CONST int *n,
  CONST int *k,
  CONST int *l,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  CONST double w[],
  CONST int *nx,
  double a[],
  CONST int *na,
  CONST double xmin[],
  CONST double xmax[],
  CONST double nux[],
  CONST int *inuxp1,
  CONST double nuy[],
  CONST int *inuyp1,
  double work[],
  CONST int *nwork,
  int *ifail
#endif
);

extern void e02cbf_(
#ifdef __STDC__
  CONST int *mfirst,
  CONST int *mlast,
  CONST int *k,
  CONST int *l,
  CONST double x[],
  CONST double *xmin,
  CONST double *xmax,
  CONST double *y,
  CONST double *ymin,
  CONST double *ymax,
  double ff[],
  CONST double a[],
  CONST int *na,
  double work[],
  CONST int *nwork,
  int *ifail
#endif
);

extern void e02daf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *px,
  CONST int *py,
  CONST double x[],
  CONST double y[],
  CONST double f[],
  CONST double w[],
  double lamda[],
  double mu[],
  CONST int point[],
  CONST int *npoint,
  double dl[],
  double c[],
  CONST int *nc,
  double ws[],
  CONST int *nws,
  CONST double *eps,
  double *sigma,
  int *rank,
  int *ifail
#endif
);

extern void e02dbf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *px,
  CONST int *py,
  CONST double x[],
  CONST double y[],
  double ff[],
  CONST double lamda[],
  CONST double mu[],
  CONST int point[],
  CONST int *npoint,
  CONST double c[],
  CONST int *nc,
  int *ifail
#endif
);

extern void e02dcf_(
#ifdef __STDC__
  CONST char start[],
  CONST int *mx,
  CONST double x[],
  CONST int *my,
  CONST double y[],
  CONST double f[],
  CONST double *s,
  CONST int *nxest,
  CONST int *nyest,
  int *nx,
  double lamda[],
  int *ny,
  double mu[],
  double c[],
  double *fp,
  double wrk[],
  CONST int *lwrk,
  int iwrk[],
  CONST int *liwrk,
  int *ifail,
  CONST int length_1
#endif
);

extern void e02ddf_(
#ifdef __STDC__
  CONST char start[],
  CONST int *m,
  double x[],
  double y[],
  CONST double f[],
  CONST double w[],
  CONST double *s,
  CONST int *nxest,
  CONST int *nyest,
  int *nx,
  double lamda[],
  int *ny,
  double mu[],
  double c[],
  double *fp,
  int *rank,
  double wrk[],
  CONST int *lwrk,
  int iwrk[],
  CONST int *liwrk,
  int *ifail,
  CONST int length_1
#endif
);

extern void e02def_(
#ifdef __STDC__
  CONST int *m,
  CONST int *px,
  CONST int *py,
  CONST double x[],
  CONST double y[],
  CONST double lamda[],
  CONST double mu[],
  CONST double c[],
  double ff[],
  double wrk[],
  int iwrk[],
  int *ifail
#endif
);

extern void e02dff_(
#ifdef __STDC__
  CONST int *mx,
  CONST int *my,
  CONST int *px,
  CONST int *py,
  CONST double x[],
  CONST double y[],
  CONST double lamda[],
  CONST double mu[],
  CONST double c[],
  double ff[],
  double wrk[],
  CONST int *lwrk,
  int iwrk[],
  CONST int *liwrk,
  int *ifail
#endif
);

extern void e02gaf_(
#ifdef __STDC__
  CONST int *m,
  double a[] /* 2 dimension */,
  CONST int *la,
  double b[],
  CONST int *nplus2,
  CONST double *tol,
  double x[],
  double *resid,
  int *irank,
  int *iter,
  int iwork[],
  int *ifail
#endif
);

extern void e02gbf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *mpl1,
  double e[] /* 2 dimension */,
  CONST int *ier,
  CONST double f[],
  double x[],
  CONST int *mxs1,
  void (*monit)(int *, double[], int *, int *, double *),
  CONST int *iprint,
  int *k,
  double *el1n,
  int indx[],
  double w[],
  CONST int *iw,
  int *ifail
#endif
);

extern void e02gcf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *mdim,
  CONST int *ndim,
  double a[] /* 2 dimension */,
  double b[],
  CONST double *tol1,
  double *reler,
  double x[],
  double *resmax,
  int *irank,
  int *iter,
  int *ifail
#endif
);

extern void e02raf_(
#ifdef __STDC__
  CONST int *ia,
  CONST int *ib,
  CONST double c[],
  CONST int *ic,
  double a[],
  double b[],
  double w[],
  CONST int *jw,
  int *ifail
#endif
);

extern void e02rbf_(
#ifdef __STDC__
  CONST double a[],
  CONST int *ia,
  CONST double b[],
  CONST int *ib,
  CONST double *x,
  double *ans,
  int *ifail
#endif
);

extern void e02zaf_(
#ifdef __STDC__
  CONST int *px,
  CONST int *py,
  CONST double lamda[],
  CONST double mu[],
  CONST int *m,
  CONST double x[],
  CONST double y[],
  int point[],
  CONST int *npoint,
  int adres[],
  CONST int *nadres,
  int *ifail
#endif
);

extern void e04abf_(
#ifdef __STDC__
  void (*fun)(double *, double *),
  double *eps,
  double *t,
  double *a,
  double *b,
  int *maxcal,
  double *x,
  double *f,
  int *ifail
#endif
);

extern void e04aba_(
#ifdef __STDC__
  void (*fun)(double *, double *, int[], double[]),
  double *eps,
  double *t,
  double *a,
  double *b,
  int *maxcal,
  double *x,
  double *f,
  int iuser[],
  double ruser[],
  int *ifail
#endif
);

extern void e04bbf_(
#ifdef __STDC__
  void (*fun)(double *, double *, double *),
  double *eps,
  double *t,
  double *a,
  double *b,
  int *maxcal,
  double *x,
  double *f,
  double *g,
  int *ifail
#endif
);

extern void e04bba_(
#ifdef __STDC__
  void (*fun)(double *, double *, double *, int[], double[]),
  double *eps,
  double *t,
  double *a,
  double *b,
  int *maxcal,
  double *x,
  double *f,
  double *g,
  int iuser[],
  double ruser[],
  int *ifail
#endif
);

extern void e04ccf_(
#ifdef __STDC__
  CONST int *n,
  double x[],
  double *fmin,
  CONST double *eps,
  CONST int *n1,
  double pdstar[],
  double pstar[],
  double pbar[],
  double step[],
  double y[],
  double p[] /* 2 dimension */,
  void (*funct)(int *, double[], double *),
  void (*monit)(double *, double *, double[], int *, int *, int *),
  CONST int *maxit,
  int *ifail
#endif
);

extern void e04cca_(
#ifdef __STDC__
  CONST int *n,
  double x[],
  double *fmin,
  CONST double *eps,
  CONST int *n1,
  double pdstar[],
  double pstar[],
  double pbar[],
  double step[],
  double y[],
  double p[] /* 2 dimension */,
  void (*funct)(int *, double[], double *, int[], double[]),
  void (*monit)(double *, double *, double[], int *, int *, int *, int[], 
                double[]),
  CONST int *maxit,
  int iuser[],
  double ruser[],
  int *ifail
#endif
);

extern void e04dgf_(
#ifdef __STDC__
  CONST int *n,
  void (*fungrd)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  int *iter,
  double *objf,
  double objgrd[],
  double x[],
  int iwork[],
  double work[],
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04dga_(
#ifdef __STDC__
  CONST int *n,
  void (*fungrd)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  int *iter,
  double *objf,
  double objgrd[],
  double x[],
  int iwork[],
  double work[],
  int iuser[],
  double user[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

extern void e04djf_(
#ifdef __STDC__
  CONST int *ioptns,
  int *inform
#endif
);

extern void e04dja_(
#ifdef __STDC__
  CONST int *ioptns,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform
#endif
);

extern void e04dkf_(
#ifdef __STDC__
  CONST char string[],
  CONST int length_1
#endif
);

extern void e04dka_(
#ifdef __STDC__
  CONST char string[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform,
  CONST int length_1
#endif
);

extern void e04fcf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  void (*lsfn1)(int *, int *, int *, double[], double[], int[], int *, 
                double[], int *),
  void (*lsmon)(int *, int *, double[], double[], double[], int *, double[], 
                int *, int *, int *, int[], int *, double[], int *),
  CONST int *iprint,
  CONST int *maxcal,
  CONST double *eta,
  CONST double *xtol,
  CONST double *stepmx,
  double x[],
  double *fsumsq,
  double fvec[],
  double fjac[] /* 2 dimension */,
  CONST int *lj,
  double s[],
  double vt[] /* 2 dimension */,
  CONST int *lvt,
  int *niter,
  int *nftotl,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04fcv_(
#ifdef __STDC__
  int *m,
  int *n,
  void (*lsfjs)(int *, int *, int *, void *, double[], double[], double[], 
                int *, int[], int *, double[], int *),
  void (*lsf)(),
  double *eps,
  double *t,
  double *eta,
  double *sftbnd,
  double *xlamda,
  double p[],
  double *gtp,
  double x[],
  double *f,
  double *alpha,
  double fjac[] /* 2 dimension */,
  int *lj,
  double fvec[],
  double g[],
  int *nftotl,
  int *iflag,
  int iw[],
  int *liw,
  double w[],
  int *lw
#endif
);

extern void e04fdf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  double *fsumsq,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04fdz_(
#ifdef __STDC__
  int *m,
  int *n,
  double x[],
  double fvec[],
  double fjac[] /* 2 dimension */,
  int *lj,
  double s[],
  int *igrade,
  int *niter,
  int *nftotl,
  int iw[],
  int *liw,
  double w[],
  int *lw
#endif
);

extern void e04fyf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  void (*lsfun1)(int *, int *, double[], double[], int[], double[]),
  double x[],
  double *fsumsq,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04gbf_(
#ifdef __STDC__
  int *m,
  int *n,
  void (*lsqlin)(int *, int *, void *, void *, double *, double *, double *, 
                 double *, double *, double[], double *, double[], double *, 
                 double *, double[], int *, double[], double[], int *, int *, 
                 int[], int *, double[], int *),
  void (*lsfjc)(int *, int *, int *, double[], double[], double[], int *, 
                int[], int *, double[], int *),
  void (*lsmon)(int *, int *, double[], double[], double[], int *, double[], 
                int *, int *, int *, int[], int *, double[], int *),
  CONST int *iprint,
  CONST int *maxcal,
  CONST double *eta,
  CONST double *xtol,
  CONST double *stepmx,
  double x[],
  double *fsumsq,
  double fvec[],
  double fjac[] /* 2 dimension */,
  int *lj,
  double s[],
  double vt[] /* 2 dimension */,
  CONST int *lvt,
  int *niter,
  int *nftotl,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04gcf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  double *fsumsq,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04gdf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  void (*lsfjc)(int *, int *, int *, double[], double[], double[], int *, 
                int[], int *, double[], int *),
  void (*lsmon)(int *, int *, double[], double[], double[], int *, double[], 
                int *, int *, int *, int[], int *, double[], int *),
  CONST int *iprint,
  CONST int *maxfun,
  CONST double *eta,
  CONST double *xtol,
  CONST double *stepmx,
  double x[],
  double *fsumsq,
  double fvec[],
  double fjac[] /* 2 dimension */,
  CONST int *lj,
  double s[],
  double vt[] /* 2 dimension */,
  CONST int *lvt,
  int *niter,
  int *nftotl,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04gef_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  double *fsumsq,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04gyf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  void (*lsfun2)(int *, int *, double[], double[], double[], int *, int[], 
                 double[]),
  double x[],
  double *fsumsq,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04gzf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  void (*lsfun2)(int *, int *, double[], double[], double[], int *, int[], 
                 double[]),
  double x[],
  double *fsumsq,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04hbf_(
#ifdef __STDC__
  int *n,
  void (*sfun)(int *, int *, double[], double *, double[], int[], int *, 
               double[], int *),
  double x[],
  int *nf,
  double delta[],
  double hesl[],
  CONST int *lh,
  double hesd[],
  double *f,
  double g[],
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04hcf_(
#ifdef __STDC__
  int *n,
  void (*sfun)(int *, int *, double[], double *, double[], int[], int *, 
               double[], int *),
  double x[],
  double *f,
  double g[],
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04hdf_(
#ifdef __STDC__
  int *n,
  void (*sfun)(int *, int *, double[], double *, double[], int[], int *, 
               double[], int *),
  void (*shess)(int *, int *, double[], double[], int *, double[], int[], 
                int *, double[], int *),
  double x[],
  double g[],
  double hesl[],
  int *lh,
  double hesd[],
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04hef_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  void (*lsfjc)(int *, int *, int *, double[], double[], double[], int *, 
                int[], int *, double[], int *),
  void (*lshes)(int *, int *, int *, double[], double[], double[], int *, 
                int[], int *, double[], int *),
  void (*lsmon)(int *, int *, double[], double[], double[], int *, double[], 
                int *, int *, int *, int[], int *, double[], int *),
  CONST int *iprint,
  CONST int *maxcal,
  CONST double *eta,
  CONST double *xtol,
  CONST double *stepmx,
  double x[],
  double *fsumsq,
  double fvec[],
  double fjac[] /* 2 dimension */,
  CONST int *lj,
  double s[],
  double vt[] /* 2 dimension */,
  CONST int *lvt,
  int *niter,
  int *nftotl,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04hev_(
#ifdef __STDC__
  int *m,
  int *n,
  void (*lsfjs)(int *, int *, int *, void *, double[], double[], double[], 
                int *, int[], int *, double[], int *),
  void (*lsf)(),
  double *eps,
  double *t,
  double *eta,
  double *sftbnd,
  double *xlamda,
  double p[],
  double *gtp,
  double x[],
  double *f,
  double *alpha,
  double fjac[] /* 2 dimension */,
  int *lj,
  double fvec[],
  double g[],
  int *nftotl,
  int *iflag,
  int iw[],
  int *liw,
  double w[],
  int *lw
#endif
);

extern void e04hff_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double x[],
  double *fsumsq,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04hyf_(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  void (*lsfun2)(int *, int *, double[], double[], double[], int *, int[], 
                 double[]),
  void (*lshes2)(int *, int *, double[], double[], double[], int *, int[], 
                 double[]),
  double x[],
  double *fsumsq,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04jaf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  double bl[],
  double bu[],
  double x[],
  double *f,
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04jyf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  void (*funct1)(int *, double[], double *, int[], double[]),
  double bl[],
  double bu[],
  double x[],
  double *f,
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04kaf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  double bl[],
  double bu[],
  double x[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04kcf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  double bl[],
  double bu[],
  double x[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04kdf_(
#ifdef __STDC__
  CONST int *n,
  void (*sfun)(int *, int *, double[], double *, double[], int[], int *, 
               double[], int *),
  void (*monit)(int *, double[], double *, double[], int[], double *, double *, 
                int *, int *, int *, int[], int *, double[], int *),
  CONST int *iprint,
  CONST int *maxfun,
  CONST double *eta,
  CONST double *xtol,
  CONST double *delta,
  CONST double *stepmx,
  CONST int *ibound,
  double bl[],
  double bu[],
  double x[],
  double hesl[],
  CONST int *lh,
  double hesd[],
  int istate[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04kyf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  void (*funct2)(int *, double[], double *, double[], int[], double[]),
  double bl[],
  double bu[],
  double x[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04kzf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  void (*funct2)(int *, double[], double *, double[], int[], double[]),
  double bl[],
  double bu[],
  double x[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04laf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  double bl[],
  double bu[],
  double x[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04lbf_(
#ifdef __STDC__
  CONST int *n,
  void (*sfun)(int *, int *, double[], double *, double[], int[], int *, 
               double[], int *),
  void (*shess)(int *, int *, double[], double[], int *, double[], int[], 
                int *, double[], int *),
  void (*monit)(int *, double[], double *, double[], int[], double *, double *, 
                int *, int *, int *, int[], int *, double[], int *),
  CONST int *iprint,
  CONST int *maxfun,
  CONST double *eta,
  CONST double *xtol,
  CONST double *stepmx,
  CONST int *ibound,
  double bl[],
  double bu[],
  double x[],
  double hesl[],
  CONST int *lh,
  double hesd[],
  int istate[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04lbs_(
#ifdef __STDC__
  int *n,
  void (*sfun)(int *, int *, double[], double *, double[], int[], int *, 
               double[], int *),
  double *eps,
  double *t,
  double *eta,
  double *sftbnd,
  double *xlamda,
  double p[],
  double *gtp,
  double x[],
  double *f,
  double *alpha,
  double g[],
  int *nftotl,
  int *iflag,
  int iw[],
  int *liw,
  double w[],
  int *lw
#endif
);

extern void e04lyf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *ibound,
  void (*funct2)(int *, double[], double *, double[], int[], double[]),
  void (*hess2)(int *, double[], double[], int *, double[], int[], double[]),
  double bl[],
  double bu[],
  double x[],
  double *f,
  double g[],
  int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04mbf_(
#ifdef __STDC__
  CONST int *itmax,
  CONST int *msglvl,
  CONST int *n,
  CONST int *nclin,
  CONST int *nctotl,
  CONST int *nrowa,
  CONST double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  CONST int *linobj,
  double x[],
  int istate[],
  double *objlp,
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04mff_(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  int istate[],
  double x[],
  int *iter,
  double *obj,
  double ax[],
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04mfa_(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  int istate[],
  double x[],
  int *iter,
  double *obj,
  double ax[],
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

extern void e04mgf_(
#ifdef __STDC__
  CONST int *ioptns,
  int *inform
#endif
);

extern void e04mga_(
#ifdef __STDC__
  CONST int *ioptns,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform
#endif
);

extern void e04mhf_(
#ifdef __STDC__
  CONST char string[],
  CONST int length_1
#endif
);

extern void e04mha_(
#ifdef __STDC__
  CONST char string[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform,
  CONST int length_1
#endif
);

extern void e04mzf_(
#ifdef __STDC__
  CONST int *infile,
  CONST int *maxn,
  CONST int *maxm,
  CONST int *maxnnz,
  CONST double *xbldef,
  CONST double *xbudef,
  CONST int *mpslst,
  int *n,
  int *m,
  int *nnz,
  int *iobj,
  int *ncolh,
  double a[],
  int ha[],
  int ka[],
  double bl[],
  double bu[],
  char start[],
  char names[],
  int *nname,
  char crname[],
  double xs[],
  int istate[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void e04naf_(
#ifdef __STDC__
  CONST int *itmax,
  CONST int *msglvl,
  CONST int *n,
  CONST int *nclin,
  CONST int *nctotl,
  CONST int *nrowa,
  CONST int *nrowh,
  CONST int *ncolh,
  CONST double *bigbnd,
  CONST double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  CONST double featol[],
  CONST double hess[] /* 2 dimension */,
  void (*qphess)(int *, int *, int *, int *, double[], double[], double[]),
  CONST int *cold,
  CONST int *lp,
  CONST int *orthog,
  double x[],
  int istate[],
  int *iter,
  double *obj,
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04nan_(
#ifdef __STDC__
  int *n,
  int *nrowh,
  int *ncolh,
  int *jthcol,
  double hess[] /* 2 dimension */,
  double x[],
  double hx[]
#endif
);

extern void e04ncf_(
#ifdef __STDC__
  CONST int *mm,
  CONST int *n,
  CONST int *nclin,
  CONST int *lda,
  CONST int *ldr,
  CONST double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  int istate[],
  int kx[],
  double x[],
  double r[] /* 2 dimension */,
  double b[],
  int *iter,
  double *obj,
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04nca_(
#ifdef __STDC__
  CONST int *mm,
  CONST int *n,
  CONST int *nclin,
  CONST int *lda,
  CONST int *ldr,
  CONST double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  int istate[],
  int kx[],
  double x[],
  double r[] /* 2 dimension */,
  double b[],
  int *iter,
  double *obj,
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

extern void e04ndf_(
#ifdef __STDC__
  CONST int *ioptns,
  int *inform
#endif
);

extern void e04nda_(
#ifdef __STDC__
  CONST int *ioptns,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform
#endif
);

extern void e04nef_(
#ifdef __STDC__
  CONST char string[],
  CONST int length_1
#endif
);

extern void e04nea_(
#ifdef __STDC__
  CONST char string[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform,
  CONST int length_1
#endif
);

extern void e04nff_(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  CONST double h[] /* 2 dimension */,
  CONST int *ldh,
  void (*qphess)(int *, int *, double[], int *, double[], double[]),
  int istate[],
  double x[],
  int *iter,
  double *obj,
  double ax[],
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04nfa_(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double bl[],
  CONST double bu[],
  CONST double cvec[],
  CONST double h[] /* 2 dimension */,
  CONST int *ldh,
  void (*qphess)(int *, int *, double[], int *, double[], double[], int[], 
                 double[]),
  int istate[],
  double x[],
  int *iter,
  double *obj,
  double ax[],
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int iuser[],
  double ruser[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

extern void e04nfu_(
#ifdef __STDC__
  int *n,
  int *jthcol,
  double h[] /* 2 dimension */,
  int *ldh,
  double x[],
  double hx[]
#endif
);

extern void e54nfu_(
#ifdef __STDC__
  int *n,
  int *jthcol,
  double h[] /* 2 dimension */,
  int *ldh,
  double x[],
  double hx[],
  int iuser[],
  double ruser[],
  int iwsav[]
#endif
);

extern void e04ngf_(
#ifdef __STDC__
  CONST int *ioptns,
  int *inform
#endif
);

extern void e04nga_(
#ifdef __STDC__
  CONST int *ioptns,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform
#endif
);

extern void e04nhf_(
#ifdef __STDC__
  CONST char string[],
  CONST int length_1
#endif
);

extern void e04nha_(
#ifdef __STDC__
  CONST char string[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform,
  CONST int length_1
#endif
);

extern void e04nkf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *nnz,
  CONST int *iobj,
  CONST int *ncolh,
  void (*qphx)(int *, int *, double[], double[]),
  double a[],
  CONST int ha[],
  CONST int ka[],
  double bl[],
  double bu[],
  CONST char start[],
  char names[],
  CONST int *nname,
  CONST char crname[],
  int *ns,
  double xs[],
  int istate[],
  int *miniz,
  int *minz,
  int *ninf,
  double *sinf,
  double *obj,
  double clamda[],
  int iz[],
  CONST int *leniz,
  double z[],
  CONST int *lenz,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void e04nka_(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *nnz,
  CONST int *iobj,
  CONST int *ncolh,
  void (*qphx)(int *, int *, double[], double[], int[], double[]),
  double a[],
  CONST int ha[],
  CONST int ka[],
  double bl[],
  double bu[],
  CONST char start[],
  char names[],
  CONST int *nname,
  CONST char crname[],
  int *ns,
  double xs[],
  int istate[],
  int *miniz,
  int *minz,
  int *ninf,
  double *sinf,
  double *obj,
  double clamda[],
  int iz[],
  CONST int *leniz,
  double z[],
  CONST int *lenz,
  int iuser[],
  double ruser[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void e54nku_(
#ifdef __STDC__
  int *nstate,
  int *ncolh,
  double x[],
  double hx[],
  int iuser[],
  double ruser[]
#endif
);

extern void e04nlf_(
#ifdef __STDC__
  CONST int *ioptns,
  int *inform
#endif
);

extern void e04nla_(
#ifdef __STDC__
  CONST int *ioptns,
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform
#endif
);

extern void e04nmf_(
#ifdef __STDC__
  CONST char string[],
  CONST int length_1
#endif
);

extern void e04nma_(
#ifdef __STDC__
  CONST char string[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *inform,
  CONST int length_1
#endif
);

extern void e04npf_(
#ifdef __STDC__
  char cw[],
  CONST int *lencw,
  int iw[],
  CONST int *leniw,
  double rw[],
  CONST int *lenrw,
  int *ifail,
  CONST int length_1
#endif
);

extern void e04nqf_(
#ifdef __STDC__
  CONST char start[],
  void (*qphx)(int *, double[], double[], int *, char[], int[], double[],int length_1),
  CONST int *m,
  CONST int *n,
  CONST int *ne,
  CONST int *nname,
  CONST int *lenc,
  CONST int *ncolh,
  CONST int *iobj,
  CONST double *objadd,
  CONST char prob[],
  double acol[],
  CONST int inda[],
  CONST int loca[],
  double bl[],
  double bu[],
  double c[],
  CONST char names[],
  CONST int helast[],
  int hs[],
  double x[],
  double pi[],
  double rc[],
  int *ns,
  int *ninf,
  double *sinf,
  double *obj,
  char cw[],
  CONST int *lencw,
  int iw[],
  CONST int *leniw,
  double rw[],
  CONST int *lenrw,
  char cuser[],
  int iuser[],
  double ruser[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5
#endif
);

extern void e04nrf_(
#ifdef __STDC__
  CONST int *ispecs,
  char cw[],
  int iw[],
  double rw[],
  int *ifail,
  CONST int length_1
#endif
);

extern void e04nsf_(
#ifdef __STDC__
  CONST char string[],
  char cw[],
  int iw[],
  double rw[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04ntf_(
#ifdef __STDC__
  CONST char string[],
  CONST int *ivalue,
  char cw[],
  int iw[],
  double rw[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04nuf_(
#ifdef __STDC__
  CONST char string[],
  CONST double *rvalue,
  char cw[],
  int iw[],
  double rw[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04nxf_(
#ifdef __STDC__
  CONST char string[],
  int *ivalue,
  char cw[],
  int iw[],
  double rw[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04nyf_(
#ifdef __STDC__
  CONST char string[],
  double *rvalue,
  char cw[],
  int iw[],
  double rw[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04ucf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcju,
  CONST i