/* 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__
  Complex (*f)(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 int *ldr,
  double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  void (*confun)(int *, int *, int *, int *, int[], double[], double[], 
                 double[], int *, int[], double[]),
  void (*objfun)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  doubl