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

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

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

   Author: Mike Dewar, University of Bath

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

*/

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern void e04ucf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcju,
  CONST 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 */,
  double clamda[],
  double *objf,
  double gradu[],
  double r[] /* 2 dimension */,
  double x[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04uca(
#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 */,
  double clamda[],
  double *objf,
  double gradu[],
  double r[] /* 2 dimension */,
  double x[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int iuser[],
  double user[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

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

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

extern void e04udm(
#ifdef __STDC__
  int *mode,
  int *ncnln,
  int *n,
  int *nrowj,
  int needc[],
  double x[],
  double c[],
  double cjac[] /* 2 dimension */,
  int *nstate,
  int iuser[],
  double user[]
#endif
);

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

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

extern void e04uff(
#ifdef __STDC__
  int *irevcm,
  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[],
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  double clamda[],
  double *objf,
  double gradu[],
  double r[] /* 2 dimension */,
  double x[],
  int needc[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04ufa(
#ifdef __STDC__
  int *irevcm,
  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[],
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  double clamda[],
  double *objf,
  double gradu[],
  double r[] /* 2 dimension */,
  double x[],
  int needc[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  char cwsav[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1
#endif
);

extern void e04ugf(
#ifdef __STDC__
  void (*confun)(int *, int *, int *, int *, double[], double[], double[], 
                 int *, int[], double[]),
  void (*objfun)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  CONST int *n,
  CONST int *m,
  CONST int *ncnln,
  CONST int *nonln,
  CONST int *njnln,
  CONST int *iobj,
  CONST int *nnz,
  double a[],
  CONST int ha[],
  CONST int ka[],
  double bl[],
  double bu[],
  CONST char start[],
  CONST int *nname,
  CONST char names[],
  int *ns,
  double xs[],
  int istate[],
  double clamda[],
  int *miniz,
  int *minz,
  int *ninf,
  double *sinf,
  double *obj,
  int iz[],
  CONST int *leniz,
  double z[],
  CONST int *lenz,
  int iuser[],
  double user[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04uga(
#ifdef __STDC__
  void (*confun)(int *, int *, int *, int *, double[], double[], double[], 
                 int *, int[], double[]),
  void (*objfun)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  CONST int *n,
  CONST int *m,
  CONST int *ncnln,
  CONST int *nonln,
  CONST int *njnln,
  CONST int *iobj,
  CONST int *nnz,
  double a[],
  CONST int ha[],
  CONST int ka[],
  double bl[],
  double bu[],
  CONST char start[],
  CONST int *nname,
  CONST char names[],
  int *ns,
  double xs[],
  int istate[],
  double clamda[],
  int *miniz,
  int *minz,
  int *ninf,
  double *sinf,
  double *obj,
  int iz[],
  CONST int *leniz,
  double z[],
  CONST int *lenz,
  int iuser[],
  double user[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04ugm(
#ifdef __STDC__
  int *mode,
  int *ncnln,
  int *njnln,
  int *nnzjac,
  double x[],
  double f[],
  double fjac[],
  int *nstate,
  int iuser[],
  double user[]
#endif
);

extern void e04ugn(
#ifdef __STDC__
  int *mode,
  int *nonln,
  double x[],
  double *objf,
  double objgrd[],
  int *nstate,
  int iuser[],
  double user[]
#endif
);

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

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

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

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

extern void e04unf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcju,
  CONST int *ldfju,
  CONST int *ldr,
  double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double y[],
  void (*confun)(int *, int *, int *, int *, int[], double[], double[], 
                 double[], int *, int[], double[]),
  void (*objfun)(int *, int *, int *, int *, double[], double[], double[], 
                 int *, int[], double[]),
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  double f[],
  double fjacu[] /* 2 dimension */,
  double clamda[],
  double *objf,
  double r[] /* 2 dimension */,
  double x[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04upf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcju,
  CONST int *ldfju,
  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 *, int *, int *, double[], double[], double[], 
                 int *, int[], double[]),
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  double f[],
  double fjacu[] /* 2 dimension */,
  double clamda[],
  double *objf,
  double r[] /* 2 dimension */,
  double x[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

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

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

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

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

extern void e04usf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcju,
  CONST int *ldfju,
  CONST int *ldr,
  double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double y[],
  void (*confun)(int *, int *, int *, int *, int[], double[], double[], 
                 double[], int *, int[], double[]),
  void (*objfun)(int *, int *, int *, int *, int *, double[], double[], 
                 double[], int *, int[], double[]),
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  double f[],
  double fjacu[] /* 2 dimension */,
  double clamda[],
  double *objf,
  double r[] /* 2 dimension */,
  double x[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int iuser[],
  double user[],
  int *ifail
#endif
);

extern void e04usa(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcju,
  CONST int *ldfju,
  CONST int *ldr,
  double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double y[],
  void (*confun)(int *, int *, int *, int *, int[], double[], double[], 
                 double[], int *, int[], double[]),
  void (*objfun)(int *, int *, int *, int *, int *, double[], double[], 
                 double[], int *, int[], double[]),
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  double f[],
  double fjacu[] /* 2 dimension */,
  double clamda[],
  double *objf,
  double r[] /* 2 dimension */,
  double x[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int iuser[],
  double user[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

extern void e04vcf(
#ifdef __STDC__
  CONST int *itmax,
  CONST int *msglvl,
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *nctotl,
  CONST int *nrowa,
  CONST int *nrowj,
  CONST int *nrowr,
  CONST double *bigbnd,
  CONST double *epsaf,
  CONST double *eta,
  CONST double *ftol,
  double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  CONST double featol[],
  void (*confun)(int *, int *, int *, int *, double[], double[], double[], 
                 int *),
  void (*objfun)(int *, int *, double[], double *, double[], int *),
  CONST int *cold,
  CONST int *fealin,
  CONST int *orthog,
  double x[],
  int istate[],
  double r[] /* 2 dimension */,
  int *iter,
  double c[],
  double cjac[] /* 2 dimension */,
  CONST double *objf,
  double objgrd[],
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04vdf(
#ifdef __STDC__
  CONST int *itmax,
  CONST int *msglvl,
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *nctotl,
  CONST int *nrowa,
  CONST int *nrowj,
  CONST double *ctol,
  CONST double *ftol,
  double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  void (*confun)(int *, int *, int *, int *, double[], double[], double[], 
                 int *),
  void (*objfun)(int *, int *, double[], double *, double[], int *),
  double x[],
  int istate[],
  double c[],
  double cjac[] /* 2 dimension */,
  CONST double *objf,
  double objgrd[],
  double clamda[],
  int iw[],
  CONST int *leniw,
  double w[],
  CONST int *lenw,
  int *ifail
#endif
);

extern void e04vdm(
#ifdef __STDC__
  int *mode,
  int *ncnln,
  int *n,
  int *nrowj,
  double x[],
  double c[],
  double cjac[] /* 2 dimension */,
  int *nstate
#endif
);

extern void e54vdm(
#ifdef __STDC__
  int *mode,
  int *ncnln,
  int *n,
  int *nrowj,
  double x[],
  double c[],
  double cjac[] /* 2 dimension */,
  int *nstate,
  int iuser[],
  double ruser[]
#endif
);

extern void e04vgf(
#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 e04vhf(
#ifdef __STDC__
  CONST int *start,
  CONST int *nf,
  CONST int *n,
  CONST int *nxname,
  CONST int *nfname,
  CONST double *objadd,
  CONST int *objrow,
  CONST char prob[],
  void (*usrfun)(int *, int *, double[], int *, int *, double[], int *, int *, 
                 double[], char[], int[], double[],int length_1),
  CONST int iafun[],
  CONST int javar[],
  CONST double a[],
  CONST int *lena,
  CONST int *nea,
  CONST int igfun[],
  CONST int jgvar[],
  CONST int *leng,
  CONST int *neg,
  CONST double xlow[],
  CONST double xupp[],
  CONST char xnames[],
  CONST double flow[],
  CONST double fupp[],
  CONST char fnames[],
  double x[],
  int xstate[],
  double xmul[],
  double f[],
  int fstate[],
  double fmul[],
  int *ns,
  int *ninf,
  double *sinf,
  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 e04vjf(
#ifdef __STDC__
  CONST int *nf,
  CONST int *n,
  void (*usrfun)(int *, int *, double[], int *, int *, double[], int *, int *, 
                 double[], char[], int[], double[],int length_1),
  int iafun[],
  int javar[],
  double a[],
  CONST int *lena,
  int *nea,
  int igfun[],
  int jgvar[],
  CONST int *leng,
  int *neg,
  CONST double x[],
  CONST double xlow[],
  CONST double xupp[],
  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
#endif
);

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

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

extern void e04vmf(
#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 e04vnf(
#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 e04vrf(
#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 e04vsf(
#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 e04wbf(
#ifdef __STDC__
  CONST char rname[],
  CONST char cwsav[],
  CONST int *lcwsav,
  int lwsav[],
  CONST int *llwsav,
  CONST int iwsav[],
  CONST int *liwsav,
  CONST double rwsav[],
  CONST int *lrwsav,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void e04wcf(
#ifdef __STDC__
  int iw[],
  CONST int *leniw,
  double rw[],
  CONST int *lenrw,
  int *ifail
#endif
);

extern void e04wdf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcj,
  CONST int *ldh,
  CONST 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 *majits,
  int istate[],
  double ccon[],
  double cjac[] /* 2 dimension */,
  double clamda[],
  double *objf,
  double grad[],
  double hess[] /* 2 dimension */,
  double x[],
  int iw[],
  CONST int *leniw,
  double rw[],
  CONST int *lenrw,
  int iuser[],
  double ruser[],
  int *ifail
#endif
);

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

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

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

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

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

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

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

extern void e04xaf(
#ifdef __STDC__
  CONST int *msglvl,
  CONST int *n,
  CONST double *epsrf,
  double x[],
  CONST int *mode,
  void (*objfun)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  CONST int *lhes,
  double hforw[],
  CONST double *fx,
  double grad[],
  double hcntrl[],
  double hesian[] /* 2 dimension */,
  int *iwarn,
  double work[],
  int iuser[],
  double user[],
  int info[],
  int *ifail
#endif
);

extern void e04xaa(
#ifdef __STDC__
  CONST int *msglvl,
  CONST int *n,
  CONST double *epsrf,
  double x[],
  CONST int *mode,
  void (*objfun)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  CONST int *lhes,
  double hforw[],
  CONST double *fx,
  double grad[],
  double hcntrl[],
  double hesian[] /* 2 dimension */,
  int *iwarn,
  double work[],
  int iuser[],
  double user[],
  int info[],
  int lwsav[],
  int iwsav[],
  double rwsav[],
  int *ifail
#endif
);

extern void e04yaf(
#ifdef __STDC__
  int *m,
  int *n,
  void (*lsqfun)(int *, int *, int *, double[], double[], double[], int *, 
                 int[], int *, double[], int *),
  double x[],
  double fvec[],
  double fjac[] /* 2 dimension */,
  int *lj,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04ybf(
#ifdef __STDC__
  int *m,
  int *n,
  void (*lsqfun)(int *, int *, int *, double[], double[], double[], int *, 
                 int[], int *, double[], int *),
  void (*lsqhes)(int *, int *, int *, double[], double[], double[], int *, 
                 int[], int *, double[], int *),
  double x[],
  double fvec[],
  double fjac[] /* 2 dimension */,
  int *lj,
  double b[],
  int *lb,
  CONST int iw[],
  CONST int *liw,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04ycf(
#ifdef __STDC__
  CONST int *job,
  CONST int *m,
  CONST int *n,
  CONST double *fsumsq,
  CONST double s[],
  double v[] /* 2 dimension */,
  CONST int *lv,
  double cj[],
  double work[],
  int *ifail
#endif
);

extern void e04zcf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *la,
  void (*con)(int *, int *, int *, int *, double[], double[], double[], int *),
  void (*fun)(int *, int *, double[], double *, double[], int *),
  CONST double c[],
  CONST double a[] /* 2 dimension */,
  CONST double *f,
  CONST double g[],
  CONST double x[],
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void e04zca(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *la,
  void (*con)(int *, int *, int *, int *, double[], double[], double[], int *, 
              int[], double[]),
  void (*fun)(int *, int *, double[], double *, double[], int *, int[], 
              double[]),
  CONST double c[],
  CONST double a[] /* 2 dimension */,
  CONST double *f,
  CONST double g[],
  CONST double x[],
  double w[],
  CONST int *lw,
  int iuser[],
  double ruser[],
  int *ifail
#endif
);

extern void f01aaf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double p[],
  int *ifail
#endif
);

extern void f01abf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double z[],
  int *ifail
#endif
);

extern void f01acf(
#ifdef __STDC__
  CONST int *n,
  CONST double *eps,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double z[],
  int *l,
  int *ifail
#endif
);

extern void f01adf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *ia,
  int *ifail
#endif
);

extern void f01aef(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double dl[],
  int *ifail
#endif
);

extern void f01aff(
#ifdef __STDC__
  CONST int *n,
  CONST int *im1,
  CONST int *im2,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double dl[],
  double z[] /* 2 dimension */,
  CONST int *iz
#endif
);

extern void f01agf(
#ifdef __STDC__
  CONST int *n,
  CONST double *atol,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double d[],
  double e[],
  double e2[]
#endif
);

extern void f01ahf(
#ifdef __STDC__
  CONST int *n,
  CONST int *im1,
  CONST int *im2,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double e[],
  double z[] /* 2 dimension */,
  CONST int *iz
#endif
);

extern void f01ajf(
#ifdef __STDC__
  CONST int *n,
  CONST double *atol,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *iz
#endif
);

extern void f01akf(
#ifdef __STDC__
  CONST int *n,
  CONST int *k,
  CONST int *l,
  double a[] /* 2 dimension */,
  CONST int *ia,
  int intger[]
#endif
);

extern void f01alf(
#ifdef __STDC__
  CONST int *kl,
  CONST int *l,
  CONST int *ir,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int intger[],
  double z[] /* 2 dimension */,
  CONST int *iz,
  CONST int *n
#endif
);

extern void f01amf(
#ifdef __STDC__
  CONST int *n,
  CONST int *k,
  CONST int *l,
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  int intger[]
#endif
);

extern void f01anf(
#ifdef __STDC__
  CONST int *kl,
  CONST int *l,
  CONST int *ir,
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  CONST int intger[],
  double zr[] /* 2 dimension */,
  CONST int *izr,
  double zi[] /* 2 dimension */,
  CONST int *izi,
  CONST int *n
#endif
);

extern void f01apf(
#ifdef __STDC__
  CONST int *n,
  CONST int *low,
  CONST int *iupp,
  CONST int intger[],
  CONST double h[] /* 2 dimension */,
  CONST int *ih,
  double v[] /* 2 dimension */,
  CONST int *iv
#endif
);

extern void f01atf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ib,
  double a[] /* 2 dimension */,
  CONST int *ia,
  int *low,
  int *lhi,
  double d[]
#endif
);

extern void f01auf(
#ifdef __STDC__
  CONST int *n,
  CONST int *low,
  CONST int *lhi,
  CONST int *m,
  CONST double d[],
  double z[] /* 2 dimension */,
  CONST int *iz
#endif
);

extern void f01avf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ib,
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  int *low,
  int *lhi,
  double d[]
#endif
);

extern void f01awf(
#ifdef __STDC__
  CONST int *n,
  CONST int *low,
  CONST int *lhi,
  CONST int *m,
  CONST double d[],
  double zr[] /* 2 dimension */,
  CONST int *izr,
  double zi[] /* 2 dimension */,
  CONST int *izi
#endif
);

extern void f01axf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double qr[] /* 2 dimension */,
  CONST int *iqr,
  double alpha[],
  int ipivot[],
  double y[],
  double e[],
  int *ifail
#endif
);

extern void f01ayf(
#ifdef __STDC__
  CONST int *n,
  CONST double *tol,
  double a[],
  CONST int *ia,
  double d[],
  double e[],
  double e2[]
#endif
);

extern void f01azf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m1,
  CONST int *m2,
  CONST double a[],
  CONST int *ia,
  double z[] /* 2 dimension */,
  CONST int *izi
#endif
);

extern void f01bcf(
#ifdef __STDC__
  CONST int *n,
  CONST double *tol,
  double z[] /* 2 dimension */,
  CONST int *iz,
  double w[] /* 2 dimension */,
  CONST int *iw,
  double d[],
  double e[],
  double c[],
  double s[]
#endif
);

extern void f01bdf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double dl[],
  int *ifail
#endif
);

extern void f01bef(
#ifdef __STDC__
  CONST int *n,
  CONST int *im1,
  CONST int *im2,
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST double dl[],
  double z[] /* 2 dimension */,
  CONST int *iz
#endif
);

extern void f01bkf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double *t,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double d[],
  double aijmax[],
  int inc[],
  int *irank,
  int *ifail
#endif
);

extern void f01blf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double *t,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double aijmax[],
  int *irank,
  int inc[],
  double d[],
  double u[] /* 2 dimension */,
  CONST int *iu,
  double du[],
  int *ifail
#endif
);

extern void f01bnf(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *ia,
  double p[],
  int *ifail
#endif
);

extern void f01bpf(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *ia,
  CONST Complex v[],
  int *ifail
#endif
);

extern void f01bqf(
#ifdef __STDC__
  CONST int *n,
  double *eps,
  double rl[],
  CONST int *irl,
  double d[],
  int *ifail
#endif
);

extern void f01brf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nz,
  double a[],
  CONST int *licn,
  int irn[],
  CONST int *lirn,
  int icn[],
  CONST double *u,
  int ikeep[] /* 2 dimension */,
  int iw[] /* 2 dimension */,
  double w[],
  CONST int *lblock,
  CONST int *grow,
  CONST int abort[],
  int idisp[],
  int *ifail
#endif
);

extern void f01bsf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nz,
  double a[],
  CONST int *licn,
  CONST int ivect[],
  CONST int jvect[],
  int icn[],
  CONST int ikeep[] /* 2 dimension */,
  int iw[] /* 2 dimension */,
  double w[],
  CONST int *grow,
  CONST double *eps,
  double *rmin,
  CONST int *abort,
  CONST int idisp[],
  int *ifail
#endif
);

extern void f01btf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double p[],
  double *dp,
  int *ifail
#endif
);

extern void f01buf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m1,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double w[],
  int *ifail
#endif
);

extern void f01bvf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ma1,
  CONST int *mb1,
  CONST int *m3,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double w[],
  int *ifail
#endif
);

extern void f01bwf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m1,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double d[],
  double e[]
#endif
);

extern void f01bxf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double p[],
  int *ifail
#endif
);

extern void f01ckf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  double b[] /* 2 dimension */,
  double c[] /* 2 dimension */,
  CONST int *n,
  CONST int *p,
  CONST int *m,
  double z[],
  CONST int *iz,
  CONST int *opt,
  int *ifail
#endif
);

extern void f01clf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST double b[] /* 2 dimension */,
  CONST double c[] /* 2 dimension */,
  CONST int *n,
  CONST int *p,
  CONST int *m,
  int *ifail
#endif
);

extern void f01crf(
#ifdef __STDC__
  double a[],
  CONST int *m,
  CONST int *n,
  CONST int *mn,
  int move[],
  CONST int *iwrk,
  int *ifail
#endif
);

extern void f01ctf(
#ifdef __STDC__
  CONST char transa[],
  CONST char transb[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *beta,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f01cwf(
#ifdef __STDC__
  CONST char transa[],
  CONST char transb[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex *beta,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f01lbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m1,
  CONST int *m2,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double al[] /* 2 dimension */,
  CONST int *il,
  int in[],
  int *iv,
  int *ifail
#endif
);

extern void f01lef(
#ifdef __STDC__
  CONST int *n,
  double a[],
  CONST double *lambda,
  double b[],
  double c[],
  CONST double *tol,
  double d[],
  int in[],
  int *ifail
#endif
);

extern void f01lhf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nbloks,
  CONST int blkstr[] /* 2 dimension */,
  double a[],
  CONST int *lena,
  int pivot[],
  double *tol,
  int *index,
  int *ifail
#endif
);

extern void f01lzf(
#ifdef __STDC__
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *nra,
  double c[] /* 2 dimension */,
  CONST int *nrc,
  CONST int *wantb,
  double b[],
  CONST int *wantq,
  CONST int *wanty,
  double y[] /* 2 dimension */,
  CONST int *nry,
  CONST int *ly,
  CONST int *wantz,
  double z[] /* 2 dimension */,
  CONST int *nrz,
  CONST int *ncz,
  double d[],
  double e[],
  double work1[],
  double work2[],
  int *ifail
#endif
);

extern void f01maf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nz,
  double a[],
  CONST int *la,
  int ini[],
  CONST int *lini,
  int inj[],
  double *droptl,
  CONST double *densw,
  double w[] /* 2 dimension */,
  int ik[] /* 2 dimension */,
  int iw[] /* 2 dimension */,
  CONST int abort[],
  int inform[],
  int *iflag
#endif
);

extern void f01mcf(
#ifdef __STDC__
  CONST int *n,
  CONST double a[],
  CONST int *lal,
  int nrow[],
  double l[],
  double d[],
  int *ifail
#endif
);

extern void f01naf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ml,
  CONST int *mu,
  Complex a[] /* 2 dimension */,
  CONST int *nra,
  CONST double *tol,
  int in[],
  double scale[],
  int *ifail
#endif
);

extern void f01qaf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *nra,
  double c[] /* 2 dimension */,
  CONST int *nrc,
  double z[],
  int *ifail
#endif
);

extern void f01qbf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *nra,
  double c[] /* 2 dimension */,
  CONST int *nrc,
  double work[],
  int *ifail
#endif
);

extern void f01qcf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double zeta[],
  int *ifail
#endif
);

extern void f01qdf(
#ifdef __STDC__
  CONST char trans[],
  CONST char wheret[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double zeta[],
  CONST int *ncolb,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double work[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f01qef(
#ifdef __STDC__
  CONST char wheret[],
  CONST int *m,
  CONST int *n,
  CONST int *ncolq,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double zeta[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f01qff(
#ifdef __STDC__
  CONST char pivot[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double zeta[],
  int perm[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f01qgf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double zeta[],
  int *ifail
#endif
);

extern void f01qjf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double zeta[],
  int *ifail
#endif
);

extern void f01qkf(
#ifdef __STDC__
  CONST char wheret[],
  CONST int *m,
  CONST int *n,
  CONST int *nrowp,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double zeta[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f01rcf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex theta[],
  int *ifail
#endif
);

extern void f01rdf(
#ifdef __STDC__
  CONST char trans[],
  CONST char wheret[],
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex theta[],
  CONST int *ncolb,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex work[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f01ref(
#ifdef __STDC__
  CONST char wheret[],
  CONST int *m,
  CONST int *n,
  CONST int *ncolq,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex theta[],
  Complex work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f01rff(
#ifdef __STDC__
  CONST char pivot[],
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex theta[],
  int perm[],
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f01rgf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex theta[],
  int *ifail
#endif
);

extern void f01rjf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex theta[],
  int *ifail
#endif
);

extern void f01rkf(
#ifdef __STDC__
  CONST char wheret[],
  CONST int *m,
  CONST int *n,
  CONST int *nrowp,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex theta[],
  Complex work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f01zaf(
#ifdef __STDC__
  CONST char job[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f01zbf(
#ifdef __STDC__
  CONST char job[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f01zcf(
#ifdef __STDC__
  CONST char job[],
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *ifail,
  CONST int length_1
#endif
);

extern void f01zdf(
#ifdef __STDC__
  CONST char job[],
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *ifail,
  CONST int length_1
#endif
);

extern void f02aaf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double r[],
  double e[],
  int *ifail
#endif
);

extern void f02abf(
#ifdef __STDC__
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double r[],
  double v[] /* 2 dimension */,
  CONST int *iv,
  double e[],
  int *ifail
#endif
);

extern void f02adf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *n,
  double r[],
  double de[],
  int *ifail
#endif
);

extern void f02aef(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *n,
  double r[],
  double v[] /* 2 dimension */,
  CONST int *iv,
  double dl[],
  double e[],
  int *ifail
#endif
);

extern void f02aff(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double rr[],
  double ri[],
  int intger[],
  int *lfail
#endif
);

extern void f02agf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double rr[],
  double ri[],
  double vr[] /* 2 dimension */,
  CONST int *ivr,
  double vi[] /* 2 dimension */,
  CONST int *ivi,
  int intger[],
  int *ifail
#endif
);

extern void f02ajf(
#ifdef __STDC__
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  CONST int *n,
  double rr[],
  double ri[],
  int intger[],
  int *lfail
#endif
);

extern void f02akf(
#ifdef __STDC__
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  CONST int *n,
  double wr[],
  double wi[],
  double vr[] /* 2 dimension */,
  CONST int *ivr,
  double vi[] /* 2 dimension */,
  CONST int *ivi,
  int intger[],
  int *ifail
#endif
);

extern void f02amf(
#ifdef __STDC__
  CONST int *n,
  CONST double *eps,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *iz,
  int *ifail
#endif
);

extern void f02anf(
#ifdef __STDC__
  CONST int *nn,
  CONST double *acc,
  double hr[] /* 2 dimension */,
  CONST int *ihr,
  double hi[] /* 2 dimension */,
  CONST int *ihi,
  double wr[],
  double wi[],
  int *lfail
#endif
);

extern void f02apf(
#ifdef __STDC__
  CONST int *nn,
  CONST double *acc,
  double h[] /* 2 dimension */,
  CONST int *ih,
  double wr[],
  double wi[],
  int icnt[],
  int *lfail
#endif
);

extern void f02aqf(
#ifdef __STDC__
  CONST int *n,
  CONST int *low,
  CONST int *upp,
  CONST double *machep,
  double h[] /* 2 dimension */,
  CONST int *ih,
  double vecs[] /* 2 dimension */,
  CONST int *ivecs,
  double wr[],
  double wi[],
  int cnt[],
  int *ifail
#endif
);

extern void f02arf(
#ifdef __STDC__
  CONST int *n,
  CONST int *low,
  CONST int *iupp,
  CONST double *acheps,
  CONST int intger[],
  double hr[] /* 2 dimension */,
  CONST int *ihr,
  double hi[] /* 2 dimension */,
  CONST int *ihi,
  double wr[],
  double wi[],
  double vr[] /* 2 dimension */,
  CONST int *ivr,
  double vi[] /* 2 dimension */,
  CONST int *ivi,
  int *ifail
#endif
);

extern void f02avf(
#ifdef __STDC__
  CONST int *n,
  CONST double *acheps,
  double d[],
  double e[],
  int *ifail
#endif
);

extern void f02awf(
#ifdef __STDC__
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  CONST int *n,
  double wr[],
  double wk1[],
  double wk2[],
  double wk3[],
  int *ifail
#endif
);

extern void f02axf(
#ifdef __STDC__
  CONST double ar[] /* 2 dimension */,
  CONST int *iar,
  CONST double ai[] /* 2 dimension */,
  CONST int *iai,
  CONST int *n,
  double wr[],
  double vr[] /* 2 dimension */,
  CONST int *ivr,
  double vi[] /* 2 dimension */,
  CONST int *ivi,
  double wk1[],
  double wk2[],
  double wk3[],
  int *ifail
#endif
);

extern void f02ayf(
#ifdef __STDC__
  CONST int *n,
  CONST double *eps,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *iz,
  double w[] /* 2 dimension */,
  CONST int *iw,
  int *ifail
#endif
);

extern void f02bbf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  CONST double *alb,
  CONST double *ub,
  CONST int *m,
  int *mm,
  double r[],
  double v[] /* 2 dimension */,
  CONST int *iv,
  double d[],
  double e[],
  double e2[],
  double x[] /* 2 dimension */,
  double g[],
  int c[],
  int icount[],
  int *ifail
#endif
);

extern void f02bcf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  CONST double *rlb,
  CONST double *rub,
  CONST int *m,
  int *mm,
  double rr[],
  double ri[],
  double vr[] /* 2 dimension */,
  CONST int *ivr,
  double vi[] /* 2 dimension */,
  CONST int *ivi,
  int intger[],
  int icnt[],
  int c[],
  double b[] /* 2 dimension */,
  CONST int *ib,
  double u[],
  double v[],
  int *lfail
#endif
);

extern void f02bdf(
#ifdef __STDC__
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  CONST int *n,
  CONST double *rlb,
  CONST double *rub,
  CONST int *m,
  int *mm,
  double rr[],
  double ri[],
  double vr[] /* 2 dimension */,
  CONST int *ivr,
  double vi[] /* 2 dimension */,
  CONST int *ivi,
  int intger[],
  int c[],
  double br[] /* 2 dimension */,
  CONST int *ibr,
  double bi[] /* 2 dimension */,
  CONST int *ibi,
  double u[],
  double v[],
  int *lfail
#endif
);

extern void f02bef(
#ifdef __STDC__
  CONST int *n,
  CONST double c[],
  CONST double *alb,
  CONST double *ub,
  CONST double *acheps,
  CONST double *eps,
  CONST double b[],
  double beta[],
  CONST int *m,
  int *mm,
  double root[],
  double vec[] /* 2 dimension */,
  CONST int *ivec,
  int icount[],
  double x[] /* 2 dimension */,
  int log[],
  int *ifail
#endif
);

extern void f02bff(
#ifdef __STDC__
  CONST double c[],
  double b[],
  double beta[],
  CONST int *n,
  CONST int *m1,
  CONST int *m2,
  CONST int *mm12,
  double *eps1,
  CONST double *relfeh,
  double *eps2,
  int *iz,
  double x[],
  double wu[]
#endif
);

extern void f02bjf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  CONST double *eps1,
  double alfr[],
  double alfi[],
  double beta[],
  CONST int *matz,
  double z[] /* 2 dimension */,
  CONST int *iz,
  int iter[],
  int *ifail
#endif
);

extern void f02bkf(
#ifdef __STDC__
  CONST int *n,
  CONST int *mm,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double wi[],
  CONST int c[],
  double wr[],
  double z[] /* 2 dimension */,
  CONST int *iz,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double u[],
  double v[],
  int *ifail
#endif
);

extern void f02blf(
#ifdef __STDC__
  CONST int *n,
  CONST int *mm,
  CONST double ar[] /* 2 dimension */,
  CONST int *iar,
  CONST double ai[] /* 2 dimension */,
  CONST int *iai,
  CONST double wi[],
  CONST int c[],
  double wr[],
  double zr[] /* 2 dimension */,
  CONST int *izr,
  double zi[] /* 2 dimension */,
  CONST int *izi,
  double br[] /* 2 dimension */,
  CONST int *ibr,
  double bi[] /* 2 dimension */,
  CONST int *ibi,
  double u[],
  double v[],
  int *ifail
#endif
);

extern void f02eaf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double wr[],
  double wi[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f02ebf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double wr[],
  double wi[],
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  double vi[] /* 2 dimension */,
  CONST int *ldvi,
  double work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f02ecf(
#ifdef __STDC__
  CONST char crit[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *wl,
  CONST double *wu,
  CONST int *mest,
  int *m,
  double wr[],
  double wi[],
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  double vi[] /* 2 dimension */,
  CONST int *ldvi,
  double work[],
  CONST int *lwork,
  int iwork[],
  int bwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f02faf(
#ifdef __STDC__
  CONST char job[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  double work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f02fcf(
#ifdef __STDC__
  CONST char job[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *wl,
  CONST double *wu,
  CONST int *il,
  CONST int *iu,
  CONST int *mest,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f02fdf(
#ifdef __STDC__
  CONST int *itype,
  CONST char job[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double w[],
  double work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f02fhf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ma,
  double a[] /* 2 dimension */,
  CONST int *nra,
  CONST int *mb,
  double b[] /* 2 dimension */,
  CONST int *nrb,
  double d[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f02fjf(
#ifdef __STDC__
  CONST int *n,
  int *em,
  CONST int *p,
  int *km,
  CONST double *eps,
  double (*ip)(int *, int *, double[], double[], double[], int *, int[], int *),
  void (*op)(int *, int *, double[], double[], double[], int *, int[], int *),
  void (*inf)(int *, int *, int *, int *, int *, double[], double[]),
  CONST int *novecs,
  double x[] /* 2 dimension */,
  CONST int *mn,
  double d[],
  double work[],
  CONST int *lwork,
  CONST double rwork[],
  CONST int *lrwork,
  CONST int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void f02fjz(
#ifdef __STDC__
  int *istate,
  int *nextit,
  int *nevals,
  int *nevecs,
  int *k,
  double f[],
  double d[]
#endif
);

extern void f02gaf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double rwork[],
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f02gbf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex w[],
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  double rwork[],
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f02gcf(
#ifdef __STDC__
  CONST char crit[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *wl,
  CONST double *wu,
  CONST int *mest,
  int *m,
  Complex w[],
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  int bwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f02gjf(
#ifdef __STDC__
  CONST int *n,
  double ar[] /* 2 dimension */,
  CONST int *iar,
  double ai[] /* 2 dimension */,
  CONST int *iai,
  double br[] /* 2 dimension */,
  CONST int *ibr,
  double bi[] /* 2 dimension */,
  CONST int *ibi,
  CONST double *eps1,
  double alfr[],
  double alfi[],
  double beta[],
  CONST int *matz,
  double zr[] /* 2 dimension */,
  CONST int *izr,
  double zi[] /* 2 dimension */,
  CONST int *izi,
  int iter[],
  int *ifail
#endif
);

extern void f02haf(
#ifdef __STDC__
  CONST char job[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  double rwork[],
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f02hcf(
#ifdef __STDC__
  CONST char job[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *wl,
  CONST double *wu,
  CONST int *il,
  CONST int *iu,
  CONST int *mest,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f02hdf(
#ifdef __STDC__
  CONST int *itype,
  CONST char job[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double w[],
  double rwork[],
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f02sdf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ma1,
  CONST int *mb1,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *sym,
  CONST double *relep,
  CONST double *rmu,
  double vec[],
  double d[],
  int _int[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f02swf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  CONST int *ncoly,
  double y[] /* 2 dimension */,
  CONST int *ldy,
  CONST int *wantq,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  int *ifail
#endif
);

extern void f02sxf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *ncoly,
  double y[] /* 2 dimension */,
  CONST int *ldy,
  double work[],
  int *ifail
#endif
);

extern void f02syf(
#ifdef __STDC__
  CONST int *n,
  double d[],
  double e[],
  CONST int *ncolb,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int *nrowy,
  double y[] /* 2 dimension */,
  CONST int *ldy,
  CONST int *ncolz,
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *ifail
#endif
);

extern void f02szf(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  CONST double e[],
  double sv[],
  CONST int *wantb,
  double b[],
  CONST int *wanty,
  double y[] /* 2 dimension */,
  CONST int *nry,
  CONST int *ly,
  CONST int *wantz,
  double z[] /* 2 dimension */,
  CONST int *nrz,
  CONST int *ncz,
  double work1[],
  double work2[],
  double work3[],
  int *ifail
#endif
);

extern void f02uwf(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  CONST int *ncoly,
  Complex y[] /* 2 dimension */,
  CONST int *ldy,
  CONST int *wantq,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex work[],
  int *ifail
#endif
);

extern void f02uxf(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *ncoly,
  Complex y[] /* 2 dimension */,
  CONST int *ldy,
  double rwork[],
  Complex cwork[],
  int *ifail
#endif
);

extern void f02uyf(
#ifdef __STDC__
  CONST int *n,
  double d[],
  double e[],
  CONST int *ncolb,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int *nrowy,
  Complex y[] /* 2 dimension */,
  CONST int *ldy,
  CONST int *ncolz,
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *ifail
#endif
);

extern void f02waf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *nra,
  CONST int *wantb,
  double b[],
  double sv[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f02wbf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *nra,
  CONST int *wantb,
  double b[],
  double sv[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f02wcf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *minmn,
  CONST double a[] /* 2 dimension */,
  CONST int *nra,
  double q[] /* 2 dimension */,
  CONST int *nrq,
  double sv[],
  double pt[] /* 2 dimension */,
  CONST int *nrpt,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f02wdf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *nra,
  CONST int *wantb,
  double b[],
  CONST double *tol,
  int *svd,
  int *irank,
  double z[],
  double sv[],
  CONST int *wantr,
  double r[] /* 2 dimension */,
  CONST int *nrr,
  CONST int *wantpt,
  double pt[] /* 2 dimension */,
  CONST int *nrpt,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f02wef(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *ncolb,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int *wantq,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double sv[],
  CONST int *wantp,
  double pt[] /* 2 dimension */,
  CONST int *ldpt,
  double work[],
  int *ifail
#endif
);

extern void f02wuf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *ncolb,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int *wantq,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double sv[],
  CONST int *wantp,
  double work[],
  int *ifail
#endif
);

extern void f02xef(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *ncolb,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int *wantq,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  double sv[],
  CONST int *wantp,
  Complex ph[] /* 2 dimension */,
  CONST int *ldph,
  double rwork[],
  Complex cwork[],
  int *ifail
#endif
);

extern void f02xuf(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *ncolb,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int *wantq,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  double sv[],
  CONST int *wantp,
  double rwork[],
  Complex cwork[],
  int *ifail
#endif
);

extern void f03aaf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double *det,
  double wkspce[],
  int *ifail
#endif
);

extern void f03abf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double *det,
  double wkspce[],
  int *ifail
#endif
);

extern void f03acf(
#ifdef __STDC__
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  CONST int *m,
  double *det,
  double rl[] /* 2 dimension */,
  CONST int *il,
  CONST int *m1,
  int *lfail
#endif
);

extern void f03adf(
#ifdef __STDC__
  Complex a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  double *detr,
  double *deti,
  double wkspce[],
  int *ifail
#endif
);

extern void f03aef(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double p[],
  double *d1,
  int *id,
  int *ifail
#endif
);

extern void f03aff(
#ifdef __STDC__
  CONST int *n,
  CONST double *eps,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double *d1,
  int *id,
  double p[],
  int *ifail
#endif
);

extern void f03agf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  double rl[] /* 2 dimension */,
  CONST int *il,
  CONST int *mm,
  double *d1,
  int *id,
  int *lfail
#endif
);

extern void f03ahf(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *ia,
  double *detr,
  double *deti,
  int *id,
  double rint[],
  int *ifail
#endif
);

extern void f03amf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ten,
  CONST double p[],
  double *detm,
  int *idete
#endif
);

extern void f04aaf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *n,
  CONST int *m,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double wkspce[],
  int *ifail
#endif
);

extern void f04abf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *n,
  CONST int *m,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double wkspce[],
  double bb[] /* 2 dimension */,
  CONST int *ibb,
  int *ifail
#endif
);

extern void f04acf(
#ifdef __STDC__
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *n,
  CONST int *m,
  CONST int *lr,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double rl[] /* 2 dimension */,
  CONST int *il,
  CONST int *m1,
  int *lfail
#endif
);

extern void f04adf(
#ifdef __STDC__
  Complex a[] /* 2 dimension */,
  CONST int *ia,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *n,
  CONST int *m,
  Complex c[] /* 2 dimension */,
  CONST int *ic,
  double wkspce[],
  int *ifail
#endif
);

extern void f04aef(
#ifdef __STDC__
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *n,
  CONST int *m,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double wkspce[],
  double aa[] /* 2 dimension */,
  CONST int *iaa,
  double bb[] /* 2 dimension */,
  CONST int *ibb,
  int *ifail
#endif
);

extern void f04aff(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double p[],
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST double *eps,
  double x[] /* 2 dimension */,
  CONST int *ix,
  double bb[] /* 2 dimension */,
  CONST int *ibb,
  int *l,
  int *ifail
#endif
);

extern void f04agf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  double a[] /* 2 dimension */,
  CONST int *ia,
  double p[],
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  double x[] /* 2 dimension */,
  CONST int *ix
#endif
);

extern void f04ahf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double aa[] /* 2 dimension */,
  CONST int *iaa,
  CONST double p[],
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST double *eps,
  double x[] /* 2 dimension */,
  CONST int *ix,
  double bb[] /* 2 dimension */,
  CONST int *ibb,
  int *l,
  int *ifail
#endif
);

extern void f04ajf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double p[],
  double b[] /* 2 dimension */,
  CONST int *ib
#endif
);

extern void f04akf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  CONST Complex a[] /* 2 dimension */,
  CONST int *ia,
  CONST double rint[],
  Complex b[] /* 2 dimension */,
  CONST int *ib
#endif
);

extern void f04alf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *ir,
  CONST double rl[] /* 2 dimension */,
  CONST int *il,
  CONST int *m1,
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  double x[] /* 2 dimension */,
  CONST int *ix
#endif
);

extern void f04amf(
#ifdef __STDC__
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  double x[] /* 2 dimension */,
  CONST int *ix,
  CONST double b[] /* 2 dimension */,
  CONST int *ib,
  CONST int *m,
  CONST int *n,
  CONST int *ip,
  CONST double *eta,
  double qr[] /* 2 dimension */,
  CONST int *iqr,
  double alpha[],
  double e[],
  double y[],
  double z[],
  double r[],
  int ipivot[],
  int *ifail
#endif
);

extern void f04anf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double qr[] /* 2 dimension */,
  CONST int *iqr,
  double alpha[],
  CONST int ipivot[],
  double r[],
  double y[],
  double z[]
#endif
);

extern void f04aqf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double rl[],
  CONST double d[],
  CONST double b[],
  double x[]
#endif
);

extern void f04arf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double b[],
  CONST int *n,
  double c[],
  double wks[],
  int *ifail
#endif
);

extern void f04asf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double b[],
  CONST int *n,
  double c[],
  double wk1[],
  double wk2[],
  int *ifail
#endif
);

extern void f04atf(
#ifdef __STDC__
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double b[],
  CONST int *n,
  double c[],
  double aa[] /* 2 dimension */,
  CONST int *iaa,
  double wks1[],
  double wks2[],
  int *ifail
#endif
);

extern void f04auf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *ip,
  CONST double d[],
  CONST int inc[],
  CONST int *ir,
  double b[] /* 2 dimension */,
  CONST int *ib,
  double x[] /* 2 dimension */,
  CONST int *ix,
  double u[] /* 2 dimension */,
  CONST int *iu,
  double du[],
  int *ifail
#endif
);

extern void f04awf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  Complex a[] /* 2 dimension */,
  CONST int *ia,
  double p[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ib,
  Complex x[] /* 2 dimension */,
  CONST int *ix
#endif
);

extern void f04axf(
#ifdef __STDC__
  CONST int *n,
  CONST double a[],
  CONST int *licn,
  CONST int icn[],
  int ikeep[] /* 2 dimension */,
  double rhs[],
  double w[],
  CONST int *mtype,
  CONST int idisp[],
  double *resid
#endif
);

extern void f04ayf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double p[],
  double b[] /* 2 dimension */,
  CONST int *ib,
  int *ifail
#endif
);

extern void f04azf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ir,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double p[],
  double b[] /* 2 dimension */,
  CONST int *ib,
  int *ifail
#endif
);

extern void f04baf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04bbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04bcf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double dl[],
  double d[],
  double du[],
  double du2[],
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04bdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04bef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double ap[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04bff(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04bgf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double d[],
  double e[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04bhf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04bjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double ap[],
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04caf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04cbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04ccf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  Complex dl[],
  Complex d[],
  Complex du[],
  Complex du2[],
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04cdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04cef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex ap[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04cff(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04cgf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double d[],
  Complex e[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail
#endif
);

extern void f04chf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04cjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex ap[],
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04dhf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04djf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex ap[],
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double *rcond,
  double *errbnd,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04eaf(
#ifdef __STDC__
  CONST int *n,
  double d[],
  double du[],
  double dl[],
  double b[],
  int *ifail
#endif
);

extern void f04faf(
#ifdef __STDC__
  CONST int *job,
  CONST int *n,
  double d[],
  double e[],
  double b[],
  int *ifail
#endif
);

extern void f04fef(
#ifdef __STDC__
  CONST int *n,
  CONST double t[],
  double x[],
  CONST int *wantp,
  double p[],
  CONST int *wantv,
  double v[],
  double *vlast,
  double work[],
  int *ifail
#endif
);

extern void f04fff(
#ifdef __STDC__
  CONST int *n,
  CONST double t[],
  CONST double b[],
  double x[],
  CONST int *wantp,
  double p[],
  double work[],
  int *ifail
#endif
);

extern void f04jaf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *nra,
  double b[],
  CONST double *tol,
  double *sigma,
  int *irank,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f04jdf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *nra,
  double b[],
  CONST double *tol,
  double *sigma,
  int *irank,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f04jgf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *nra,
  double b[],
  CONST double *tol,
  int *svd,
  double *sigma,
  int *irank,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f04jlf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *p,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double d[],
  double x[],
  double y[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f04jmf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *p,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double c[],
  double d[],
  double x[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f04klf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *p,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex d[],
  Complex x[],
  Complex y[],
  Complex work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f04kmf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *p,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex c[],
  Complex d[],
  Complex x[],
  Complex work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f04ldf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m1,
  CONST int *m2,
  CONST int *ir,
  CONST double a[] /* 2 dimension */,
  CONST int *ia,
  CONST double al[] /* 2 dimension */,
  CONST int *il,
  CONST int in[],
  double b[] /* 2 dimension */,
  CONST int *ib,
  int *ifail
#endif
);

extern void f04lef(
#ifdef __STDC__
  CONST int *job,
  CONST int *n,
  CONST double a[],
  CONST double b[],
  CONST double c[],
  CONST double d[],
  CONST int in[],
  double y[],
  double *tol,
  int *ifail
#endif
);

extern void f04lhf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nbloks,
  CONST int blkstr[] /* 2 dimension */,
  CONST double a[],
  CONST int *lena,
  CONST int pivot[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int *ir,
  int *ifail,
  CONST int length_1
#endif
);

extern void f04maf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nz,
  CONST double a[],
  CONST int *la,
  CONST int ini[],
  CONST int *lini,
  CONST int inj[],
  double b[],
  double eps[],
  int kmax[],
  double w[] /* 2 dimension */,
  double w1[] /* 2 dimension */,
  CONST int ik[] /* 2 dimension */,
  CONST int inform[],
  int *iflag
#endif
);

extern void f04mbf(
#ifdef __STDC__
  CONST int *n,
  CONST double b[],
  double x[],
  void (*aprod)(int *, int *, double[], double[], double[], int *, int[], 
                int *),
  void (*msolve)(int *, int *, double[], double[], double[], int *, int[], 
                 int *),
  CONST int *precon,
  CONST double *shift,
  CONST double *rtol,
  CONST int *itnlim,
  CONST int *msglvl,
  int *itn,
  double *anorm,
  double *acond,
  double *rnorm,
  double *xnorm,
  double work[] /* 2 dimension */,
  CONST double rwork[],
  CONST int *lrwork,
  CONST int iwork[],
  CONST int *liwork,
  int *inform,
  int *ifail
#endif
);

extern void f04mcf(
#ifdef __STDC__
  CONST int *n,
  CONST double l[],
  CONST int *ll,
  CONST double d[],
  CONST int nrow[],
  CONST int *p,
  CONST double b[] /* 2 dimension */,
  CONST int *nrb,
  CONST int *iselct,
  double x[] /* 2 dimension */,
  CONST int *nrx,
  int *ifail
#endif
);

extern void f04mef(
#ifdef __STDC__
  CONST int *n,
  CONST double t[],
  double x[],
  double *v,
  double work[],
  int *ifail
#endif
);

extern void f04mff(
#ifdef __STDC__
  CONST int *n,
  CONST double t[],
  CONST double b[],
  double x[],
  double *p,
  double work[],
  int *ifail
#endif
);

extern void f04naf(
#ifdef __STDC__
  CONST int *job,
  CONST int *n,
  CONST int *ml,
  CONST int *mu,
  CONST Complex a[] /* 2 dimension */,
  CONST int *nra,
  CONST int in[],
  Complex b[],
  double *tol,
  int *ifail
#endif
);

extern void f04qaf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double b[],
  double x[],
  double se[],
  void (*aprod)(int *, int *, int *, double[], double[], double[], int *, 
                int[], int *),
  CONST double *damp,
  CONST double *atol,
  CONST double *btol,
  CONST double *conlim,
  int *itnlim,
  CONST int *msglvl,
  int *itn,
  double *anorm,
  double *acond,
  double *rnorm,
  double *arnorm,
  double *xnorm,
  double work[] /* 2 dimension */,
  CONST double rwork[],
  CONST int *lrwork,
  CONST int iwork[],
  CONST int *liwork,
  int *inform,
  int *ifail
#endif
);

extern void f04yaf(
#ifdef __STDC__
  CONST int *job,
  CONST int *p,
  CONST double *sigma,
  double a[] /* 2 dimension */,
  CONST int *nra,
  CONST int *svd,
  CONST int *irank,
  CONST double sv[],
  double cj[],
  double work[],
  int *ifail
#endif
);

extern void f04ycf(
#ifdef __STDC__
  int *icase,
  CONST int *n,
  double x[],
  double *estnrm,
  double work[],
  int iwork[],
  int *ifail
#endif
);

extern void f04zcf(
#ifdef __STDC__
  int *icase,
  CONST int *n,
  Complex x[],
  double *estnrm,
  Complex work[],
  int *ifail
#endif
);

extern void f05aaf(
#ifdef __STDC__
  double a[] /* 2 dimension */,
  CONST int *ia,
  CONST int *m,
  CONST int *n1,
  CONST int *n2,
  double s[],
  double *cc,
  int *icol,
  int *ifail
#endif
);

extern void f06aaf(
#ifdef __STDC__
  double *a,
  double *b,
  double *c,
  double *s
#endif
);

extern void f06baf(
#ifdef __STDC__
  double *a,
  double *b,
  double *c,
  double *s
#endif
);

extern void f06bcf(
#ifdef __STDC__
  CONST double *t,
  double *c,
  double *s
#endif
);

extern void f06bef(
#ifdef __STDC__
  CONST char job[],
  double *x,
  double *y,
  double *z,
  double *c,
  double *s,
  CONST int length_1
#endif
);

extern void f06bhf(
#ifdef __STDC__
  double *x,
  double *y,
  double *z,
  CONST double *c,
  CONST double *s
#endif
);

extern double f06blf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  int *fail
#endif
);

extern double f06bmf(
#ifdef __STDC__
  CONST double *scale,
  CONST double *ssq
#endif
);

extern double f06bnf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b
#endif
);

extern double f06bpf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST double *c
#endif
);

extern void f06caf(
#ifdef __STDC__
  Complex *a,
  Complex *b,
  double *c,
  Complex *s
#endif
);

extern void f06cbf(
#ifdef __STDC__
  Complex *a,
  Complex *b,
  Complex *c,
  double *s
#endif
);

extern void f06ccf(
#ifdef __STDC__
  CONST Complex *t,
  double *c,
  Complex *s
#endif
);

extern void f06cdf(
#ifdef __STDC__
  Complex *t,
  Complex *c,
  double *s
#endif
);

extern void f06chf(
#ifdef __STDC__
  Complex *x,
  Complex *y,
  Complex *z,
  CONST double *c,
  CONST Complex *s
#endif
);

extern void f06clf(
#ifdef __STDC__
  Complex *f06clf,
  CONST Complex *a,
  CONST Complex *b,
  int *fail
#endif
);

extern void f06dbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *_const,
  int x[],
  CONST int *incx
#endif
);

extern void f06dff(
#ifdef __STDC__
  CONST int *n,
  CONST int x[],
  CONST int *incx,
  int y[],
  CONST int *incy
#endif
);

extern double f06eaf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy
#endif
);

extern void f06ecf(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  double y[],
  CONST int *incy
#endif
);

extern void f06edf(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  double x[],
  CONST int *incx
#endif
);

extern void f06eff(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  double y[],
  CONST int *incy
#endif
);

extern void f06egf(
#ifdef __STDC__
  CONST int *n,
  double x[],
  CONST int *incx,
  double y[],
  CONST int *incy
#endif
);

extern double f06ejf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx
#endif
);

extern double f06ekf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx
#endif
);

extern void f06epf(
#ifdef __STDC__
  CONST int *n,
  double x[],
  CONST int *incx,
  double y[],
  CONST int *incy,
  CONST double *c,
  CONST double *s
#endif
);

extern double f06erf(
#ifdef __STDC__
  CONST int *nz,
  CONST double x[],
  CONST int indx[],
  CONST double y[]
#endif
);

extern void f06etf(
#ifdef __STDC__
  CONST int *nz,
  CONST double *a,
  CONST double x[],
  CONST int indx[],
  double y[]
#endif
);

extern void f06euf(
#ifdef __STDC__
  CONST int *nz,
  CONST double y[],
  double x[],
  CONST int indx[]
#endif
);

extern void f06evf(
#ifdef __STDC__
  CONST int *nz,
  double y[],
  double x[],
  CONST int indx[]
#endif
);

extern void f06ewf(
#ifdef __STDC__
  CONST int *nz,
  CONST double x[],
  CONST int indx[],
  double y[]
#endif
);

extern void f06exf(
#ifdef __STDC__
  CONST int *nz,
  double x[],
  CONST int indx[],
  double y[],
  CONST double *c,
  CONST double *s
#endif
);

extern double f06faf(
#ifdef __STDC__
  CONST int *n,
  CONST int *j,
  CONST double *tolx,
  CONST double x[],
  CONST int *incx,
  CONST double *toly,
  CONST double y[],
  CONST int *incy
#endif
);

extern void f06fbf(
#ifdef __STDC__
  CONST int *n,
  CONST double *_const,
  double x[],
  CONST int *incx
#endif
);

extern void f06fcf(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  CONST int *incd,
  double x[],
  CONST int *incx
#endif
);

extern void f06fdf(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  double y[],
  CONST int *incy
#endif
);

extern void f06fef(
#ifdef __STDC__
  CONST int *n,
  CONST double *sa,
  double sx[],
  CONST int *incx
#endif
);

extern void f06fgf(
#ifdef __STDC__
  CONST int *n,
  double x[],
  CONST int *incx
#endif
);

extern void f06fjf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  double *scale,
  double *sumsq
#endif
);

extern double f06fkf(
#ifdef __STDC__
  CONST int *n,
  CONST double w[],
  CONST int *incw,
  CONST double x[],
  CONST int *incx
#endif
);

extern void f06flf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  double *xmax,
  double *xmin
#endif
);

extern void f06fpf(
#ifdef __STDC__
  CONST int *n,
  double x[],
  CONST int *incx,
  double y[],
  CONST int *incy,
  CONST double *c,
  CONST double *s
#endif
);

extern void f06fqf(
#ifdef __STDC__
  CONST char pivot[],
  CONST char direct[],
  CONST int *n,
  double *alpha,
  double x[],
  CONST int *incx,
  double c[],
  double s[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06frf(
#ifdef __STDC__
  CONST int *n,
  double *alpha,
  double x[],
  CONST int *incx,
  CONST double *tol,
  double *zeta
#endif
);

extern void f06fsf(
#ifdef __STDC__
  CONST int *n,
  double *alpha,
  double x[],
  CONST int *incx,
  CONST double *tol,
  double *z1
#endif
);

extern void f06ftf(
#ifdef __STDC__
  CONST int *n,
  double *delta,
  double y[],
  CONST int *incy,
  CONST double *zeta,
  CONST double z[],
  CONST int *incz
#endif
);

extern void f06fuf(
#ifdef __STDC__
  CONST int *n,
  CONST double z[],
  CONST int *incz,
  CONST double *z1,
  double *alpha,
  double x[],
  CONST int *incx
#endif
);

extern void f06gaf(
#ifdef __STDC__
  Complex *f06gaf,
  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy
#endif
);

extern void f06gbf(
#ifdef __STDC__
  Complex *f06gbf,
  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy
#endif
);

extern void f06gcf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void f06gdf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *alpha,
  Complex x[],
  CONST int *incx
#endif
);

extern void f06gff(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void f06ggf(
#ifdef __STDC__
  CONST int *n,
  Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void f06grf(
#ifdef __STDC__
  Complex *f06grf,
  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  CONST Complex y[]
#endif
);

extern void f06gsf(
#ifdef __STDC__
  Complex *f06gsf,
  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  CONST Complex y[]
#endif
);

extern void f06gtf(
#ifdef __STDC__
  CONST int *nz,
  CONST Complex *a,
  CONST Complex x[],
  CONST int indx[],
  Complex y[]
#endif
);

extern void f06guf(
#ifdef __STDC__
  CONST int *nz,
  CONST Complex y[],
  Complex x[],
  CONST int indx[]
#endif
);

extern void f06gvf(
#ifdef __STDC__
  CONST int *nz,
  Complex y[],
  Complex x[],
  CONST int indx[]
#endif
);

extern void f06gwf(
#ifdef __STDC__
  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  Complex y[]
#endif
);

extern void f06hbf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *_const,
  Complex x[],
  CONST int *incx
#endif
);

extern void f06hcf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex d[],
  CONST int *incd,
  Complex x[],
  CONST int *incx
#endif
);

extern void f06hdf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void f06hgf(
#ifdef __STDC__
  CONST int *n,
  Complex x[],
  CONST int *incx
#endif
);

extern void f06hpf(
#ifdef __STDC__
  CONST int *n,
  Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy,
  CONST Complex *c,
  CONST Complex *s
#endif
);

extern void f06hqf(
#ifdef __STDC__
  CONST char pivot[],
  CONST char direct[],
  CONST int *n,
  Complex *alpha,
  Complex x[],
  CONST int *incx,
  double c[],
  Complex s[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zdotu(
#ifdef __STDC__
  Complex *zdotu,
  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy
#endif
);

extern void zdotc(
#ifdef __STDC__
  Complex *zdotc,
  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy
#endif
);

extern void zaxpy(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void zscal(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *alpha,
  Complex x[],
  CONST int *incx
#endif
);

extern void zcopy(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void zswap(
#ifdef __STDC__
  CONST int *n,
  Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void zdotui(
#ifdef __STDC__
  Complex *zdotui,
  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  CONST Complex y[]
#endif
);

extern void zdotci(
#ifdef __STDC__
  Complex *zdotci,
  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  CONST Complex y[]
#endif
);

extern void zaxpyi(
#ifdef __STDC__
  CONST int *nz,
  CONST Complex *a,
  CONST Complex x[],
  CONST int indx[],
  Complex y[]
#endif
);

extern void zgthr(
#ifdef __STDC__
  CONST int *nz,
  CONST Complex y[],
  Complex x[],
  CONST int indx[]
#endif
);

extern void zgthrz(
#ifdef __STDC__
  CONST int *nz,
  Complex y[],
  Complex x[],
  CONST int indx[]
#endif
);

extern void zsctr(
#ifdef __STDC__
  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  Complex y[]
#endif
);

extern void f06hrf(
#ifdef __STDC__
  CONST int *n,
  Complex *alpha,
  Complex x[],
  CONST int *incx,
  CONST double *tol,
  Complex *theta
#endif
);

extern void f06htf(
#ifdef __STDC__
  CONST int *n,
  Complex *delta,
  Complex y[],
  CONST int *incy,
  CONST Complex *theta,
  CONST Complex z[],
  CONST int *incz
#endif
);

extern void f06jdf(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  Complex x[],
  CONST int *incx
#endif
);

extern double f06jjf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx
#endif
);

extern double f06jkf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx
#endif
);

extern int f06jlf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx
#endif
);

extern int f06jmf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx
#endif
);

extern void f06kcf(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  CONST int *incd,
  Complex x[],
  CONST int *incx
#endif
);

extern void f06kdf(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void f06kef(
#ifdef __STDC__
  CONST int *n,
  CONST double *sa,
  Complex sx[],
  CONST int *incx
#endif
);

extern void f06kff(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy
#endif
);

extern void f06kjf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  double *scale,
  double *sumsq
#endif
);

extern int f06klf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  CONST double *tol
#endif
);

extern void f06kpf(
#ifdef __STDC__
  CONST int *n,
  Complex x[],
  CONST int *incx,
  Complex y[],
  CONST int *incy,
  CONST double *c,
  CONST double *s
#endif
);

extern void f06paf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06pbf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06pcf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06pdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06pef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double ap[],
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06pff(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06pgf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06phf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double ap[],
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06pjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06pkf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06plf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double ap[],
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06pmf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy,
  double a[] /* 2 dimension */,
  CONST int *lda
#endif
);

extern void f06ppf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06pqf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  double ap[],
  CONST int length_1
#endif
);

extern void f06prf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06psf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy,
  double ap[],
  CONST int length_1
#endif
);

extern void f06qff(
#ifdef __STDC__
  CONST char matrix[],
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1
#endif
);

extern void zdscal(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  Complex x[],
  CONST int *incx
#endif
);

extern double dznrm2(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx
#endif
);

extern double dzasum(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx
#endif
);

extern int idamax(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx
#endif
);

extern int izamax(
#ifdef __STDC__
  CONST int *n,
  CONST Complex x[],
  CONST int *incx
#endif
);

extern void dgemv(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void dgbmv(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void dsymv(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void dsbmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void dspmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double ap[],
  CONST double x[],
  CONST int *incx,
  CONST double *beta,
  double y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void dtrmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtbmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtpmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double ap[],
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtrsv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtbsv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtpsv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST double ap[],
  double x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dger(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy,
  double a[] /* 2 dimension */,
  CONST int *lda
#endif
);

extern void dsyr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void dspr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  double ap[],
  CONST int length_1
#endif
);

extern void dsyr2(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void dspr2(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy,
  double ap[],
  CONST int length_1
#endif
);

extern double f06qgf(
#ifdef __STDC__
  CONST char norm[],
  CONST char matrix[],
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06qhf(
#ifdef __STDC__
  CONST char matrix[],
  CONST int *m,
  CONST int *n,
  CONST double *_const,
  CONST double *diag,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06qjf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *n,
  CONST int perm[],
  CONST int *k,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06qkf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *n,
  CONST double perm[],
  CONST int *k,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06qmf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char pivot[],
  CONST char direct[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  CONST double s[],
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06qpf(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double c[],
  double s[]
#endif
);

extern void f06qqf(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  double x[],
  CONST int *incx,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double c[],
  double s[]
#endif
);

extern void f06qrf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  double c[],
  double s[],
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06qsf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  double c[],
  double s[],
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06qtf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  double c[],
  double s[],
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06qvf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  double s[],
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06qwf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  double s[],
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06qxf(
#ifdef __STDC__
  CONST char side[],
  CONST char pivot[],
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  CONST double s[],
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06raf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1
#endif
);

extern double f06rbf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double work[],
  CONST int length_1
#endif
);

extern double f06rcf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06rdf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST double ap[],
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06ref(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST int *k,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06rjf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06rkf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST double ap[],
  double work[],
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06rlf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double work[],
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06rmf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1
#endif
);

extern double f06rnf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST double dl[],
  CONST double d[],
  CONST double du[],
  CONST int length_1
#endif
);

extern double f06rpf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST double d[],
  CONST double e[],
  CONST int length_1
#endif
);

extern void f06saf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06sbf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06scf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06sdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06sef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex ap[],
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06sff(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zgemv(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void zgbmv(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void zhemv(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void zhbmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void zhpmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex ap[],
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void ztrmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06sgf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06shf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex ap[],
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06sjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06skf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06slf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex ap[],
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06smf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex a[] /* 2 dimension */,
  CONST int *lda
#endif
);

extern void f06snf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex a[] /* 2 dimension */,
  CONST int *lda
#endif
);

extern void f06spf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06sqf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex ap[],
  CONST int length_1
#endif
);

extern void f06srf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06ssf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex ap[],
  CONST int length_1
#endif
);

extern void f06taf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06tbf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06tcf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex ap[],
  CONST Complex x[],
  CONST int *incx,
  CONST Complex *beta,
  Complex y[],
  CONST int *incy,
  CONST int length_1
#endif
);

extern void f06tdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex ap[],
  CONST int length_1
#endif
);

extern void f06tff(
#ifdef __STDC__
  CONST char matrix[],
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1
#endif
);

extern void f06thf(
#ifdef __STDC__
  CONST char matrix[],
  CONST int *m,
  CONST int *n,
  CONST Complex *_const,
  CONST Complex *diag,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06tmf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char pivot[],
  CONST char direct[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  CONST Complex s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06tpf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *alpha,
  Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double c[],
  Complex s[]
#endif
);

extern void f06tqf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex *alpha,
  Complex x[],
  CONST int *incx,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double c[],
  Complex s[]
#endif
);

extern void f06trf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  Complex c[],
  double s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06tsf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  double c[],
  Complex s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06ttf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  double c[],
  Complex s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06tvf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST Complex c[],
  double s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06twf(
#ifdef __STDC__
  CONST char side[],
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  Complex s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void f06txf(
#ifdef __STDC__
  CONST char side[],
  CONST char pivot[],
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  CONST Complex s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06tyf(
#ifdef __STDC__
  CONST char side[],
  CONST char pivot[],
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST Complex c[],
  CONST double s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06uaf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1
#endif
);

extern double f06ubf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double work[],
  CONST int length_1
#endif
);

extern double f06ucf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06udf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06uef(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST int *k,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06uff(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06ugf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztbmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztpmv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex ap[],
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztrsv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztbsv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztpsv(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST Complex ap[],
  Complex x[],
  CONST int *incx,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zgeru(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex a[] /* 2 dimension */,
  CONST int *lda
#endif
);

extern void zgerc(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex a[] /* 2 dimension */,
  CONST int *lda
#endif
);

extern void zher(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void zhpr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double *alpha,
  CONST Complex x[],
  CONST int *incx,
  Complex ap[],
  CONST int length_1
#endif
);

extern void zher2(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1
#endif
);

extern void zhpr2(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy,
  Complex ap[],
  CONST int length_1
#endif
);

extern double f06uhf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST int *n,
  CONST int *k,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double work[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double f06ujf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06ukf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST Complex ap[],
  double work[],
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06ulf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST int *k,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double work[],
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double f06umf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  double work[],
  CONST int length_1
#endif
);

extern double f06unf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST Complex dl[],
  CONST Complex d[],
  CONST Complex du[],
  CONST int length_1
#endif
);

extern double f06upf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST double d[],
  CONST Complex e[],
  CONST int length_1
#endif
);

extern double f06vgf(
#ifdef __STDC__
  CONST char norm[],
  CONST char matrix[],
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06vjf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *n,
  CONST int perm[],
  CONST int *k,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06vkf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *n,
  CONST double perm[],
  CONST int *k,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06vxf(
#ifdef __STDC__
  CONST char side[],
  CONST char pivot[],
  CONST char direct[],
  CONST int *m,
  CONST int *n,
  CONST int *k1,
  CONST int *k2,
  CONST double c[],
  CONST double s[],
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f06yaf(
#ifdef __STDC__
  CONST char transa[],
  CONST char transb[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06ycf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06yff(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f06yjf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f06ypf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06yrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06zaf(
#ifdef __STDC__
  CONST char transa[],
  CONST char transb[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06zcf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06zff(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f06zjf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f06zpf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06zrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06ztf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06zuf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f06zwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07aaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07abf(
#ifdef __STDC__
  CONST char fact[],
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double af[] /* 2 dimension */,
  CONST int *ldaf,
  int ipiv[],
  char equed[],
  double r[],
  double c[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07adf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  int *info
#endif
);

extern void dgemm(
#ifdef __STDC__
  CONST char transa[],
  CONST char transb[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dsymm(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dtrmm(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void dtrsm(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void dsyrk(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dsyr2k(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zgemm(
#ifdef __STDC__
  CONST char transa[],
  CONST char transb[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zhemm(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztrmm(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void ztrsm(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char transa[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void zherk(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST double *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zher2k(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zsymm(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST int *m,
  CONST int *n,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zsyrk(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zsyr2k(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST int *n,
  CONST int *k,
  CONST Complex *alpha,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex *beta,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dgetrf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  int *info
#endif
);

extern void f07aef(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07agf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07ahf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07ajf(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f07anf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07apf(
#ifdef __STDC__
  CONST char fact[],
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  int ipiv[],
  char equed[],
  double r[],
  double c[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07arf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  int *info
#endif
);

extern void f07asf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07auf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07avf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07awf(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f07baf(
#ifdef __STDC__
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07bbf(
#ifdef __STDC__
  CONST char fact[],
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double afb[] /* 2 dimension */,
  CONST int *ldafb,
  int ipiv[],
  char equed[],
  double r[],
  double c[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07bdf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  int *info
#endif
);

extern void f07bef(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07bgf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07bhf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07bnf(
#ifdef __STDC__
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07bpf(
#ifdef __STDC__
  CONST char fact[],
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex afb[] /* 2 dimension */,
  CONST int *ldafb,
  int ipiv[],
  char equed[],
  double r[],
  double c[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07brf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  int *info
#endif
);

extern void f07bsf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07buf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07bvf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07caf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double dl[],
  double d[],
  double du[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07cbf(
#ifdef __STDC__
  CONST char fact[],
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST double dl[],
  CONST double d[],
  CONST double du[],
  double dlf[],
  double df[],
  double duf[],
  double du2[],
  int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07cnf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  Complex dl[],
  Complex d[],
  Complex du[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07cpf(
#ifdef __STDC__
  CONST char fact[],
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex dl[],
  CONST Complex d[],
  CONST Complex du[],
  Complex dlf[],
  Complex df[],
  Complex duf[],
  Complex du2[],
  int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07faf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07fbf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double af[] /* 2 dimension */,
  CONST int *ldaf,
  char equed[],
  double s[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07fdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void dgetrs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dgecon(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dgerfs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dgetri(
#ifdef __STDC__
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zgetrf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  int *info
#endif
);

extern void zgetrs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zgecon(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zgerfs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zgetri(
#ifdef __STDC__
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dgbtrf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  int *info
#endif
);

extern void dgbtrs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dgbcon(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dgbrfs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zgbtrf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  int ipiv[],
  int *info
#endif
);

extern void zgbtrs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zgbcon(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zgbrfs(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dpotrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void f07fef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07fgf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07fhf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07fjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void f07fnf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07fpf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  char equed[],
  double s[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07frf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void f07fsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07fuf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07fvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07fwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void f07gaf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double ap[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07gbf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double ap[],
  double afp[],
  char equed[],
  double s[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07gdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  int *info,
  CONST int length_1
#endif
);

extern void f07gef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07ggf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double ap[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07ghf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST double afp[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07gjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  int *info,
  CONST int length_1
#endif
);

extern void f07gnf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex ap[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07gpf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex ap[],
  Complex afp[],
  char equed[],
  double s[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07grf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int *info,
  CONST int length_1
#endif
);

extern void f07gsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07guf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07gvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex afp[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07gwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int *info,
  CONST int length_1
#endif
);

extern void f07haf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07hbf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double afb[] /* 2 dimension */,
  CONST int *ldafb,
  char equed[],
  double s[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07hdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int *info,
  CONST int length_1
#endif
);

extern void f07hef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07hgf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07hhf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dpotrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dpocon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dporfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dpotri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void zpotrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void zpotrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zpocon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zporfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zpotri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1
#endif
);

extern void dpptrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  int *info,
  CONST int length_1
#endif
);

extern void dpptrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dppcon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double ap[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dpprfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST double afp[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dpptri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  int *info,
  CONST int length_1
#endif
);

extern void zpptrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int *info,
  CONST int length_1
#endif
);

extern void zpptrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zppcon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zpprfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex afp[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zpptri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int *info,
  CONST int length_1
#endif
);

extern void dpbtrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int *info,
  CONST int length_1
#endif
);

extern void dpbtrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dpbcon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dpbrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07hnf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07hpf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex afb[] /* 2 dimension */,
  CONST int *ldafb,
  char equed[],
  double s[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07hrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  int *info,
  CONST int length_1
#endif
);

extern void f07hsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07huf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07hvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07jaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double d[],
  double e[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07jbf(
#ifdef __STDC__
  CONST char fact[],
  CONST int *n,
  CONST int *nrhs,
  CONST double d[],
  CONST double e[],
  double df[],
  double ef[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07jnf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nrhs,
  double d[],
  Complex e[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info
#endif
);

extern void f07jpf(
#ifdef __STDC__
  CONST char fact[],
  CONST int *n,
  CONST int *nrhs,
  CONST double d[],
  CONST Complex e[],
  double df[],
  Complex ef[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07maf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f07mbf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double af[] /* 2 dimension */,
  CONST int *ldaf,
  int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  CONST int *lwork,
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07mdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f07mef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07mgf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07mhf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07mjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07mnf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f07mpf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07mrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f07msf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07muf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07mvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07mwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07nnf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f07npf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07nrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f07nsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07nuf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void zpbtrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  int *info,
  CONST int length_1
#endif
);

extern void zpbtrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zpbcon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double *anorm,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zpbrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex afb[] /* 2 dimension */,
  CONST int *ldafb,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dsytrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void dsytrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dsycon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dsyrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dsytri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void zhetrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void zhetrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zhecon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void zherfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zhetri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void zsytrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int ipiv[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void zsytrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zsycon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07nvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07nwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07paf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  double ap[],
  int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07pbf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  double afp[],
  int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07pdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  int ipiv[],
  int *info,
  CONST int length_1
#endif
);

extern void f07pef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07pgf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double ap[],
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07phf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST double afp[],
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07pjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  CONST int ipiv[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07pnf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex ap[],
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07ppf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  Complex afp[],
  int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07prf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int ipiv[],
  int *info,
  CONST int length_1
#endif
);

extern void f07psf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07puf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07pvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex afp[],
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07pwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07qnf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  Complex ap[],
  int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07qpf(
#ifdef __STDC__
  CONST char fact[],
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  Complex afp[],
  int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double *rcond,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07qrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int ipiv[],
  int *info,
  CONST int length_1
#endif
);

extern void f07qsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f07quf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07qvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex afp[],
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f07qwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f07tef(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07tgf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07thf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07tjf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07tsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07tuf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07tvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zsyrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex af[] /* 2 dimension */,
  CONST int *ldaf,
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zsytri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void dsptrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  int ipiv[],
  int *info,
  CONST int length_1
#endif
);

extern void dsptrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST int ipiv[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dspcon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double ap[],
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dsprfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST double afp[],
  CONST int ipiv[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void dsptri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  CONST int ipiv[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void zhptrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int ipiv[],
  int *info,
  CONST int length_1
#endif
);

extern void zhptrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zhpcon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void zhprfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex afp[],
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zhptri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void zsptrf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  int ipiv[],
  int *info,
  CONST int length_1
#endif
);

extern void zsptrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST int ipiv[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zspcon(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST int ipiv[],
  CONST double *anorm,
  double *rcond,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void zsprfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex afp[],
  CONST int ipiv[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zsptri(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  CONST int ipiv[],
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void dtrtrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtrcon(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtrrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtrtri(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztrtrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztrcon(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztrrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07twf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07uef(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07ugf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST double ap[],
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07uhf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07ujf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  double ap[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07usf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07uuf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST Complex ap[],
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07uvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07uwf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  Complex ap[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f07vef(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07vgf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07vhf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07vsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07vuf(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f07vvf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08aaf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08aef(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08aff(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08agf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08ahf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08ajf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08akf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08anf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08asf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08atf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08auf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08avf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08awf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08axf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08baf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int jpvt[],
  CONST double *rcond,
  int *rank,
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08bnf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int jpvt[],
  CONST double *rcond,
  int *rank,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info
#endif
);

extern void f08bef(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int jpvt[],
  double tau[],
  double work[],
  int *info
#endif
);

extern void f08bsf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int jpvt[],
  Complex tau[],
  Complex work[],
  double rwork[],
  int *info
#endif
);

extern void f08faf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08fbf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08fcf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dsyevd(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08fdf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  int isuppz[],
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08fef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  double tau[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08fff(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08fgf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08fnf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08fpf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08fqf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zheevd(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double w[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08frf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  int isuppz[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08fsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08ftf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08fuf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08gaf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08gbf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  double ap[],
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08gcf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dspevd(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08gef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double d[],
  double e[],
  double tau[],
  int *info,
  CONST int length_1
#endif
);

extern void f08gff(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double ap[],
  CONST double tau[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08ggf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  double ap[],
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08gnf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08gpf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08gqf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zhpevd(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08gsf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  double d[],
  double e[],
  Complex tau[],
  int *info,
  CONST int length_1
#endif
);

extern void f08gtf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST Complex tau[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08guf(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  Complex ap[],
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08haf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08hbf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08hcf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dsbevd(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08hef(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08hnf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08hpf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08hqf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zhbevd(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08hsf(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08jaf(
#ifdef __STDC__
  CONST char jobz[],
  CONST int *n,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08jbf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST int *n,
  double d[],
  double e[],
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08jcf(
#ifdef __STDC__
  CONST char jobz[],
  CONST int *n,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1
#endif
);

extern void dstevd(
#ifdef __STDC__
  CONST char jobz[],
  CONST int *n,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08jdf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST int *n,
  double d[],
  double e[],
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  int isuppz[],
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08jef(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08jff(
#ifdef __STDC__
  CONST int *n,
  double d[],
  double e[],
  int *info
#endif
);

extern void f08jgf(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08jjf(
#ifdef __STDC__
  CONST char range[],
  CONST char order[],
  CONST int *n,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  CONST double d[],
  CONST double e[],
  int *m,
  int *nsplit,
  double w[],
  int iblock[],
  int isplit[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08jkf(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  CONST double e[],
  CONST int *m,
  CONST double w[],
  CONST int iblock[],
  CONST int isplit[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info
#endif
);

extern void f08jsf(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08juf(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08jxf(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  CONST double e[],
  CONST int *m,
  CONST double w[],
  CONST int iblock[],
  CONST int isplit[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info
#endif
);

extern void f08kaf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double s[],
  CONST double *rcond,
  int *rank,
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08kbf(
#ifdef __STDC__
  CONST char jobu[],
  CONST char jobvt[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double s[],
  double u[] /* 2 dimension */,
  CONST int *ldu,
  double vt[] /* 2 dimension */,
  CONST int *ldvt,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08kcf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double s[],
  CONST double *rcond,
  int *rank,
  double work[],
  CONST int *lwork,
  int iwork[],
  int *info
#endif
);

extern void f08kdf(
#ifdef __STDC__
  CONST char jobz[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double s[],
  double u[] /* 2 dimension */,
  CONST int *ldu,
  double vt[] /* 2 dimension */,
  CONST int *ldvt,
  double work[],
  CONST int *lwork,
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f08kef(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  double tauq[],
  double taup[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08kff(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08kgf(
#ifdef __STDC__
  CONST char vect[],
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08knf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double s[],
  CONST double *rcond,
  int *rank,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info
#endif
);

extern void f08kpf(
#ifdef __STDC__
  CONST char jobu[],
  CONST char jobvt[],
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double s[],
  Complex u[] /* 2 dimension */,
  CONST int *ldu,
  Complex vt[] /* 2 dimension */,
  CONST int *ldvt,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08kqf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *nrhs,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double s[],
  CONST double *rcond,
  int *rank,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  int *info
#endif
);

extern void f08krf(
#ifdef __STDC__
  CONST char jobz[],
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double s[],
  Complex u[] /* 2 dimension */,
  CONST int *ldu,
  Complex vt[] /* 2 dimension */,
  CONST int *ldvt,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f08ksf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  Complex tauq[],
  Complex taup[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08ktf(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void f08kuf(
#ifdef __STDC__
  CONST char vect[],
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08lef(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *ncc,
  CONST int *kl,
  CONST int *ku,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double pt[] /* 2 dimension */,
  CONST int *ldpt,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void dgbbrd(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *ncc,
  CONST int *kl,
  CONST int *ku,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double pt[] /* 2 dimension */,
  CONST int *ldpt,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08lsf(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *ncc,
  CONST int *kl,
  CONST int *ku,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex pt[] /* 2 dimension */,
  CONST int *ldpt,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void zgbbrd(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *ncc,
  CONST int *kl,
  CONST int *ku,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex pt[] /* 2 dimension */,
  CONST int *ldpt,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1
#endif
);

extern void f08mef(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *ncvt,
  CONST int *nru,
  CONST int *ncc,
  double d[],
  double e[],
  double vt[] /* 2 dimension */,
  CONST int *ldvt,
  double u[] /* 2 dimension */,
  CONST int *ldu,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08msf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *ncvt,
  CONST int *nru,
  CONST int *ncc,
  double d[],
  double e[],
  Complex vt[] /* 2 dimension */,
  CONST int *ldvt,
  Complex u[] /* 2 dimension */,
  CONST int *ldu,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08naf(
#ifdef __STDC__
  CONST char jobvl[],
  CONST char jobvr[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double wr[],
  double wi[],
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08nbf(
#ifdef __STDC__
  CONST char balanc[],
  CONST char jobvl[],
  CONST char jobvr[],
  CONST char sense[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double wr[],
  double wi[],
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  int *ilo,
  int *ihi,
  double scale[],
  double *abnrm,
  double rconde[],
  double rcondv[],
  double work[],
  CONST int *lwork,
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f08nef(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08nff(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08ngf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08nhf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *ilo,
  int *ihi,
  double scale[],
  int *info,
  CONST int length_1
#endif
);

extern void f08njf(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double scale[],
  CONST int *m,
  double v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08nnf(
#ifdef __STDC__
  CONST char jobvl[],
  CONST char jobvr[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex w[],
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08npf(
#ifdef __STDC__
  CONST char balanc[],
  CONST char jobvl[],
  CONST char jobvr[],
  CONST char sense[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex w[],
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  int *ilo,
  int *ihi,
  double scale[],
  double *abnrm,
  double rconde[],
  double rcondv[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f08nsf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08ntf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08nuf(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08nvf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *ilo,
  int *ihi,
  double scale[],
  int *info,
  CONST int length_1
#endif
);

extern void f08nwf(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double scale[],
  CONST int *m,
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08paf(
#ifdef __STDC__
  CONST char jobvs[],
  CONST char sort[],
  int (*select)(double *, double *),
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *sdim,
  double wr[],
  double wi[],
  double vs[] /* 2 dimension */,
  CONST int *ldvs,
  double work[],
  CONST int *lwork,
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08pbf(
#ifdef __STDC__
  CONST char jobvs[],
  CONST char sort[],
  int (*select)(double *, double *),
  CONST char sense[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *sdim,
  double wr[],
  double wi[],
  double vs[] /* 2 dimension */,
  CONST int *ldvs,
  double *rconde,
  double *rcondv,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08pef(
#ifdef __STDC__
  CONST char job[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double h[] /* 2 dimension */,
  CONST int *ldh,
  double wr[],
  double wi[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08pkf(
#ifdef __STDC__
  CONST char job[],
  CONST char eigsrc[],
  CONST char initv[],
  int select[],
  CONST int *n,
  CONST double h[] /* 2 dimension */,
  CONST int *ldh,
  double wr[],
  CONST double wi[],
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  double work[],
  int ifaill[],
  int ifailr[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08pnf(
#ifdef __STDC__
  CONST char jobvs[],
  CONST char sort[],
  int (*select)(Complex *),
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *sdim,
  Complex w[],
  Complex vs[] /* 2 dimension */,
  CONST int *ldvs,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern int f08pnz(
#ifdef __STDC__
  Complex *a
#endif
);

extern void f08ppf(
#ifdef __STDC__
  CONST char jobvs[],
  CONST char sort[],
  int (*select)(Complex *),
  CONST char sense[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *sdim,
  Complex w[],
  Complex vs[] /* 2 dimension */,
  CONST int *ldvs,
  double *rconde,
  double *rcondv,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08psf(
#ifdef __STDC__
  CONST char job[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex h[] /* 2 dimension */,
  CONST int *ldh,
  Complex w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08pxf(
#ifdef __STDC__
  CONST char job[],
  CONST char eigsrc[],
  CONST char initv[],
  CONST int select[],
  CONST int *n,
  CONST Complex h[] /* 2 dimension */,
  CONST int *ldh,
  Complex w[],
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  Complex work[],
  double rwork[],
  int ifaill[],
  int ifailr[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08qff(
#ifdef __STDC__
  CONST char compq[],
  CONST int *n,
  double t[] /* 2 dimension */,
  CONST int *ldt,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  int *ifst,
  int *ilst,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08qgf(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST int select[],
  CONST int *n,
  double t[] /* 2 dimension */,
  CONST int *ldt,
  CONST double q[] /* 2 dimension */,
  CONST int *ldq,
  double wr[],
  double wi[],
  int *m,
  double *s,
  double *sep,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08qhf(
#ifdef __STDC__
  CONST char trana[],
  CONST char tranb[],
  CONST int *isgn,
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double *scale,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08qkf(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  int select[],
  CONST int *n,
  CONST double t[] /* 2 dimension */,
  CONST int *ldt,
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08qlf(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST double t[] /* 2 dimension */,
  CONST int *ldt,
  CONST double vl[] /* 2 dimension */,
  CONST int *ldvl,
  CONST double vr[] /* 2 dimension */,
  CONST int *ldvr,
  double s[],
  double sep[],
  CONST int *mm,
  int *m,
  double work[] /* 2 dimension */,
  CONST int *ldwork,
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08qtf(
#ifdef __STDC__
  CONST char compq[],
  CONST int *n,
  Complex t[] /* 2 dimension */,
  CONST int *ldt,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  CONST int *ifst,
  CONST int *ilst,
  int *info,
  CONST int length_1
#endif
);

extern void f08quf(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST int select[],
  CONST int *n,
  Complex t[] /* 2 dimension */,
  CONST int *ldt,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex w[],
  int *m,
  double *s,
  double *sep,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08qvf(
#ifdef __STDC__
  CONST char trana[],
  CONST char tranb[],
  CONST int *isgn,
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  double *scale,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08qxf(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  Complex t[] /* 2 dimension */,
  CONST int *ldt,
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08qyf(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST Complex t[] /* 2 dimension */,
  CONST int *ldt,
  CONST Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  CONST Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  double s[],
  double sep[],
  CONST int *mm,
  int *m,
  Complex work[] /* 2 dimension */,
  CONST int *ldwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08saf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double w[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08sbf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08scf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double w[],
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08sef(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f08snf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double w[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08spf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08sqf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double w[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08ssf(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void f08taf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double bp[],
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08tbf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double bp[],
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08tcf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double bp[],
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08tef(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  double ap[],
  CONST double bp[],
  int *info,
  CONST int length_1
#endif
);

extern void f08tnf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  Complex bp[],
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08tpf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  Complex bp[],
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08tqf(
#ifdef __STDC__
  CONST int *itype,
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  Complex bp[],
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08tsf(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  CONST Complex bp[],
  int *info,
  CONST int length_1
#endif
);

extern void f08uaf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double bb[] /* 2 dimension */,
  CONST int *ldbb,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08ubf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double bb[] /* 2 dimension */,
  CONST int *ldbb,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08ucf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double bb[] /* 2 dimension */,
  CONST int *ldbb,
  double w[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08uef(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double bb[] /* 2 dimension */,
  CONST int *ldbb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dsbgst(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double bb[] /* 2 dimension */,
  CONST int *ldbb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08uff(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int *info,
  CONST int length_1
#endif
);

extern void dpbstf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  int *info,
  CONST int length_1
#endif
);

extern void f08unf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex bb[] /* 2 dimension */,
  CONST int *ldbb,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08upf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char range[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex bb[] /* 2 dimension */,
  CONST int *ldbb,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  int *m,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  double rwork[],
  int iwork[],
  int ifail[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08uqf(
#ifdef __STDC__
  CONST char jobz[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex bb[] /* 2 dimension */,
  CONST int *ldbb,
  double w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  CONST int *lrwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08usf(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex bb[] /* 2 dimension */,
  CONST int *ldbb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zhbgst(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *ka,
  CONST int *kb,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex bb[] /* 2 dimension */,
  CONST int *ldbb,
  Complex x[] /* 2 dimension */,
  CONST int *ldx,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08utf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kb,
  Complex bb[] /* 2 dimension */,
  CONST int *ldbb,
  int *info,
  CONST int length_1
#endif
);

extern void zpbstf(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *kb,
  Complex bb[] /* 2 dimension */,
  CONST int *ldbb,
  int *info,
  CONST int length_1
#endif
);

extern void f08vaf(
#ifdef __STDC__
  CONST char jobu[],
  CONST char jobv[],
  CONST char jobq[],
  CONST int *m,
  CONST int *n,
  CONST int *p,
  int *k,
  int *l,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double alpha[],
  double beta[],
  double u[] /* 2 dimension */,
  CONST int *ldu,
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08vnf(
#ifdef __STDC__
  CONST char jobu[],
  CONST char jobv[],
  CONST char jobq[],
  CONST int *m,
  CONST int *n,
  CONST int *p,
  int *k,
  int *l,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  double alpha[],
  double beta[],
  Complex u[] /* 2 dimension */,
  CONST int *ldu,
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex work[],
  double rwork[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08waf(
#ifdef __STDC__
  CONST char jobvl[],
  CONST char jobvr[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double alphar[],
  double alphai[],
  double beta[],
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08wbf(
#ifdef __STDC__
  CONST char balanc[],
  CONST char jobvl[],
  CONST char jobvr[],
  CONST char sense[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double alphar[],
  double alphai[],
  double beta[],
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  int *ilo,
  int *ihi,
  double lscale[],
  double rscale[],
  double *abnrm,
  double *bbnrm,
  double rconde[],
  double rcondv[],
  double work[],
  CONST int *lwork,
  int iwork[],
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f08wef(
#ifdef __STDC__
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double z[] /* 2 dimension */,
  CONST int *ldz,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dgghrd(
#ifdef __STDC__
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double z[] /* 2 dimension */,
  CONST int *ldz,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08whf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *ilo,
  int *ihi,
  double lscale[],
  double rscale[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void dggbal(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *ilo,
  int *ihi,
  double lscale[],
  double rscale[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08wjf(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double lscale[],
  CONST double rscale[],
  CONST int *m,
  double v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dggbak(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double lscale[],
  CONST double rscale[],
  CONST int *m,
  double v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08wnf(
#ifdef __STDC__
  CONST char jobvl[],
  CONST char jobvr[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex alpha[],
  Complex beta[],
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08wpf(
#ifdef __STDC__
  CONST char balanc[],
  CONST char jobvl[],
  CONST char jobvr[],
  CONST char sense[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex alpha[],
  Complex beta[],
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  int *ilo,
  int *ihi,
  double lscale[],
  double rscale[],
  double *abnrm,
  double *bbnrm,
  double rconde[],
  double rcondv[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f08wsf(
#ifdef __STDC__
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zgghrd(
#ifdef __STDC__
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08wvf(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *ilo,
  int *ihi,
  double lscale[],
  double rscale[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void zggbal(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *ilo,
  int *ihi,
  double lscale[],
  double rscale[],
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void f08wwf(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double lscale[],
  CONST double rscale[],
  CONST int *m,
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zggbak(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double lscale[],
  CONST double rscale[],
  CONST int *m,
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08xaf(
#ifdef __STDC__
  CONST char jobvsl[],
  CONST char jobvsr[],
  CONST char sort[],
  int (*selctg)(double *, double *, double *),
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *sdim,
  double alphar[],
  double alphai[],
  double beta[],
  double vsl[] /* 2 dimension */,
  CONST int *ldvsl,
  double vsr[] /* 2 dimension */,
  CONST int *ldvsr,
  double work[],
  CONST int *lwork,
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08xbf(
#ifdef __STDC__
  CONST char jobvsl[],
  CONST char jobvsr[],
  CONST char sort[],
  int (*selctg)(double *, double *, double *),
  CONST char sense[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *sdim,
  double alphar[],
  double alphai[],
  double beta[],
  double vsl[] /* 2 dimension */,
  CONST int *ldvsl,
  double vsr[] /* 2 dimension */,
  CONST int *ldvsr,
  double rconde[],
  double rcondv[],
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f08xef(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double alphar[],
  double alphai[],
  double beta[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dhgeqz(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double alphar[],
  double alphai[],
  double beta[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08xnf(
#ifdef __STDC__
  CONST char jobvsl[],
  CONST char jobvsr[],
  CONST char sort[],
  int (*selctg)(Complex *, Complex *),
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *sdim,
  Complex alpha[],
  Complex beta[],
  Complex vsl[] /* 2 dimension */,
  CONST int *ldvsl,
  Complex vsr[] /* 2 dimension */,
  CONST int *ldvsr,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern int f08xnz(
#ifdef __STDC__
  Complex *a,
  Complex *b
#endif
);

extern void f08xpf(
#ifdef __STDC__
  CONST char jobvsl[],
  CONST char jobvsr[],
  CONST char sort[],
  int (*selctg)(Complex *, Complex *),
  CONST char sense[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *sdim,
  Complex alpha[],
  Complex beta[],
  Complex vsl[] /* 2 dimension */,
  CONST int *ldvsl,
  Complex vsr[] /* 2 dimension */,
  CONST int *ldvsr,
  double rconde[],
  double rcondv[],
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int iwork[],
  CONST int *liwork,
  int bwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f08xsf(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex alpha[],
  Complex beta[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zhgeqz(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex alpha[],
  Complex beta[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void f08ykf(
#ifdef __STDC__
  CONST char side[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dtgevc(
#ifdef __STDC__
  CONST char side[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08yxf(
#ifdef __STDC__
  CONST char side[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztgevc(
#ifdef __STDC__
  CONST char side[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f08zaf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *p,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double c[],
  double d[],
  double x[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08zbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *p,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  double d[],
  double x[],
  double y[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08znf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *p,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex c[],
  Complex d[],
  Complex x[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f08zpf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *p,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex d[],
  Complex x[],
  Complex y[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void f11baf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST char norm[],
  CONST char weight[],
  CONST int *iterm,
  CONST int *n,
  CONST int *m,
  CONST double *tol,
  CONST int *maxitn,
  CONST double *anorm,
  CONST double *sigmax,
  CONST int *monit,
  int *lwreq,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f11bbf(
#ifdef __STDC__
  int *irevcm,
  double u[],
  double v[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11bcf(
#ifdef __STDC__
  int *itn,
  double *stplhs,
  double *stprhs,
  double *anorm,
  double *sigmax,
  int *ifail
#endif
);

extern void f11bdf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST char norm[],
  CONST char weight[],
  CONST int *iterm,
  CONST int *n,
  CONST int *m,
  CONST double *tol,
  CONST int *maxitn,
  CONST double *anorm,
  CONST double *sigmax,
  CONST int *monit,
  int *lwreq,
  double w[],
  CONST int *lw,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f11bef(
#ifdef __STDC__
  int *irevcm,
  double u[],
  double v[],
  CONST double wgt[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11bff(
#ifdef __STDC__
  int *itn,
  double *stplhs,
  double *stprhs,
  double *anorm,
  double *sigmax,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11brf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST char norm[],
  CONST char weight[],
  CONST int *iterm,
  CONST int *n,
  CONST int *m,
  CONST double *tol,
  CONST int *maxitn,
  CONST double *anorm,
  CONST double *sigmax,
  CONST int *monit,
  int *lwreq,
  Complex w[],
  CONST int *lw,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f11bsf(
#ifdef __STDC__
  int *irevcm,
  Complex u[],
  Complex v[],
  CONST double wgt[],
  Complex work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11btf(
#ifdef __STDC__
  int *itn,
  double *stplhs,
  double *stprhs,
  double *anorm,
  double *sigmax,
  Complex work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11daf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  double a[],
  CONST int *la,
  int irow[],
  int icol[],
  CONST int *lfill,
  CONST double *dtol,
  CONST char pstrat[],
  CONST char milu[],
  int ipivp[],
  int ipivq[],
  int istr[],
  int idiag[],
  int *nnzc,
  int *npivm,
  int iwork[],
  CONST int *liwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11dbf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST double a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipivp[],
  int ipivq[],
  CONST int istr[],
  CONST int idiag[],
  CONST char check[],
  CONST double y[],
  double x[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11dcf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipivp[],
  int ipivq[],
  CONST int istr[],
  CONST int idiag[],
  CONST double b[],
  CONST int *m,
  CONST double *tol,
  CONST int *maxitn,
  double x[],
  double *rnorm,
  int *itn,
  double work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f11ddf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int irow[],
  CONST int icol[],
  CONST double rdiag[],
  CONST double *omega,
  CONST char check[],
  CONST double y[],
  double x[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11def(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int irow[],
  CONST int icol[],
  CONST double *omega,
  CONST double b[],
  CONST int *m,
  CONST double *tol,
  CONST int *maxitn,
  double x[],
  double *rnorm,
  int *itn,
  double work[],
  CONST int *lwork,
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11dkf(
#ifdef __STDC__
  CONST char store[],
  CONST char trans[],
  CONST char init[],
  CONST int *niter,
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int irow[],
  CONST int icol[],
  CONST char check[],
  CONST double b[],
  double x[],
  double diag[],
  double work[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f11dnf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  Complex a[],
  CONST int *la,
  int irow[],
  int icol[],
  CONST int *lfill,
  CONST double *dtol,
  CONST char pstrat[],
  CONST char milu[],
  int ipivp[],
  int ipivq[],
  int istr[],
  int idiag[],
  int *nnzc,
  int *npivm,
  int iwork[],
  CONST int *liwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11dpf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST Complex a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipivp[],
  int ipivq[],
  CONST int istr[],
  CONST int idiag[],
  CONST char check[],
  CONST Complex y[],
  Complex x[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11dqf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipivp[],
  int ipivq[],
  CONST int istr[],
  CONST int idiag[],
  CONST Complex b[],
  CONST int *m,
  CONST double *tol,
  CONST int *maxitn,
  Complex x[],
  double *rnorm,
  int *itn,
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f11drf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int irow[],
  CONST int icol[],
  CONST Complex rdiag[],
  CONST double *omega,
  CONST char check[],
  CONST Complex y[],
  Complex x[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11dsf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int irow[],
  CONST int icol[],
  CONST double *omega,
  CONST Complex b[],
  CONST int *m,
  CONST double *tol,
  CONST int *maxitn,
  Complex x[],
  double *rnorm,
  int *itn,
  Complex work[],
  CONST int *lwork,
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11dxf(
#ifdef __STDC__
  CONST char store[],
  CONST char trans[],
  CONST char init[],
  CONST int *niter,
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int irow[],
  CONST int icol[],
  CONST char check[],
  CONST Complex b[],
  Complex x[],
  Complex diag[],
  Complex work[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void f11gaf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST char sigcmp[],
  CONST char norm[],
  CONST char weight[],
  CONST int *iterm,
  CONST int *n,
  CONST double *tol,
  CONST int *maxitn,
  CONST double *anorm,
  CONST double *sigmax,
  CONST double *sigtol,
  CONST int *maxits,
  CONST int *monit,
  int *lwreq,
  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 f11gbf(
#ifdef __STDC__
  int *irevcm,
  double u[],
  double v[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11gcf(
#ifdef __STDC__
  int *itn,
  double *stplhs,
  double *stprhs,
  double *anorm,
  double *sigmax,
  int *its,
  double *sigerr,
  int *ifail
#endif
);

extern void f11gdf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST char sigcmp[],
  CONST char norm[],
  CONST char weight[],
  CONST int *iterm,
  CONST int *n,
  CONST double *tol,
  CONST int *maxitn,
  CONST double *anorm,
  CONST double *sigmax,
  CONST double *sigtol,
  CONST int *maxits,
  CONST int *monit,
  int *lwreq,
  double work[],
  CONST int *lwork,
  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 f11gef(
#ifdef __STDC__
  int *irevcm,
  double u[],
  double v[],
  CONST double wgt[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11gff(
#ifdef __STDC__
  int *itn,
  double *stplhs,
  double *stprhs,
  double *anorm,
  double *sigmax,
  int *its,
  double *sigerr,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11grf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST char sigcmp[],
  CONST char norm[],
  CONST char weight[],
  CONST int *iterm,
  CONST int *n,
  CONST double *tol,
  CONST int *maxitn,
  CONST double *anorm,
  CONST double *sigmax,
  CONST double *sigtol,
  CONST int *maxits,
  CONST int *monit,
  int *lwreq,
  Complex w[],
  CONST int *lw,
  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 f11gsf(
#ifdef __STDC__
  int *irevcm,
  Complex u[],
  Complex v[],
  CONST double wgt[],
  Complex work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11gtf(
#ifdef __STDC__
  int *itn,
  double *stplhs,
  double *stprhs,
  double *anorm,
  double *sigmax,
  int *its,
  double *sigerr,
  Complex work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void f11jaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  double a[],
  CONST int *la,
  int irow[],
  int icol[],
  CONST int *lfill,
  CONST double *dtol,
  CONST char mic[],
  CONST double *dscale,
  CONST char pstrat[],
  int ipiv[],
  int istr[],
  int *nnzc,
  int *npivm,
  int iwork[],
  CONST int *liwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11jbf(
#ifdef __STDC__
  CONST int *n,
  CONST double a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipiv[],
  int istr[],
  CONST char check[],
  CONST double y[],
  double x[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11jcf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipiv[],
  int istr[],
  CONST double b[],
  CONST double *tol,
  CONST int *maxitn,
  double x[],
  double *rnorm,
  int *itn,
  double work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f11jdf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int irow[],
  CONST int icol[],
  CONST double rdiag[],
  CONST double *omega,
  CONST char check[],
  CONST double y[],
  double x[],
  int iwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11jef(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int irow[],
  CONST int icol[],
  CONST double *omega,
  CONST double b[],
  CONST double *tol,
  CONST int *maxitn,
  double x[],
  double *rnorm,
  int *itn,
  double work[],
  CONST int *lwork,
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11jnf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  Complex a[],
  CONST int *la,
  int irow[],
  int icol[],
  CONST int *lfill,
  CONST double *dtol,
  CONST char mic[],
  CONST double *dscale,
  CONST char pstrat[],
  int ipiv[],
  int istr[],
  int *nnzc,
  int *npivm,
  int iwork[],
  CONST int *liwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11jpf(
#ifdef __STDC__
  CONST int *n,
  CONST Complex a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipiv[],
  CONST int istr[],
  CONST char check[],
  CONST Complex y[],
  Complex x[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11jqf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int *la,
  CONST int irow[],
  CONST int icol[],
  int ipiv[],
  CONST int istr[],
  CONST Complex b[],
  CONST double *tol,
  CONST int *maxitn,
  Complex x[],
  double *rnorm,
  int *itn,
  Complex work[],
  CONST int *lwork,
  int *ifail,
  CONST int length_1
#endif
);

extern void f11jrf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int irow[],
  CONST int icol[],
  CONST double rdiag[],
  CONST double *omega,
  CONST char check[],
  CONST Complex y[],
  Complex x[],
  int iwork[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11jsf(
#ifdef __STDC__
  CONST char method[],
  CONST char precon[],
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int irow[],
  CONST int icol[],
  CONST double *omega,
  CONST Complex b[],
  CONST double *tol,
  CONST int *maxitn,
  Complex x[],
  double *rnorm,
  int *itn,
  double rdiag[],
  Complex work[],
  CONST int *lwork,
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11mdf(
#ifdef __STDC__
  CONST char spec[],
  CONST int *n,
  CONST int icolzp[],
  CONST int irowix[],
  int iprm[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11mef(
#ifdef __STDC__
  CONST int *n,
  CONST int irowix[],
  CONST double a[],
  int iprm[],
  CONST double *thresh,
  CONST int *nzlmx,
  int *nzlumx,
  CONST int *nzumx,
  int il[],
  double lval[],
  int iu[],
  double uval[],
  int *nnzl,
  int *nnzu,
  double *flop,
  int *ifail
#endif
);

extern void f11mff(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int iprm[],
  CONST int il[],
  CONST double lval[],
  CONST int iu[],
  CONST double uval[],
  CONST int *nrhs,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *ifail,
  CONST int length_1
#endif
);

extern void f11mgf(
#ifdef __STDC__
  CONST char norm[],
  CONST int *n,
  CONST int il[],
  CONST double lval[],
  CONST int iu[],
  CONST double uval[],
  CONST double *anorm,
  double *rcond,
  int *ifail,
  CONST int length_1
#endif
);

extern void f11mhf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int icolzp[],
  CONST int irowix[],
  CONST double a[],
  CONST int iprm[],
  CONST int il[],
  CONST double lval[],
  CONST int iu[],
  CONST double uval[],
  CONST int *nrhs,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11mkf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *m,
  CONST double *alpha,
  CONST int icolzp[],
  CONST int irowix[],
  CONST double a[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double *beta,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  int *ifail,
  CONST int length_1
#endif
);

extern void f11mlf(
#ifdef __STDC__
  CONST char norm[],
  double *anorm,
  CONST int *n,
  CONST int icolzp[],
  CONST int irowix[],
  CONST double a[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11mmf(
#ifdef __STDC__
  CONST int *n,
  CONST int icolzp[],
  CONST double a[],
  CONST int iprm[],
  CONST int il[],
  CONST double lval[],
  CONST int iu[],
  CONST double uval[],
  double *rpg,
  int *ifail
#endif
);

extern void f11xaf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int irow[],
  CONST int icol[],
  CONST char check[],
  CONST double x[],
  double y[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11xef(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  CONST double a[],
  CONST int irow[],
  CONST int icol[],
  CONST char check[],
  CONST double x[],
  double y[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11xnf(
#ifdef __STDC__
  CONST char trans[],
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int irow[],
  CONST int icol[],
  CONST char check[],
  CONST Complex x[],
  Complex y[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11xsf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nnz,
  CONST Complex a[],
  CONST int irow[],
  CONST int icol[],
  CONST char check[],
  CONST Complex x[],
  Complex y[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f11zaf(
#ifdef __STDC__
  CONST int *n,
  int *nnz,
  double a[],
  int irow[],
  int icol[],
  CONST char dup[],
  CONST char zero[],
  int istr[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11zbf(
#ifdef __STDC__
  CONST int *n,
  int *nnz,
  double a[],
  int irow[],
  int icol[],
  CONST char dup[],
  CONST char zero[],
  int istr[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11znf(
#ifdef __STDC__
  CONST int *n,
  int *nnz,
  Complex a[],
  int irow[],
  int icol[],
  CONST char dup[],
  CONST char zero[],
  int istr[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void f11zpf(
#ifdef __STDC__
  CONST int *n,
  int *nnz,
  Complex a[],
  int irow[],
  int icol[],
  CONST char dup[],
  CONST char zero[],
  int istr[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern double ddot(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  CONST double y[],
  CONST int *incy
#endif
);

extern void drotg(
#ifdef __STDC__
  double *a,
  double *b,
  double *c,
  double *s
#endif
);

extern void daxpy(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  CONST double x[],
  CONST int *incx,
  double y[],
  CONST int *incy
#endif
);

extern void dscal(
#ifdef __STDC__
  CONST int *n,
  CONST double *alpha,
  double x[],
  CONST int *incx
#endif
);

extern void dcopy(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx,
  double y[],
  CONST int *incy
#endif
);

extern void dswap(
#ifdef __STDC__
  CONST int *n,
  double x[],
  CONST int *incx,
  double y[],
  CONST int *incy
#endif
);

extern double dnrm2(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx
#endif
);

extern double dasum(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *incx
#endif
);

extern void drot(
#ifdef __STDC__
  CONST int *n,
  double x[],
  CONST int *incx,
  double y[],
  CONST int *incy,
  CONST double *c,
  CONST double *s
#endif
);

extern double ddoti(
#ifdef __STDC__
  CONST int *nz,
  CONST double x[],
  CONST int indx[],
  CONST double y[]
#endif
);

extern void daxpyi(
#ifdef __STDC__
  CONST int *nz,
  CONST double *a,
  CONST double x[],
  CONST int indx[],
  double y[]
#endif
);

extern void dgthr(
#ifdef __STDC__
  CONST int *nz,
  CONST double y[],
  double x[],
  CONST int indx[]
#endif
);

extern void dgthrz(
#ifdef __STDC__
  CONST int *nz,
  double y[],
  double x[],
  CONST int indx[]
#endif
);

extern void dsctr(
#ifdef __STDC__
  CONST int *nz,
  CONST double x[],
  CONST int indx[],
  double y[]
#endif
);

extern void droti(
#ifdef __STDC__
  CONST int *nz,
  double x[],
  CONST int indx[],
  double y[],
  CONST double *c,
  CONST double *s
#endif
);

extern void ztrtri(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dtptrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtpcon(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST double ap[],
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtprfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST double ap[],
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtptri(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  double ap[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztptrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztpcon(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST Complex ap[],
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztprfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *nrhs,
  CONST Complex ap[],
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztptri(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  Complex ap[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dtbtrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtbcon(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  double *rcond,
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtbrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztbtrs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztbcon(
#ifdef __STDC__
  CONST char norm[],
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double *rcond,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void ztbrfs(
#ifdef __STDC__
  CONST char uplo[],
  CONST char trans[],
  CONST char diag[],
  CONST int *n,
  CONST int *kd,
  CONST int *nrhs,
  CONST Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  CONST Complex x[] /* 2 dimension */,
  CONST int *ldx,
  double ferr[],
  double berr[],
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dgeqrf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dorgqr(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dormqr(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dgelqf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dorglq(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dormlq(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zgeqrf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zungqr(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zunmqr(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zgelqf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zunglq(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zunmlq(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dgeqpf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int jpvt[],
  double tau[],
  double work[],
  int *info
#endif
);

extern void zgeqpf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int jpvt[],
  Complex tau[],
  Complex work[],
  double rwork[],
  int *info
#endif
);

extern void dsytrd(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  double tau[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void dorgtr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void dormtr(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zhetrd(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void zungtr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void zunmtr(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dsptrd(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  double ap[],
  double d[],
  double e[],
  double tau[],
  int *info,
  CONST int length_1
#endif
);

extern void dopgtr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST double ap[],
  CONST double tau[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void dopmtr(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  double ap[],
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zhptrd(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  double d[],
  double e[],
  Complex tau[],
  int *info,
  CONST int length_1
#endif
);

extern void zupgtr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST Complex ap[],
  CONST Complex tau[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex work[],
  int *info,
  CONST int length_1
#endif
);

extern void zupmtr(
#ifdef __STDC__
  CONST char side[],
  CONST char uplo[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  Complex ap[],
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dsbtrd(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  double ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zhbtrd(
#ifdef __STDC__
  CONST char vect[],
  CONST char uplo[],
  CONST int *n,
  CONST int *kd,
  Complex ab[] /* 2 dimension */,
  CONST int *ldab,
  double d[],
  double e[],
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dsteqr(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void dsterf(
#ifdef __STDC__
  CONST int *n,
  double d[],
  double e[],
  int *info
#endif
);

extern void dpteqr(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void dstebz(
#ifdef __STDC__
  CONST char range[],
  CONST char order[],
  CONST int *n,
  CONST double *vl,
  CONST double *vu,
  CONST int *il,
  CONST int *iu,
  CONST double *abstol,
  CONST double d[],
  CONST double e[],
  int *m,
  int *nsplit,
  double w[],
  int iblock[],
  int isplit[],
  double work[],
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dstein(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  CONST double e[],
  CONST int *m,
  CONST double w[],
  CONST int iblock[],
  CONST int isplit[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info
#endif
);

extern void zsteqr(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void zpteqr(
#ifdef __STDC__
  CONST char compz[],
  CONST int *n,
  double d[],
  double e[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void zstein(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  CONST double e[],
  CONST int *m,
  CONST double w[],
  CONST int iblock[],
  CONST int isplit[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  int iwork[],
  int ifail[],
  int *info
#endif
);

extern void dgebrd(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  double tauq[],
  double taup[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dorgbr(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void dormbr(
#ifdef __STDC__
  CONST char vect[],
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zgebrd(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  double d[],
  double e[],
  Complex tauq[],
  Complex taup[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zungbr(
#ifdef __STDC__
  CONST char vect[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1
#endif
);

extern void zunmbr(
#ifdef __STDC__
  CONST char vect[],
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *k,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dbdsqr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *ncvt,
  CONST int *nru,
  CONST int *ncc,
  double d[],
  double e[],
  double vt[] /* 2 dimension */,
  CONST int *ldvt,
  double u[] /* 2 dimension */,
  CONST int *ldu,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void zbdsqr(
#ifdef __STDC__
  CONST char uplo[],
  CONST int *n,
  CONST int *ncvt,
  CONST int *nru,
  CONST int *ncc,
  double d[],
  double e[],
  Complex vt[] /* 2 dimension */,
  CONST int *ldvt,
  Complex u[] /* 2 dimension */,
  CONST int *ldu,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void dgehrd(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dorghr(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double work[],
  CONST int *lwork,
  int *info
#endif
);

extern void dormhr(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double tau[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dgebal(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  int *ilo,
  int *ihi,
  double scale[],
  int *info,
  CONST int length_1
#endif
);

extern void dgebak(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double scale[],
  CONST int *m,
  double v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zgehrd(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zunghr(
#ifdef __STDC__
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex work[],
  CONST int *lwork,
  int *info
#endif
);

extern void zunmhr(
#ifdef __STDC__
  CONST char side[],
  CONST char trans[],
  CONST int *m,
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex tau[],
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zgebal(
#ifdef __STDC__
  CONST char job[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  int *ilo,
  int *ihi,
  double scale[],
  int *info,
  CONST int length_1
#endif
);

extern void zgebak(
#ifdef __STDC__
  CONST char job[],
  CONST char side[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  CONST double scale[],
  CONST int *m,
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dhseqr(
#ifdef __STDC__
  CONST char job[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  double h[] /* 2 dimension */,
  CONST int *ldh,
  double wr[],
  double wi[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dhsein(
#ifdef __STDC__
  CONST char job[],
  CONST char eigsrc[],
  CONST char initv[],
  int select[],
  CONST int *n,
  CONST double h[] /* 2 dimension */,
  CONST int *ldh,
  double wr[],
  CONST double wi[],
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  double work[],
  int ifaill[],
  int ifailr[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void zhseqr(
#ifdef __STDC__
  CONST char job[],
  CONST char compz[],
  CONST int *n,
  CONST int *ilo,
  CONST int *ihi,
  Complex h[] /* 2 dimension */,
  CONST int *ldh,
  Complex w[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void zhsein(
#ifdef __STDC__
  CONST char job[],
  CONST char eigsrc[],
  CONST char initv[],
  CONST int select[],
  CONST int *n,
  CONST Complex h[] /* 2 dimension */,
  CONST int *ldh,
  Complex w[],
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  Complex work[],
  double rwork[],
  int ifaill[],
  int ifailr[],
  int *info,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void dtrexc(
#ifdef __STDC__
  CONST char compq[],
  CONST int *n,
  double t[] /* 2 dimension */,
  CONST int *ldt,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  int *ifst,
  int *ilst,
  double work[],
  int *info,
  CONST int length_1
#endif
);

extern void dtrsen(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST int select[],
  CONST int *n,
  double t[] /* 2 dimension */,
  CONST int *ldt,
  CONST double q[] /* 2 dimension */,
  CONST int *ldq,
  double wr[],
  double wi[],
  int *m,
  double *s,
  double *sep,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dtrsyl(
#ifdef __STDC__
  CONST char trana[],
  CONST char tranb[],
  CONST int *isgn,
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double *scale,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dtrevc(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  int select[],
  CONST int *n,
  CONST double t[] /* 2 dimension */,
  CONST int *ldt,
  double vl[] /* 2 dimension */,
  CONST int *ldvl,
  double vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  double work[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dtrsna(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST double t[] /* 2 dimension */,
  CONST int *ldt,
  CONST double vl[] /* 2 dimension */,
  CONST int *ldvl,
  CONST double vr[] /* 2 dimension */,
  CONST int *ldvr,
  double s[],
  double sep[],
  CONST int *mm,
  int *m,
  double work[] /* 2 dimension */,
  CONST int *ldwork,
  int iwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztrexc(
#ifdef __STDC__
  CONST char compq[],
  CONST int *n,
  Complex t[] /* 2 dimension */,
  CONST int *ldt,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  CONST int *ifst,
  CONST int *ilst,
  int *info,
  CONST int length_1
#endif
);

extern void ztrsen(
#ifdef __STDC__
  CONST char job[],
  CONST char compq[],
  CONST int select[],
  CONST int *n,
  Complex t[] /* 2 dimension */,
  CONST int *ldt,
  Complex q[] /* 2 dimension */,
  CONST int *ldq,
  Complex w[],
  int *m,
  double *s,
  double *sep,
  Complex work[],
  CONST int *lwork,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztrsyl(
#ifdef __STDC__
  CONST char trana[],
  CONST char tranb[],
  CONST int *isgn,
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST Complex b[] /* 2 dimension */,
  CONST int *ldb,
  Complex c[] /* 2 dimension */,
  CONST int *ldc,
  double *scale,
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztrevc(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  Complex t[] /* 2 dimension */,
  CONST int *ldt,
  Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  CONST int *mm,
  int *m,
  Complex work[],
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void ztrsna(
#ifdef __STDC__
  CONST char job[],
  CONST char howmny[],
  CONST int select[],
  CONST int *n,
  CONST Complex t[] /* 2 dimension */,
  CONST int *ldt,
  CONST Complex vl[] /* 2 dimension */,
  CONST int *ldvl,
  CONST Complex vr[] /* 2 dimension */,
  CONST int *ldvr,
  double s[],
  double sep[],
  CONST int *mm,
  int *m,
  Complex work[] /* 2 dimension */,
  CONST int *ldwork,
  double rwork[],
  int *info,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void dsygst(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void zhegst(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  Complex a[] /* 2 dimension */,
  CONST int *lda,
  Complex b[] /* 2 dimension */,
  CONST int *ldb,
  int *info,
  CONST int length_1
#endif
);

extern void dspgst(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  double ap[],
  CONST double bp[],
  int *info,
  CONST int length_1
#endif
);

extern void zhpgst(
#ifdef __STDC__
  CONST int *itype,
  CONST char uplo[],
  CONST int *n,
  Complex ap[],
  CONST Complex bp[],
  int *info,
  CONST int length_1
#endif
);

extern void g01aaf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  int *iwt,
  double wt[],
  double *xmean,
  double *s2,
  double *s3,
  double *s4,
  double *xmin,
  double *xmax,
  double *wsum,
  int *ifail
#endif
);

extern void f12aaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nev,
  CONST int *ncv,
  int icomm[],
  CONST int *licomm,
  double comm[],
  CONST int *lcomm,
  int *ifail
#endif
);

extern void f12abf(
#ifdef __STDC__
  int *irevcm,
  double resid[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double x[],
  double mx[],
  int *nshift,
  double comm[],
  int icomm[],
  int *ifail
#endif
);

extern void f12acf(
#ifdef __STDC__
  int *nconv,
  double dr[],
  double di[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  CONST double *sigmar,
  CONST double *sigmai,
  CONST double resid[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double comm[],
  int icomm[],
  int *ifail
#endif
);

extern void f12adf(
#ifdef __STDC__
  CONST char str[],
  int iopts[],
  double ropts[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f12aef(
#ifdef __STDC__
  int *niter,
  int *nconv,
  double ritzr[],
  double ritzi[],
  double rzest[],
  CONST int icomm[],
  CONST double comm[]
#endif
);

extern void f12aff(
#ifdef __STDC__
  CONST int *n,
  CONST int *nev,
  CONST int *ncv,
  int icomm[],
  CONST int *licomm,
  double comm[],
  CONST int *lcomm,
  int *ifail
#endif
);

extern void f12agf(
#ifdef __STDC__
  CONST int *kl,
  CONST int *ku,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double mb[],
  CONST int *ldmb,
  CONST double *sigmar,
  CONST double *sigmai,
  int *nconv,
  double dr[],
  double di[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double resid[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double comm[],
  int icomm[],
  int *ifail
#endif
);

extern void f12anf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nev,
  CONST int *ncv,
  int icomm[],
  CONST int *licomm,
  Complex comm[],
  CONST int *lcomm,
  int *ifail
#endif
);

extern void f12apf(
#ifdef __STDC__
  int *irevcm,
  Complex resid[],
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  Complex x[],
  Complex mx[],
  int *nshift,
  Complex comm[],
  int icomm[],
  int *ifail
#endif
);

extern void f12aqf(
#ifdef __STDC__
  int *nconv,
  Complex d[],
  Complex z[] /* 2 dimension */,
  CONST int *ldz,
  CONST Complex *sigma,
  CONST Complex resid[],
  Complex v[] /* 2 dimension */,
  CONST int *ldv,
  Complex comm[],
  int icomm[],
  int *ifail
#endif
);

extern void f12arf(
#ifdef __STDC__
  CONST char str[],
  int iopts[],
  Complex copts[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f12asf(
#ifdef __STDC__
  int *niter,
  int *nconv,
  Complex ritz[],
  Complex rzest[],
  CONST int icomm[],
  CONST Complex comm[]
#endif
);

extern void f12faf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nev,
  CONST int *ncv,
  int icomm[],
  CONST int *licomm,
  double comm[],
  CONST int *lcomm,
  int *ifail
#endif
);

extern void f12fbf(
#ifdef __STDC__
  int *irevcm,
  double resid[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double x[],
  double mx[],
  int *nshift,
  double comm[],
  int icomm[],
  int *ifail
#endif
);

extern void f12fcf(
#ifdef __STDC__
  int *nconv,
  double d[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  CONST double *sigma,
  CONST double resid[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double comm[],
  int icomm[],
  int *ifail
#endif
);

extern void f12fdf(
#ifdef __STDC__
  CONST char str[],
  int iopts[],
  double ropts[],
  int *ifail,
  CONST int length_1
#endif
);

extern void f12fef(
#ifdef __STDC__
  int *niter,
  int *nconv,
  double ritz[],
  double rzest[],
  CONST int icomm[],
  CONST double comm[]
#endif
);

extern void f12fff(
#ifdef __STDC__
  CONST int *n,
  CONST int *nev,
  CONST int *ncv,
  int icomm[],
  CONST int *licomm,
  double comm[],
  CONST int *lcomm,
  int *ifail
#endif
);

extern void f12fgf(
#ifdef __STDC__
  CONST int *kl,
  CONST int *ku,
  CONST double ab[] /* 2 dimension */,
  CONST int *ldab,
  CONST double mb[],
  CONST int *ldmb,
  CONST double *sigma,
  int *nconv,
  double d[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  double resid[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double comm[],
  int icomm[],
  int *ifail
#endif
);

extern void g01abf(
#ifdef __STDC__
  CONST int *n,
  CONST double x1[],
  CONST double x2[],
  int *iwt,
  double wt[],
  double res[],
  int *ifail
#endif
);

extern void g01adf(
#ifdef __STDC__
  CONST int *k,
  CONST double x[],
  CONST int ifreq[],
  double *xmean,
  double *s2,
  double *s3,
  double *s4,
  int *n,
  int *ifail
#endif
);

extern void g01aef(
#ifdef __STDC__
  CONST int *n,
  CONST int *k2,
  CONST double x[],
  CONST int *iclass,
  double cint[],
  int ifreq[],
  double *xmin,
  double *xmax,
  int *ifail
#endif
);

extern void g01aff(
#ifdef __STDC__
  CONST int *inob,
  CONST int *ipred,
  CONST int *m,
  CONST int *n,
  int nobs[] /* 2 dimension */,
  int *num,
  double pred[] /* 2 dimension */,
  double *chis,
  double p[],
  int *npos,
  int *ndf,
  int *m1,
  int *n1,
  int *ifail
#endif
);

extern void g01agf(
#ifdef __STDC__
  CONST double x[],
  double y[],
  CONST int *nobs,
  int isort[],
  CONST int *nstepx,
  CONST int *nstepy,
  int *ifail
#endif
);

extern void g01ahf(
#ifdef __STDC__
  CONST double x[],
  CONST int *nobs,
  CONST int *nstepx,
  CONST int *nstepy,
  CONST int *istand,
  int iwork[],
  double work[],
  CONST int *lwork,
  double xsort[],
  double *xbar,
  double *xstd,
  int *ifail
#endif
);

extern void g01ajf(
#ifdef __STDC__
  CONST double x[],
  CONST int *n,
  int *nstepx,
  int *nstepy,
  CONST int *itype,
  int *ispace,
  double *xmin,
  double *xmax,
  double *xstep,
  int *n1,
  int *multy,
  int *ifail
#endif
);

extern void g01alf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  int iwrk[],
  double res[],
  int *ifail
#endif
);

extern void g01arf(
#ifdef __STDC__
  CONST char range[],
  CONST char prt[],
  CONST int *n,
  CONST double y[],
  CONST int *nstepx,
  CONST int *nstepy,
  double *unit,
  char plot[] /* 2 dimension */,
  CONST int *ldp,
  int *lines,
  double sorty[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void g01asf(
#ifdef __STDC__
  CONST char prt[],
  CONST int *m,
  CONST int n[],
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *nstepx,
  CONST int *nstepy,
  char plot[] /* 2 dimension */,
  CONST int *ldp,
  double work[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern double g01baf(
#ifdef __STDC__
  CONST int *idf,
  CONST double *t,
  int *ifail
#endif
);

extern double g01bbf(
#ifdef __STDC__
  CONST int *i1,
  CONST int *i2,
  CONST double *a,
  int *ifail
#endif
);

extern double g01bcf(
#ifdef __STDC__
  CONST double *x,
  CONST int *n,
  int *ifail
#endif
);

extern double g01bdf(
#ifdef __STDC__
  CONST double *x,
  CONST double *a,
  CONST double *b,
  int *ifail
#endif
);

extern void g01bjf(
#ifdef __STDC__
  CONST int *n,
  CONST double *p,
  CONST int *k,
  double *plek,
  double *pgtk,
  double *peqk,
  int *ifail
#endif
);

extern void g01bkf(
#ifdef __STDC__
  CONST double *rlamda,
  CONST int *k,
  double *plek,
  double *pgtk,
  double *peqk,
  int *ifail
#endif
);

extern void g01blf(
#ifdef __STDC__
  CONST int *n,
  CONST int *l,
  CONST int *m,
  CONST int *k,
  double *plek,
  double *pgtk,
  double *peqk,
  int *ifail
#endif
);

extern double g01caf(
#ifdef __STDC__
  CONST double *p,
  CONST int *n,
  int *ifail
#endif
);

extern double g01cbf(
#ifdef __STDC__
  CONST double *p,
  CONST int *m,
  CONST int *n,
  int *ifail
#endif
);

extern double g01ccf(
#ifdef __STDC__
  CONST double *p,
  CONST int *n,
  int *ifail
#endif
);

extern double g01cdf(
#ifdef __STDC__
  CONST double *p,
  CONST double *a,
  CONST double *b,
  int *ifail
#endif
);

extern double g01cef(
#ifdef __STDC__
  CONST double *p,
  int *ifail
#endif
);

extern void g01daf(
#ifdef __STDC__
  CONST int *n,
  double pp[],
  CONST double *etol,
  double *errest,
  double work[],
  CONST int *iw,
  int *ifail
#endif
);

extern void g01dbf(
#ifdef __STDC__
  CONST int *n,
  double pp[],
  int *ifail
#endif
);

extern void g01dcf(
#ifdef __STDC__
  CONST int *n,
  CONST double *ex1,
  CONST double *ex2,
  CONST double *summ2,
  double vapvec[],
  int *ifail
#endif
);

extern void g01ddf(
#ifdef __STDC__
  CONST double x[],
  CONST int *n,
  CONST int *calwts,
  double a[],
  double *w,
  double *pw,
  int *ifail
#endif
);

extern void g01dhf(
#ifdef __STDC__
  CONST char scores[],
  CONST char ties[],
  CONST int *n,
  CONST double x[],
  double r[],
  int iwrk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern double g01eaf(
#ifdef __STDC__
  CONST char tail[],
  CONST double *x,
  int *ifail,
  CONST int length_1
#endif
);

extern double g01ebf(
#ifdef __STDC__
  CONST char tail[],
  CONST double *t,
  CONST double *df,
  int *ifail,
  CONST int length_1
#endif
);

extern double g01ecf(
#ifdef __STDC__
  CONST char tail[],
  CONST double *x,
  CONST double *df,
  int *ifail,
  CONST int length_1
#endif
);

extern double g01edf(
#ifdef __STDC__
  CONST char tail[],
  CONST double *f,
  CONST double *df1,
  CONST double *df2,
  int *ifail,
  CONST int length_1
#endif
);

extern void g01eef(
#ifdef __STDC__
  CONST double *x,
  CONST double *a,
  CONST double *b,
  CONST double *tol,
  double *p,
  double *q,
  double *pdf,
  int *ifail
#endif
);

extern double g01eff(
#ifdef __STDC__
  CONST char tail[],
  CONST double *g,
  CONST double *a,
  CONST double *b,
  int *ifail,
  CONST int length_1
#endif
);

extern double g01emf(
#ifdef __STDC__
  CONST double *q,
  CONST double *v,
  CONST int *ir,
  int *ifail
#endif
);

extern void g01epf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ip,
  CONST double *d,
  double *pdl,
  double *pdu,
  double work[],
  int *ifail
#endif
);

extern double g01erf(
#ifdef __STDC__
  CONST double *t,
  CONST double *vk,
  int *ifail
#endif
);

extern double g01etf(
#ifdef __STDC__
  CONST double *x
#endif
);

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

extern double g01eyf(
#ifdef __STDC__
  CONST int *n,
  CONST double *d,
  int *ifail
#endif
);

extern double g01ezf(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST double *d,
  int *ifail
#endif
);

extern double g01faf(
#ifdef __STDC__
  CONST char tail[],
  CONST double *p,
  int *ifail,
  CONST int length_1
#endif
);

extern double g01fbf(
#ifdef __STDC__
  CONST char tail[],
  CONST double *p,
  CONST double *df,
  int *ifail,
  CONST int length_1
#endif
);

extern double g01fcf(
#ifdef __STDC__
  CONST double *p,
  CONST double *df,
  int *ifail
#endif
);

extern double g01fdf(
#ifdef __STDC__
  CONST double *p,
  CONST double *df1,
  CONST double *df2,
  int *ifail
#endif
);

extern double g01fef(
#ifdef __STDC__
  CONST double *p,
  CONST double *a,
  CONST double *b,
  CONST double *tol,
  int *ifail
#endif
);

extern double g01fff(
#ifdef __STDC__
  CONST double *p,
  CONST double *a,
  CONST double *b,
  CONST double *tol,
  int *ifail
#endif
);

extern double g01fmf(
#ifdef __STDC__
  CONST double *p,
  CONST double *v,
  CONST int *ir,
  int *ifail
#endif
);

extern double g01ftf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double g01gbf(
#ifdef __STDC__
  CONST double *t,
  CONST double *df,
  CONST double *delta,
  CONST double *tol,
  CONST int *maxit,
  int *ifail
#endif
);

extern double g01gcf(
#ifdef __STDC__
  CONST double *x,
  CONST double *df,
  CONST double *rlamda,
  CONST double *tol,
  CONST int *maxit,
  int *ifail
#endif
);

extern double g01gdf(
#ifdef __STDC__
  CONST double *f,
  CONST double *df1,
  CONST double *df2,
  CONST double *rlamda,
  CONST double *tol,
  CONST int *maxit,
  int *ifail
#endif
);

extern double g01gef(
#ifdef __STDC__
  CONST double *x,
  CONST double *a,
  CONST double *b,
  CONST double *rlamda,
  CONST double *tol,
  CONST int *maxit,
  int *ifail
#endif
);

extern double g01haf(
#ifdef __STDC__
  CONST double *x,
  CONST double *y,
  CONST double *rho,
  int *ifail
#endif
);

extern double g01hbf(
#ifdef __STDC__
  CONST char tail[],
  CONST int *n,
  CONST double a[],
  CONST double b[],
  CONST double xmu[],
  CONST double sig[] /* 2 dimension */,
  CONST int *ldsig,
  CONST double *tol,
  double wk[],
  CONST int *lwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g01jcf(
#ifdef __STDC__
  CONST double a[],
  CONST int mult[],
  CONST double rlamda[],
  CONST int *n,
  CONST double *c,
  double *p,
  double *pdf,
  CONST double *tol,
  CONST int *maxit,
  double wrk[],
  int *ifail
#endif
);

extern void g01jdf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST double rlam[],
  CONST double *d,
  CONST double *c,
  double *prob,
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern double g01mbf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double g01mtf(
#ifdef __STDC__
  CONST double *x
#endif
);

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

extern void g01naf(
#ifdef __STDC__
  CONST char mom[],
  CONST char mean[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double emu[],
  CONST double sigma[] /* 2 dimension */,
  CONST int *ldsig,
  CONST int *l,
  double rkum[],
  double rmom[],
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g01nbf(
#ifdef __STDC__
  CONST char case1[],
  CONST char mean[],
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double b[] /* 2 dimension */,
  CONST int *ldb,
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST double ela[],
  CONST double emu[],
  CONST double sigma[] /* 2 dimension */,
  CONST int *ldsig,
  CONST int *l1,
  CONST int *l2,
  int *lmax,
  double rmom[],
  double *abserr,
  CONST double *eps,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern double g01ptf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double g01qtf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double g01rtf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern void g01zuf(
#ifdef __STDC__
  CONST double *rkappa,
  CONST double *beta2,
  CONST int *mode,
  double *xl,
  double *xu,
  double work[],
  int *ifail
#endif
);

extern void g02baf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  double xbar[],
  double std[],
  double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  int *ifail
#endif
);

extern void g02bbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  int miss[],
  double xmiss[],
  double xbar[],
  double std[],
  double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  int *ncases,
  int *ifail
#endif
);

extern void g02bcf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int miss[],
  CONST double xmiss[],
  double xbar[],
  double std[],
  double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  int *ncases,
  double count[] /* 2 dimension */,
  CONST int *ic,
  int *ifail
#endif
);

extern void g02bdf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  double xbar[],
  double std[],
  double sspz[] /* 2 dimension */,
  CONST int *isspz,
  double rz[] /* 2 dimension */,
  CONST int *irz,
  int *ifail
#endif
);

extern void g02bef(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  int miss[],
  double xmiss[],
  double xbar[],
  double std[],
  double sspz[] /* 2 dimension */,
  CONST int *isspz,
  double rz[] /* 2 dimension */,
  CONST int *irz,
  int *ncases,
  int *ifail
#endif
);

extern void g02bff(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int miss[],
  CONST double xmiss[],
  double xbar[],
  double std[],
  double sspz[] /* 2 dimension */,
  CONST int *isspz,
  double rz[] /* 2 dimension */,
  CONST int *irz,
  int *ncases,
  double count[] /* 2 dimension */,
  CONST int *ic,
  int *ifail
#endif
);

extern void g02bgf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int *nvars,
  CONST int kvar[],
  double xbar[],
  double std[],
  double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  int *ifail
#endif
);

extern void g02bhf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  int miss[],
  double xmiss[],
  CONST int *mistyp,
  CONST int *nvars,
  CONST int kvar[],
  double xbar[],
  double std[],
  double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  int *ncases,
  int *ifail
#endif
);

extern void g02bjf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int miss[],
  CONST double xmiss[],
  CONST int *nvars,
  CONST int kvar[],
  double xbar[],
  double std[],
  double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  int *ncases,
  double count[] /* 2 dimension */,
  CONST int *ic,
  int *ifail
#endif
);

extern void g02bkf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int *nvars,
  CONST int kvar[],
  double xbar[],
  double std[],
  double sspz[] /* 2 dimension */,
  CONST int *isspz,
  double rz[] /* 2 dimension */,
  CONST int *irz,
  int *ifail
#endif
);

extern void g02blf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  int miss[],
  double xmiss[],
  CONST int *mistyp,
  CONST int *nvars,
  CONST int kvar[],
  double xbar[],
  double std[],
  double sspz[] /* 2 dimension */,
  CONST int *isspz,
  double rz[] /* 2 dimension */,
  CONST int *irz,
  int *ncases,
  int *ifail
#endif
);

extern void g02bmf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int miss[],
  CONST double xmiss[],
  CONST int *nvars,
  CONST int kvar[],
  double xbar[],
  double std[],
  double sspz[] /* 2 dimension */,
  CONST int *isspz,
  double rz[] /* 2 dimension */,
  CONST int *irz,
  int *ncases,
  double count[] /* 2 dimension */,
  CONST int *ic,
  int *ifail
#endif
);

extern void g02bnf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int *itype,
  double rr[] /* 2 dimension */,
  CONST int *irr,
  int kworka[],
  int kworkb[],
  double work1[],
  double work2[],
  int *ifail
#endif
);

extern void g02bpf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  double x[] /* 2 dimension */,
  CONST int *ix,
  int miss[],
  double xmiss[],
  CONST int *itype,
  double rr[] /* 2 dimension */,
  CONST int *irr,
  int *ncases,
  int incase[],
  int kworka[],
  int kworkb[],
  int kworkc[],
  double work1[],
  double work2[],
  int *ifail
#endif
);

extern void g02bqf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int *itype,
  double rr[] /* 2 dimension */,
  CONST int *irr,
  int kworka[],
  int kworkb[],
  double work1[],
  double work2[],
  int *ifail
#endif
);

extern void g02brf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  int miss[],
  double xmiss[],
  CONST int *itype,
  double rr[] /* 2 dimension */,
  CONST int *irr,
  int *ncases,
  int incase[],
  int kworka[],
  int kworkb[],
  int kworkc[],
  double work1[],
  double work2[],
  int *ifail
#endif
);

extern void g02bsf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int miss[],
  CONST double xmiss[],
  CONST int *itype,
  double rr[] /* 2 dimension */,
  CONST int *irr,
  int *ncases,
  double count[] /* 2 dimension */,
  CONST int *ic,
  int kworka[],
  int kworkb[],
  int kworkc[],
  int kworkd[],
  double work1[],
  double work2[],
  int *ifail
#endif
);

extern void g02btf(
#ifdef __STDC__
  CONST char mean[],
  CONST int *m,
  CONST double *wt,
  CONST double x[],
  CONST int *incx,
  double *sw,
  double xbar[],
  double c[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g02buf(
#ifdef __STDC__
  CONST char mean[],
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST double wt[],
  double *sw,
  double wmean[],
  double c[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g02bwf(
#ifdef __STDC__
  CONST int *m,
  double r[],
  int *ifail
#endif
);

extern void g02bxf(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST double wt[],
  double xbar[],
  double std[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double r[] /* 2 dimension */,
  int *ifail,
  CONST int length_1
#endif
);

extern void g02byf(
#ifdef __STDC__
  CONST int *m,
  CONST int *ny,
  CONST int *nx,
  CONST int isz[],
  CONST double r[] /* 2 dimension */,
  CONST int *ldr,
  double p[] /* 2 dimension */,
  CONST int *ldp,
  double wk[],
  int *ifail
#endif
);

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

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

extern void g02ccf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double y[],
  CONST double *xmiss,
  CONST double *ymiss,
  double result[],
  int *ifail
#endif
);

extern void g02cdf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double y[],
  CONST double *xmiss,
  CONST double *ymiss,
  double result[],
  int *ifail
#endif
);

extern void g02cef(
#ifdef __STDC__
  CONST int *nvars,
  CONST double xbar[],
  CONST double std[],
  CONST double ssp[] /* 2 dimension */,
  CONST int *issp,
  CONST double r[] /* 2 dimension */,
  CONST int *ir,
  CONST int *nvars2,
  CONST int korder[],
  double xbar2[],
  double std2[],
  double ssp2[] /* 2 dimension */,
  CONST int *issp2,
  double r2[] /* 2 dimension */,
  CONST int *ir2,
  int *ifail
#endif
);

extern void g02cff(
#ifdef __STDC__
  CONST int *nvars,
  CONST int korder[],
  double xbar[],
  double std[],
  double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  int kwork[],
  int *ifail
#endif
);

extern void g02cgf(
#ifdef __STDC__
  CONST int *ncases,
  CONST int *nvars,
  CONST int *nind,
  CONST double xbar[],
  CONST double ssp[] /* 2 dimension */,
  CONST int *issp,
  double r[] /* 2 dimension */,
  CONST int *ir,
  double result[],
  double coeff[] /* 2 dimension */,
  CONST int *icoeff,
  double _const[],
  double rinv[] /* 2 dimension */,
  CONST int *irinv,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double wkz[] /* 2 dimension */,
  CONST int *iwkz,
  int *ifail
#endif
);

extern void g02chf(
#ifdef __STDC__
  CONST int *ncases,
  CONST int *nvars,
  CONST int *nind,
  CONST double sspz[] /* 2 dimension */,
  CONST int *isspz,
  double rz[] /* 2 dimension */,
  CONST int *irz,
  double result[],
  double coeff[] /* 2 dimension */,
  CONST int *icoeff,
  double rzinv[] /* 2 dimension */,
  CONST int *irzinv,
  double cz[] /* 2 dimension */,
  CONST int *icz,
  double wkz[] /* 2 dimension */,
  CONST int *iwkz,
  int *ifail
#endif
);

extern void g02cjf(
#ifdef __STDC__
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST double y[] /* 2 dimension */,
  CONST int *iy,
  CONST int *n,
  CONST int *m,
  CONST int *ir,
  double theta[] /* 2 dimension */,
  CONST int *it,
  double sigsq[],
  double c[] /* 2 dimension */,
  CONST int *ic,
  int ipiv[],
  double wk1[] /* 2 dimension */,
  double wk2[],
  int *ifail
#endif
);

extern void g02daf(
#ifdef __STDC__
  CONST char mean[],
  CONST char weight[],
  CONST int *n,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *m,
  CONST int isx[],
  CONST int *ip,
  CONST double y[],
  CONST double wt[],
  double *rss,
  int *idf,
  double b[],
  double se[],
  double cov[],
  double res[],
  double h[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  int *svd,
  int *irank,
  double p[],
  CONST double *tol,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g02dcf(
#ifdef __STDC__
  CONST char update[],
  CONST char mean[],
  CONST char weight[],
  CONST int *m,
  CONST int isx[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  CONST int *ip,
  CONST double x[],
  CONST int *ix,
  CONST double *y,
  CONST double *wt,
  double *rss,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void g02ddf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ip,
  CONST double q[] /* 2 dimension */,
  CONST int *ldq,
  double *rss,
  int *idf,
  double b[],
  double se[],
  double cov[],
  int *svd,
  int *irank,
  double p[],
  CONST double *tol,
  double wk[],
  int *ifail
#endif
);

extern void g02def(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST int *ip,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double p[],
  CONST double wt[],
  CONST double x[],
  double *rss,
  CONST double *tol,
  int *ifail,
  CONST int length_1
#endif
);

extern void g02dff(
#ifdef __STDC__
  CONST int *ip,
  double q[] /* 2 dimension */,
  CONST int *ldq,
  CONST int *indx,
  double *rss,
  double wk[],
  int *ifail
#endif
);

extern void g02dgf(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST double wt[],
  double *rss,
  CONST int *ip,
  CONST int *irank,
  double cov[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  CONST int *svd,
  CONST double p[],
  CONST double y[],
  double b[],
  double se[],
  double res[],
  CONST double wk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g02dkf(
#ifdef __STDC__
  CONST int *ip,
  CONST int *iconst,
  CONST double p[],
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  double b[],
  CONST double *rss,
  CONST int *idf,
  double se[],
  double cov[],
  double wk[],
  int *ifail
#endif
);

extern void g02dnf(
#ifdef __STDC__
  CONST int *ip,
  CONST int *irank,
  CONST double b[],
  CONST double cov[],
  CONST double p[],
  CONST double f[],
  int *est,
  double *stat,
  double *sestat,
  double *t,
  CONST double *tol,
  double wk[],
  int *ifail
#endif
);

extern void g02eaf(
#ifdef __STDC__
  CONST char mean[],
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST char name[],
  CONST int isx[],
  CONST double y[],
  CONST double wt[],
  int *nmod,
  char model[] /* 2 dimension */,
  CONST int *ldm,
  double rss[],
  int nterms[],
  int mrank[],
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void g02ecf(
#ifdef __STDC__
  CONST char mean[],
  CONST int *n,
  CONST double *sigsq,
  CONST double *tss,
  CONST int *nmod,
  CONST int nterms[],
  CONST double rss[],
  double rsq[],
  double cp[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g02eef(
#ifdef __STDC__
  int *istep,
  CONST char mean[],
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST char name[],
  CONST int isx[],
  CONST int *maxip,
  CONST double y[],
  CONST double wt[],
  CONST double *fin,
  int *addvar,
  char newvar[],
  double *chrss,
  double *f,
  char model[],
  int *nterm,
  double *rss,
  int *idf,
  int *ifr,
  char free[],
  double exss[],
  double q[] /* 2 dimension */,
  CONST int *ldq,
  double p[],
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6
#endif
);

extern void g02eff(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST double wmean[],
  CONST double c[],
  CONST double *sw,
  int model[],
  CONST double *fin,
  CONST double *fout,
  CONST double *tau,
  double b[],
  double se[],
  double *rsq,
  double *rms,
  int *df,
  CONST int *monlev,
  void (*monfun)(char [], int *, double *, int[], double[],int length_1),
  int iuser[],
  double ruser[],
  int *ifail
#endif
);

extern void g02faf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ip,
  CONST int *nres,
  CONST double res[],
  CONST double h[],
  CONST double *rms,
  double sres[] /* 2 dimension */,
  CONST int *lds,
  int *ifail
#endif
);

extern void g02fcf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ip,
  CONST double res[],
  double *d,
  double *pdl,
  double *pdu,
  double work[],
  int *ifail
#endif
);

extern void g02gaf(
#ifdef __STDC__
  CONST char link[],
  CONST char mean[],
  CONST char offset[],
  CONST char weight[],
  CONST int *n,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *m,
  CONST int isx[],
  CONST int *ip,
  CONST double y[],
  CONST double wt[],
  double *s,
  double *a,
  double *rss,
  int *idf,
  double b[],
  int *irank,
  double se[],
  double cov[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  CONST double *tol,
  CONST int *maxit,
  CONST int *iprint,
  CONST double *eps,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void g02gbf(
#ifdef __STDC__
  CONST char link[],
  CONST char mean[],
  CONST char offset[],
  CONST char weight[],
  CONST int *n,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *m,
  CONST int isx[],
  CONST int *ip,
  CONST double y[],
  double t[],
  CONST double wt[],
  double *dev,
  int *idf,
  double b[],
  int *irank,
  double se[],
  double cov[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  CONST double *tol,
  CONST int *maxit,
  CONST int *iprint,
  CONST double *eps,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void g02gcf(
#ifdef __STDC__
  CONST char link[],
  CONST char mean[],
  CONST char offset[],
  CONST char weight[],
  CONST int *n,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *m,
  CONST int isx[],
  CONST int *ip,
  CONST double y[],
  CONST double wt[],
  double *a,
  double *dev,
  int *idf,
  double b[],
  int *irank,
  double se[],
  double cov[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  CONST double *tol,
  CONST int *maxit,
  CONST int *iprint,
  CONST double *eps,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void g02gdf(
#ifdef __STDC__
  CONST char link[],
  CONST char mean[],
  CONST char offset[],
  CONST char weight[],
  CONST int *n,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *m,
  CONST int isx[],
  CONST int *ip,
  CONST double y[],
  CONST double wt[],
  double *s,
  double *a,
  double *dev,
  int *idf,
  double b[],
  int *irank,
  double se[],
  double cov[],
  double v[] /* 2 dimension */,
  CONST int *ldv,
  CONST double *tol,
  CONST int *maxit,
  CONST int *iprint,
  CONST double *eps,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4
#endif
);

extern void g02gkf(
#ifdef __STDC__
  CONST int *ip,
  CONST int *iconst,
  CONST double v[] /* 2 dimension */,
  CONST int *ldv,
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  double b[],
  CONST double *s,
  double se[],
  double cov[],
  double wk[],
  int *ifail
#endif
);

extern void g02gnf(
#ifdef __STDC__
  CONST int *ip,
  CONST int *irank,
  CONST double b[],
  CONST double cov[],
  CONST double v[] /* 2 dimension */,
  CONST int *ldv,
  CONST double f[],
  int *est,
  double *stat,
  double *sestat,
  double *z,
  CONST double *tol,
  double wk[],
  int *ifail
#endif
);

extern void g02haf(
#ifdef __STDC__
  CONST int *indw,
  CONST int *ipsi,
  CONST int *isigma,
  CONST int *indc,
  CONST int *n,
  CONST int *m,
  double x[] /* 2 dimension */,
  CONST int *ix,
  double y[],
  CONST double *cpsi,
  CONST double *h1,
  CONST double *h2,
  CONST double *h3,
  CONST double *cucv,
  CONST double *dchi,
  double theta[],
  double *sigma,
  double c[] /* 2 dimension */,
  CONST int *ic,
  double rs[],
  double wgt[],
  CONST double *tol,
  CONST int *maxit,
  CONST int *nitmon,
  double work[],
  int *ifail
#endif
);

extern void g02hbf(
#ifdef __STDC__
  double (*ucv)(double *),
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  double a[],
  double z[],
  CONST double *bl,
  CONST double *bd,
  CONST double *tol,
  CONST int *maxit,
  CONST int *nitmon,
  int *nit,
  double wk[],
  int *ifail
#endif
);

extern void g02hdf(
#ifdef __STDC__
  double (*chi)(double *),
  double (*psi)(double *),
  CONST double *psip0,
  CONST double *beta,
  CONST int *indw,
  CONST int *isigma,
  CONST int *n,
  CONST int *m,
  double x[] /* 2 dimension */,
  CONST int *ix,
  double y[],
  double wgt[],
  double theta[],
  int *k,
  double *sigma,
  double rs[],
  CONST double *tol,
  CONST double *eps,
  CONST int *maxit,
  CONST int *nitmon,
  int *nit,
  double wk[],
  int *ifail
#endif
);

extern double g02hdz(
#ifdef __STDC__
  double *t
#endif
);

extern void g02hff(
#ifdef __STDC__
  double (*psi)(double *),
  double (*psp)(double *),
  CONST int *indw,
  CONST int *indc,
  CONST double *sigma,
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST double rs[],
  CONST double wgt[],
  double c[] /* 2 dimension */,
  CONST int *ic,
  double wk[],
  int *ifail
#endif
);

extern void g02hkf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST double *eps,
  double cov[],
  double theta[],
  CONST int *maxit,
  CONST int *nitmon,
  CONST double *tol,
  int *nit,
  double wk[],
  int *ifail
#endif
);

extern void g02hlf(
#ifdef __STDC__
  void (*ucv)(double *, double[], double *, double *, double *, double *),
  CONST double userp[],
  CONST int *indm,
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double cov[],
  double a[],
  double wt[],
  double theta[],
  CONST double *bl,
  CONST double *bd,
  CONST int *maxit,
  CONST int *nitmon,
  CONST double *tol,
  int *nit,
  double wk[],
  int *ifail
#endif
);

extern void g02hmf(
#ifdef __STDC__
  void (*ucv)(double *, double[], double *, double *),
  CONST double userp[],
  CONST int *indm,
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double cov[],
  double a[],
  double wt[],
  double theta[],
  CONST double *bl,
  CONST double *bd,
  CONST int *maxit,
  CONST int *nitmon,
  CONST double *tol,
  int *nit,
  double wk[],
  int *ifail
#endif
);

extern void g02jaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ncol,
  CONST int *lddat,
  CONST double dat[] /* 2 dimension */,
  CONST int levels[],
  CONST int *yvid,
  CONST int *cwid,
  CONST int *nfv,
  CONST int fvid[],
  CONST int *fint,
  CONST int *nrv,
  CONST int rvid[],
  CONST int *nvpr,
  CONST int vpr[],
  CONST int *rint,
  CONST int *svid,
  double gamma[],
  int *nff,
  int *nrf,
  int *df,
  double *reml,
  int *lb,
  double b[],
  double se[],
  CONST int *maxit,
  CONST double *tol,
  int *warn,
  int *ifail
#endif
);

extern void g02jbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ncol,
  CONST int *lddat,
  CONST double dat[] /* 2 dimension */,
  CONST int levels[],
  CONST int *yvid,
  CONST int *cwid,
  CONST int *nfv,
  CONST int fvid[],
  CONST int *fint,
  CONST int *nrv,
  CONST int rvid[],
  CONST int *nvpr,
  CONST int vpr[],
  CONST int *rint,
  CONST int *svid,
  double gamma[],
  int *nff,
  int *nrf,
  int *df,
  double *ml,
  int *lb,
  double b[],
  double se[],
  CONST int *maxit,
  CONST double *tol,
  int *warn,
  int *ifail
#endif
);

extern void g03aaf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char std[],
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int isx[],
  double s[],
  CONST double wt[],
  CONST int *nvar,
  double e[] /* 2 dimension */,
  CONST int *lde,
  double p[] /* 2 dimension */,
  CONST int *ldp,
  double v[] /* 2 dimension */,
  CONST int *ldv,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void g03acf(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int isx[],
  CONST int *nx,
  CONST int ing[],
  CONST int *ng,
  CONST double wt[],
  int nig[],
  double cvm[] /* 2 dimension */,
  CONST int *ldcvm,
  double e[] /* 2 dimension */,
  CONST int *lde,
  int *ncv,
  double cvx[] /* 2 dimension */,
  CONST int *ldcvx,
  CONST double *tol,
  int *irankx,
  double wk[],
  CONST int *iwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g03adf(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double z[] /* 2 dimension */,
  CONST int *ldz,
  CONST int isz[],
  int *nx,
  int *ny,
  CONST double wt[],
  double e[] /* 2 dimension */,
  CONST int *lde,
  int *ncv,
  double cvx[] /* 2 dimension */,
  CONST int *ldcvx,
  CONST int *mcv,
  double cvy[] /* 2 dimension */,
  CONST int *ldcvy,
  CONST double *tol,
  double wk[],
  CONST int *iwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g03baf(
#ifdef __STDC__
  CONST char stand[],
  CONST double *g,
  CONST int *nvar,
  CONST int *k,
  double fl[] /* 2 dimension */,
  CONST int *ldf,
  double flr[] /* 2 dimension */,
  double r[] /* 2 dimension */,
  CONST int *ldr,
  CONST double *acc,
  CONST int *maxit,
  int *iter,
  double wk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g03bcf(
#ifdef __STDC__
  CONST char stand[],
  CONST char pscale[],
  CONST int *n,
  CONST int *m,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double y[] /* 2 dimension */,
  CONST int *ldy,
  double yhat[] /* 2 dimension */,
  double r[] /* 2 dimension */,
  CONST int *ldr,
  double *alpha,
  double *rss,
  double res[],
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g03caf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *nvar,
  CONST int isx[],
  CONST int *nfac,
  CONST double wt[],
  double e[],
  double stat[],
  double com[],
  double psi[],
  double res[],
  double fl[] /* 2 dimension */,
  CONST int *ldfl,
  CONST int iop[],
  int iwk[],
  double wk[],
  CONST int *lwk,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g03ccf(
#ifdef __STDC__
  CONST char method[],
  CONST char rotate[],
  CONST int *nvar,
  CONST int *nfac,
  CONST double fl[] /* 2 dimension */,
  CONST int *ldfl,
  CONST double psi[],
  CONST double e[],
  CONST double r[] /* 2 dimension */,
  CONST int *ldr,
  double fs[] /* 2 dimension */,
  CONST int *ldfs,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g03daf(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int isx[],
  CONST int *nvar,
  CONST int ing[],
  CONST int *ng,
  CONST double wt[],
  int nig[],
  double gmean[] /* 2 dimension */,
  CONST int *ldg,
  double det[],
  double gc[],
  double *stat,
  double *df,
  double *sig,
  double wk[],
  int iwk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g03dbf(
#ifdef __STDC__
  CONST char equal[],
  CONST char mode[],
  CONST int *nvar,
  CONST int *ng,
  CONST double gmean[] /* 2 dimension */,
  CONST int *ldg,
  CONST double gc[],
  CONST int *nobs,
  CONST int *m,
  CONST int isx[],
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double d[] /* 2 dimension */,
  CONST int *ldd,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g03dcf(
#ifdef __STDC__
  CONST char type[],
  CONST char equal[],
  CONST char priors[],
  CONST int *nvar,
  CONST int *ng,
  CONST int nig[],
  CONST double gmean[] /* 2 dimension */,
  CONST int *ldg,
  CONST double gc[],
  CONST double det[],
  CONST int *nobs,
  CONST int *m,
  CONST int isx[],
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double prior[],
  double p[] /* 2 dimension */,
  CONST int *ldp,
  int iag[],
  CONST int *atiq,
  double ati[] /* 2 dimension */,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void g03eaf(
#ifdef __STDC__
  CONST char update[],
  CONST char dist[],
  CONST char scale[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int isx[],
  double s[],
  double d[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void g03ecf(
#ifdef __STDC__
  CONST int *method,
  CONST int *n,
  double d[],
  int ilc[],
  int iuc[],
  double cd[],
  int iord[],
  double dord[],
  int iwk[],
  int *ifail
#endif
);

extern void g03eff(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int isx[],
  CONST int *nvar,
  CONST int *k,
  double cmeans[] /* 2 dimension */,
  CONST int *ldc,
  CONST double wt[],
  int inc[],
  int nic[],
  double css[],
  double csw[],
  CONST int *maxit,
  int iwk[],
  double wk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g03ehf(
#ifdef __STDC__
  CONST char orient[],
  CONST int *n,
  CONST double dord[],
  CONST double *dmin,
  CONST double *dstep,
  CONST int *nsym,
  char c[],
  CONST int *lenc,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g03ejf(
#ifdef __STDC__
  CONST int *n,
  CONST double cd[],
  CONST int iord[],
  CONST double dord[],
  int *k,
  double *dlevel,
  int ic[],
  int *ifail
#endif
);

extern void g03faf(
#ifdef __STDC__
  CONST char roots[],
  CONST int *n,
  CONST double d[],
  CONST int *ndim,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double eval[],
  double wk[],
  int iwk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g03fcf(
#ifdef __STDC__
  CONST char type[],
  CONST int *n,
  CONST int *ndim,
  CONST double d[],
  double x[] /* 2 dimension */,
  CONST int *ldx,
  double *stress,
  double dfit[],
  CONST int *iter,
  CONST int *iopt,
  double wk[],
  int iwk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g03zaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *nvar,
  CONST int isx[],
  CONST double s[],
  CONST double e[],
  double z[] /* 2 dimension */,
  CONST int *ldz,
  int *ifail
#endif
);

extern void g04adf(
#ifdef __STDC__
  CONST double data[],
  double var[],
  double amr[],
  double amc[],
  double amt[],
  CONST int lcode[] /* 2 dimension */,
  CONST int *ia,
  CONST int *n,
  CONST int *nn
#endif
);

extern void g04aef(
#ifdef __STDC__
  CONST double y[],
  CONST int *n,
  CONST int *k,
  CONST int nobs[],
  double gbar[],
  double *gm,
  double ss[],
  int idf[],
  double *f,
  double *fp,
  int *ifail
#endif
);

extern void g04aff(
#ifdef __STDC__
  CONST double y[] /* 3 dimension */,
  CONST int *iy1,
  CONST int *iy2,
  CONST int *m,
  CONST int *nr,
  CONST int *nc,
  double row[],
  double col[],
  double cell[] /* 2 dimension */,
  CONST int *icell,
  double *gm,
  double ss[],
  int idf[],
  double f[],
  double fp[],
  int *ifail
#endif
);

extern void g04agf(
#ifdef __STDC__
  CONST double y[],
  CONST int *n,
  CONST int *k,
  CONST int lsub[],
  CONST int nobs[],
  CONST int *l,
  int ngp[],
  double gbar[],
  double sgbar[],
  double *gm,
  double ss[],
  int idf[],
  double f[],
  double fp[],
  int *ifail
#endif
);

extern void g04bbf(
#ifdef __STDC__
  CONST int *n,
  CONST double y[],
  CONST int *iblock,
  CONST int *nt,
  CONST int it[],
  double *gmean,
  double bmean[],
  double tmean[],
  double table[] /* 2 dimension */,
  CONST int *ldt,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  int irep[],
  double r[],
  double ef[],
  CONST double *tol,
  CONST int *irdf,
  double wk[],
  int *ifail
#endif
);

extern void g04bcf(
#ifdef __STDC__
  CONST int *nrep,
  CONST int *nrow,
  CONST int *ncol,
  CONST double y[],
  CONST int *nt,
  CONST int it[],
  double *gmean,
  double tmean[],
  double table[] /* 2 dimension */,
  CONST int *ldt,
  double c[] /* 2 dimension */,
  CONST int *ldc,
  int irep[],
  double rpmean[],
  double rmean[],
  double cmean[],
  double r[],
  double ef[],
  CONST double *tol,
  CONST int *irdf,
  double wk[],
  int *ifail
#endif
);

extern void g04caf(
#ifdef __STDC__
  CONST int *n,
  CONST double y[],
  CONST int *nfac,
  CONST int lfac[],
  CONST int *nblock,
  CONST int *inter,
  CONST int *irdf,
  CONST int *mterm,
  double table[] /* 2 dimension */,
  int *itotal,
  double tmean[],
  CONST int *maxt,
  double e[],
  int imean[],
  double semean[],
  double bmean[],
  double r[],
  int iwk[],
  int *ifail
#endif
);

extern void g04daf(
#ifdef __STDC__
  CONST int *nt,
  CONST double tmean[],
  CONST int irep[],
  CONST double *rms,
  CONST double *rdf,
  CONST int *nc,
  CONST double ct[] /* 2 dimension */,
  CONST int *ldct,
  double est[],
  double table[] /* 2 dimension */,
  CONST int *ldt,
  CONST double *tol,
  CONST int *usetx,
  CONST double tx[],
  int *ifail
#endif
);

extern void g04dbf(
#ifdef __STDC__
  CONST char type[],
  CONST int *nt,
  CONST double tmean[],
  CONST double *rdf,
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST double *clevel,
  double cil[],
  double ciu[],
  int isig[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g04eaf(
#ifdef __STDC__
  CONST char type[],
  CONST int *n,
  CONST int *levels,
  CONST int ifact[],
  double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST double v[],
  double rep[],
  int *ifail,
  CONST int length_1
#endif
);

extern double g05caf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern void g05cbf(
#ifdef __STDC__
  CONST int *i
#endif
);

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

extern void g05cff(
#ifdef __STDC__
  int ia[],
  CONST int *ni,
  double xa[],
  CONST int *nx,
  int *ifail
#endif
);

extern void g05cgf(
#ifdef __STDC__
  CONST int ia[],
  CONST int *ni,
  CONST double xa[],
  CONST int *nx,
  int *ifail
#endif
);

extern double g05daf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b
#endif
);

extern double g05dbf(
#ifdef __STDC__
  CONST double *a
#endif
);

extern double g05dcf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b
#endif
);

extern double g05ddf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b
#endif
);

extern double g05def(
#ifdef __STDC__
  CONST double *a,
  CONST double *b
#endif
);

extern double g05dff(
#ifdef __STDC__
  CONST double *a,
  CONST double *b
#endif
);

extern double g05dgf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  int *ifail
#endif
);

extern double g05dhf(
#ifdef __STDC__
  CONST int *n,
  int *ifail
#endif
);

extern double g05djf(
#ifdef __STDC__
  CONST int *n,
  int *ifail
#endif
);

extern double g05dkf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  int *ifail
#endif
);

extern double g05dlf(
#ifdef __STDC__
  CONST double *g,
  CONST double *h,
  int *ifail
#endif
);

extern double g05dmf(
#ifdef __STDC__
  CONST double *g,
  CONST double *h,
  int *ifail
#endif
);

extern double g05dpf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  int *ifail
#endif
);

extern int g05drf(
#ifdef __STDC__
  CONST double *alamda,
  int *ifail
#endif
);

extern int g05dyf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n
#endif
);

extern int g05dzf(
#ifdef __STDC__
  CONST double *p
#endif
);

extern void g05eaf(
#ifdef __STDC__
  CONST double a[],
  CONST int *n,
  CONST double c[] /* 2 dimension */,
  CONST int *ic,
  CONST double *eps,
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05ebf(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05ecf(
#ifdef __STDC__
  CONST double *t,
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05edf(
#ifdef __STDC__
  CONST int *n,
  CONST double *p,
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05eef(
#ifdef __STDC__
  CONST int *n,
  CONST double *p,
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05eff(
#ifdef __STDC__
  CONST int *l,
  CONST int *m,
  CONST int *n,
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05egf(
#ifdef __STDC__
  CONST double *e,
  CONST double a[],
  CONST int *na,
  CONST double b[],
  CONST int *nb,
  double r[],
  CONST int *nr,
  double *var,
  int *ifail
#endif
);

extern void g05ehf(
#ifdef __STDC__
  int index[],
  CONST int *n,
  int *ifail
#endif
);

extern void g05ejf(
#ifdef __STDC__
  CONST int ia[],
  CONST int *n,
  int iz[],
  CONST int *m,
  int *ifail
#endif
);

extern double g05ewf(
#ifdef __STDC__
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05exf(
#ifdef __STDC__
  CONST double p[],
  CONST int *np,
  CONST int *ip,
  CONST int *lp,
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern int g05eyf(
#ifdef __STDC__
  CONST double r[],
  CONST int *nr
#endif
);

extern void g05ezf(
#ifdef __STDC__
  double z[],
  CONST int *n,
  CONST double r[],
  CONST int *nr,
  int *ifail
#endif
);

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

extern void g05fbf(
#ifdef __STDC__
  CONST double *a,
  CONST int *n,
  double x[]
#endif
);

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

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

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

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

extern void g05gaf(
#ifdef __STDC__
  CONST char side[],
  CONST char init[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g05gbf(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST double *eps,
  double wk[],
  int *ifail
#endif
);

extern void g05hdf(
#ifdef __STDC__
  CONST char mode[],
  CONST int *k,
  CONST int *ip,
  CONST int *iq,
  CONST char mean[],
  CONST double par[],
  CONST int *lpar,
  double qq[] /* 2 dimension */,
  CONST int *ik,
  CONST int *n,
  double w[] /* 2 dimension */,
  double ref[],
  CONST int *lref,
  int iwork[],
  CONST int *liwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g05hkf(
#ifdef __STDC__
  CONST char dist[],
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST double param[],
  CONST double *gamma,
  CONST double *df,
  double ht[],
  double yt[],
  CONST int *fcall,
  double rvec[],
  CONST int *igen,
  int iseed[],
  double rwsav[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g05hlf(
#ifdef __STDC__
  CONST char dist[],
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST double param[],
  CONST double *gamma,
  CONST double *df,
  double ht[],
  double yt[],
  CONST int *fcall,
  double rvec[],
  CONST int *igen,
  int iseed[],
  double rwsav[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g05hmf(
#ifdef __STDC__
  CONST char dist[],
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST double param[],
  CONST double *gamma,
  CONST double *df,
  double ht[],
  double yt[],
  CONST int *fcall,
  double rvec[],
  CONST int *igen,
  int iseed[],
  double rwsav[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g05hnf(
#ifdef __STDC__
  CONST char dist[],
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST double param[],
  CONST double *df,
  double ht[],
  double yt[],
  CONST int *fcall,
  double rvec[],
  CONST int *igen,
  int iseed[],
  double rwsav[],
  int *ifail,
  CONST int length_1
#endif
);

extern double g05kaf(
#ifdef __STDC__
  CONST int *igen,
  int iseed[]
#endif
);

extern void g05kbf(
#ifdef __STDC__
  int *igen,
  int iseed[]
#endif
);

extern void g05kcf(
#ifdef __STDC__
  int *igen,
  int iseed[]
#endif
);

extern int g05kef(
#ifdef __STDC__
  CONST double *p,
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05laf(
#ifdef __STDC__
  CONST double *xmu,
  CONST double *var,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lbf(
#ifdef __STDC__
  CONST int *df,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lcf(
#ifdef __STDC__
  CONST int *df,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05ldf(
#ifdef __STDC__
  CONST int *df1,
  CONST int *df2,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lef(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lff(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lgf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lhf(
#ifdef __STDC__
  CONST double *xmin,
  CONST double *xmax,
  CONST double *xmean,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05ljf(
#ifdef __STDC__
  CONST double *a,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lkf(
#ifdef __STDC__
  CONST double *xmu,
  CONST double *var,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05llf(
#ifdef __STDC__
  CONST double *xmed,
  CONST double *semiqr,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lmf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lnf(
#ifdef __STDC__
  CONST double *a,
  CONST double *b,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lpf(
#ifdef __STDC__
  CONST double *vk,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lqf(
#ifdef __STDC__
  CONST int *nmix,
  CONST double a[],
  double wgt[],
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05lxf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *df,
  CONST int *m,
  CONST double xmu[],
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *lr,
  int *ifail
#endif
);

extern void g05lyf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *m,
  CONST double xmu[],
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *lr,
  int *ifail
#endif
);

extern void g05lzf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *n,
  CONST double xmu[],
  CONST double c[] /* 2 dimension */,
  CONST int *ic,
  double x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05maf(
#ifdef __STDC__
  CONST int *a,
  CONST int *b,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05mbf(
#ifdef __STDC__
  CONST int *mode,
  CONST double *p,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05mcf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *m,
  CONST double *p,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05mdf(
#ifdef __STDC__
  CONST int *mode,
  CONST double *a,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05mef(
#ifdef __STDC__
  CONST int *m,
  CONST double vlamda[],
  int x[],
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05mjf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *m,
  CONST double *p,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05mkf(
#ifdef __STDC__
  CONST int *mode,
  CONST double *lambda,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05mlf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *ns,
  CONST int *np,
  CONST int *m,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05mrf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *m,
  CONST int *k,
  CONST double p[],
  CONST int *n,
  int x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05mzf(
#ifdef __STDC__
  CONST int *mode,
  CONST double p[],
  CONST int *np,
  CONST int *ip1,
  CONST int *itype,
  CONST int *n,
  int x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05naf(
#ifdef __STDC__
  int index[],
  CONST int *n,
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05nbf(
#ifdef __STDC__
  CONST int ipop[],
  CONST int *n,
  int isampl[],
  CONST int *m,
  CONST int *igen,
  int iseed[],
  int *ifail
#endif
);

extern void g05paf(
#ifdef __STDC__
  CONST int *mode,
  CONST double *xmean,
  CONST int *ip,
  CONST double phi[],
  CONST int *iq,
  CONST double theta[],
  CONST double *avar,
  double *var,
  CONST int *n,
  double x[],
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int *ifail
#endif
);

extern void g05pcf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *k,
  CONST double xmean[],
  CONST int *ip,
  CONST double phi[],
  CONST int *iq,
  CONST double theta[],
  double var[] /* 2 dimension */,
  CONST int *ldv,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int iwork[],
  CONST int *liwork,
  int *ifail
#endif
);

extern void g05qaf(
#ifdef __STDC__
  CONST char side[],
  CONST char init[],
  CONST int *m,
  CONST int *n,
  double a[] /* 2 dimension */,
  CONST int *lda,
  CONST int *igen,
  int iseed[],
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g05qbf(
#ifdef __STDC__
  CONST int *n,
  CONST double d[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST double *eps,
  CONST int *igen,
  int iseed[],
  double wk[],
  int *ifail
#endif
);

extern void g05qdf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *nrow,
  CONST int *ncol,
  CONST int totr[],
  CONST int totc[],
  int x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *nr,
  int iw[],
  CONST int *liw,
  int *ifail
#endif
);

extern void g05raf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *m,
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *lr,
  int *ifail
#endif
);

extern void g05rbf(
#ifdef __STDC__
  CONST int *mode,
  CONST int *df,
  CONST int *m,
  CONST double c[] /* 2 dimension */,
  CONST int *ldc,
  CONST int *n,
  double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *igen,
  int iseed[],
  double r[],
  CONST int *lr,
  int *ifail
#endif
);

extern void g05yaf(
#ifdef __STDC__
  CONST int *fcall,
  CONST char seq[],
  CONST int *iskip,
  CONST int *idim,
  double quasi[],
  int iref[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g05ybf(
#ifdef __STDC__
  CONST int *fcall,
  CONST char seq[],
  CONST int *lnorm,
  CONST double xmean[],
  CONST double std[],
  CONST int *iskip,
  CONST int *idim,
  double quasi[],
  int iref[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g05ycf(
#ifdef __STDC__
  CONST int *idim,
  int iref[],
  int *ifail
#endif
);

extern void g05ydf(
#ifdef __STDC__
  CONST int *n,
  double quasi[] /* 2 dimension */,
  int iref[],
  int *ifail
#endif
);

extern void g05yef(
#ifdef __STDC__
  CONST int *idim,
  int iref[],
  CONST int *iskip,
  int *ifail
#endif
);

extern void g05yff(
#ifdef __STDC__
  CONST int *n,
  double quasi[] /* 2 dimension */,
  int iref[],
  int *ifail
#endif
);

extern void g05ygf(
#ifdef __STDC__
  CONST int *idim,
  int iref[],
  CONST int *skip,
  int *ifail
#endif
);

extern void g05yhf(
#ifdef __STDC__
  CONST int *n,
  double quasi[] /* 2 dimension */,
  int iref[],
  int *ifail
#endif
);

extern void g05yjf(
#ifdef __STDC__
  CONST double xmean[],
  CONST double std[],
  CONST int *n,
  double quasi[] /* 2 dimension */,
  int iref[],
  int *ifail
#endif
);

extern void g05ykf(
#ifdef __STDC__
  CONST double xmean[],
  CONST double std[],
  CONST int *n,
  double quasi[] /* 2 dimension */,
  int iref[],
  int *ifail
#endif
);

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

extern void g07aaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *k,
  CONST double *clevel,
  double *pl,
  double *pu,
  int *ifail
#endif
);

extern void g07abf(
#ifdef __STDC__
  CONST int *n,
  CONST double *xmean,
  CONST double *clevel,
  double *tl,
  double *tu,
  int *ifail
#endif
);

extern void g07bbf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST double x[],
  CONST double xc[],
  CONST int ic[],
  double *xmu,
  double *xsig,
  CONST double *tol,
  CONST int *maxit,
  double *sexmu,
  double *sexsig,
  double *corr,
  double *dev,
  int nobs[],
  int *nit,
  double wk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g07bef(
#ifdef __STDC__
  CONST char cens[],
  CONST int *n,
  CONST double x[],
  CONST int ic[],
  double *beta,
  double *gamma,
  CONST double *tol,
  CONST int *maxit,
  double *sebeta,
  double *segam,
  double *corr,
  double *dev,
  int *nit,
  double wk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g07caf(
#ifdef __STDC__
  CONST char tail[],
  CONST char equal[],
  CONST int *nx,
  CONST int *ny,
  CONST double *xmean,
  CONST double *ymean,
  CONST double *xstd,
  CONST double *ystd,
  CONST double *clevel,
  double *t,
  double *df,
  double *prob,
  double *dl,
  double *du,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g07daf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  double y[],
  double *xme,
  double *xmd,
  double *xsd,
  int *ifail
#endif
);

extern void g07dbf(
#ifdef __STDC__
  CONST int *isigma,
  CONST int *n,
  CONST double x[],
  CONST int *ipsi,
  CONST double *c,
  CONST double *h1,
  CONST double *h2,
  CONST double *h3,
  CONST double *dchi,
  double *theta,
  double *sigma,
  CONST int *maxit,
  CONST double *tol,
  double rs[],
  int *nit,
  double wrk[],
  int *ifail
#endif
);

extern void g07dcf(
#ifdef __STDC__
  double (*chi)(double *),
  double (*psi)(double *),
  CONST int *isigma,
  CONST int *n,
  CONST double x[],
  CONST double *beta,
  double *theta,
  double *sigma,
  CONST int *maxit,
  CONST double *tol,
  double rs[],
  int *nit,
  double wrk[],
  int *ifail
#endif
);

extern void g07ddf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double *alpha,
  double *tmean,
  double *wmean,
  double *tvar,
  double *wvar,
  int *k,
  double sx[],
  int *ifail
#endif
);

extern void g07eaf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST double x[],
  CONST double *clevel,
  double *theta,
  double *thetal,
  double *thetau,
  double *estcl,
  double *wlower,
  double *wupper,
  double wrk[],
  int iwrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g07ebf(
#ifdef __STDC__
  CONST char method[],
  CONST int *n,
  CONST double x[],
  CONST int *m,
  CONST double y[],
  CONST double *clevel,
  double *theta,
  double *thetal,
  double *thetau,
  double *estcl,
  double *ulower,
  double *uupper,
  double wrk[],
  int iwrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g08aaf(
#ifdef __STDC__
  CONST double x[],
  CONST double y[],
  CONST int *n,
  int *is,
  int *n1,
  double *p,
  int *ifail
#endif
);

extern void g08abf(
#ifdef __STDC__
  CONST double x[],
  CONST double y[],
  CONST int *n,
  double w1[],
  double w2[],
  double *w,
  int *n1,
  double *p,
  int *ifail
#endif
);

extern void g08acf(
#ifdef __STDC__
  CONST double x[],
  CONST int *n,
  CONST int *n1,
  double w1[],
  int *i1,
  int *i2,
  double *p,
  int *ifail
#endif
);

extern void g08adf(
#ifdef __STDC__
  CONST double x[],
  CONST int *n,
  CONST int *n1,
  double w1[],
  double *u,
  double *p,
  int *ifail
#endif
);

extern void g08aef(
#ifdef __STDC__
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int *k,
  CONST int *n,
  double w1[],
  double w2[],
  double *fr,
  double *p,
  int *ifail
#endif
);

extern void g08aff(
#ifdef __STDC__
  CONST double x[],
  CONST int *lx,
  CONST int l[],
  CONST int *k,
  double w1[],
  double *h,
  double *p,
  int *ifail
#endif
);

extern void g08agf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double *xme,
  CONST char tail[],
  CONST char zeros[],
  double *rs,
  double *rsnor,
  double *p,
  int *nz1,
  double wrk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g08ahf(
#ifdef __STDC__
  CONST int *n1,
  CONST double x[],
  CONST int *n2,
  CONST double y[],
  CONST char tail[],
  double *u,
  double *unor,
  double *p,
  int *ties,
  double ranks[],
  double wrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g08ajf(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST char tail[],
  CONST double *u,
  double *p,
  double wrk[],
  CONST int *lwrk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g08akf(
#ifdef __STDC__
  CONST int *n1,
  CONST int *n2,
  CONST char tail[],
  CONST double ranks[],
  CONST double *u,
  double *p,
  double wrk[],
  CONST int *lwrk,
  int iwrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g08alf(
#ifdef __STDC__
  CONST int *n,
  CONST int *k,
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  double *q,
  double *prob,
  int *ifail
#endif
);

extern void g08baf(
#ifdef __STDC__
  CONST double x[],
  CONST int *n,
  CONST int *n1,
  double r[],
  CONST int *itest,
  double *w,
  double *v,
  double *pw,
  double *pv,
  int *ifail
#endif
);

extern void g08caf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST int *null,
  CONST int *np,
  double p[],
  CONST int *nest,
  CONST int *ntype,
  double *d,
  double *prob,
  double s[],
  int ind[],
  int *ifail
#endif
);

extern void g08cbf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST char dist[],
  double par[],
  CONST char estima[],
  CONST int *ntype,
  double *d,
  double *z,
  double *p,
  double sx[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g08ccf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  double (*cdf)(double[]),
  CONST int *ntype,
  double *d,
  double *z,
  double *p,
  double sx[],
  int *ifail
#endif
);

extern void g08cdf(
#ifdef __STDC__
  CONST int *n1,
  CONST double x[],
  CONST int *n2,
  CONST double y[],
  CONST int *ntype,
  double *d,
  double *z,
  double *p,
  double sx[],
  double sy[],
  int *ifail
#endif
);

extern void g08cgf(
#ifdef __STDC__
  CONST int *k2,
  CONST int ifreq[],
  CONST double cint[],
  CONST char dist[],
  CONST double par[],
  CONST int *iparam,
  CONST double prob[],
  double *chisq,
  double *p,
  int *ndf,
  double eval[],
  double chisqi[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g08daf(
#ifdef __STDC__
  CONST double x[] /* 2 dimension */,
  CONST int *ix,
  CONST int *k,
  CONST int *n,
  double rnk[] /* 2 dimension */,
  double *w,
  double *p,
  int *ifail
#endif
);

extern void g08eaf(
#ifdef __STDC__
  CONST char cl[],
  CONST int *n,
  CONST double x[],
  CONST int *m,
  CONST int *maxr,
  int *nruns,
  int ncount[],
  double ex[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double *chi,
  double *df,
  double *prob,
  double wrk[],
  CONST int *lwrk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g08ebf(
#ifdef __STDC__
  CONST char cl[],
  CONST int *n,
  CONST double x[],
  CONST int *msize,
  CONST int *lag,
  int ncount[] /* 2 dimension */,
  CONST int *ldc,
  double *ex,
  double *chi,
  double *df,
  double *p,
  double wrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g08ecf(
#ifdef __STDC__
  CONST char cl[],
  CONST int *n,
  CONST double x[],
  CONST int *msize,
  int ncount[] /* 3 dimension */,
  CONST int *ldc,
  double *ex,
  double *chi,
  double *df,
  double *p,
  int *ifail,
  CONST int length_1
#endif
);

extern void g08edf(
#ifdef __STDC__
  CONST char cl[],
  CONST int *n,
  CONST double x[],
  CONST int *m,
  CONST int *k,
  CONST double *rl,
  CONST double *ru,
  CONST double *til,
  int *ngaps,
  int ncount[],
  double ex[],
  double *chi,
  double *df,
  double *prob,
  int *ifail,
  CONST int length_1
#endif
);

extern void g08raf(
#ifdef __STDC__
  CONST int *ns,
  int nv[],
  CONST int *nsum,
  CONST double y[],
  CONST int *ip,
  CONST double x[] /* 2 dimension */,
  CONST int *nx,
  CONST int *idist,
  CONST int *nmax,
  CONST double *tol,
  double parvar[] /* 2 dimension */,
  CONST int *npvar,
  int irank[],
  double zin[],
  double eta[],
  double vapvec[],
  double parest[],
  double work[],
  CONST int *lwork,
  int iwa[],
  int *ifail
#endif
);

extern void g08rbf(
#ifdef __STDC__
  CONST int *ns,
  CONST int nv[],
  CONST int *nsum,
  CONST double y[],
  CONST int *ip,
  CONST double x[] /* 2 dimension */,
  CONST int *nx,
  CONST int icen[],
  CONST double *gamma,
  CONST int *nmax,
  CONST double *tol,
  double parvar[] /* 2 dimension */,
  CONST int *npvar,
  int irank[],
  double zin[],
  double eta[],
  double vapvec[],
  double parest[],
  double work[],
  CONST int *lwork,
  int iwa[],
  int *ifail
#endif
);

extern void g10abf(
#ifdef __STDC__
  CONST char mode[],
  CONST char weight[],
  CONST int *n,
  CONST double x[],
  CONST double y[],
  CONST double wt[],
  CONST double *rho,
  double yhat[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double *rss,
  double *df,
  double res[],
  double h[],
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g10acf(
#ifdef __STDC__
  CONST char method[],
  CONST char weight[],
  CONST int *n,
  CONST double x[],
  CONST double y[],
  CONST double wt[],
  double yhat[],
  double c[] /* 2 dimension */,
  CONST int *ldc,
  double *rss,
  double *rdf,
  double res[],
  double h[],
  double *crit,
  double *rho,
  CONST double *u,
  CONST double *tol,
  int *maxcal,
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g10baf(
#ifdef __STDC__
  CONST int *n,
  CONST double x[],
  CONST double *window,
  CONST double *slo,
  CONST double *shi,
  CONST int *ns,
  double smooth[],
  double t[],
  CONST int *usefft,
  double fft[],
  int *ifail
#endif
);

extern void g10caf(
#ifdef __STDC__
  CONST int *itype,
  CONST int *n,
  CONST double y[],
  double smooth[],
  double rough[],
  int *ifail
#endif
);

extern void g10zaf(
#ifdef __STDC__
  CONST char weight[],
  CONST int *n,
  CONST double x[],
  CONST double y[],
  CONST double wt[],
  int *nord,
  double xord[],
  double yord[],
  double wwt[],
  double *rss,
  int iwrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g11aaf(
#ifdef __STDC__
  CONST int *nrow,
  CONST int *ncol,
  CONST int nobst[] /* 2 dimension */,
  CONST int *ldt,
  double expt[] /* 2 dimension */,
  double chist[] /* 2 dimension */,
  double *prob,
  double *chi,
  double *g,
  double *df,
  int *ifail
#endif
);

extern void g11baf(
#ifdef __STDC__
  CONST char stat[],
  CONST char update[],
  CONST char weight[],
  CONST int *n,
  CONST int *nfac,
  CONST int isf[],
  CONST int lfac[],
  CONST int ifac[] /* 2 dimension */,
  CONST int *ldf,
  CONST double y[],
  CONST double wt[],
  double table[],
  CONST int *maxt,
  int *ncells,
  int *ndim,
  int idim[],
  int icount[],
  double auxt[],
  int iwk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void g11bbf(
#ifdef __STDC__
  CONST char type[],
  CONST char weight[],
  CONST int *n,
  CONST int *nfac,
  CONST int isf[],
  CONST int lfac[],
  CONST int ifac[] /* 2 dimension */,
  CONST int *ldf,
  CONST double *percnt,
  CONST double y[],
  CONST double wt[],
  double table[],
  CONST int *maxt,
  int *ncells,
  int *ndim,
  int idim[],
  int icount[],
  int iwk[],
  double wk[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g11bcf(
#ifdef __STDC__
  CONST char stat[],
  CONST double table[],
  CONST int *ncells,
  CONST int *ndim,
  CONST int idim[],
  CONST int isdim[],
  double stable[],
  CONST int *maxst,
  int *mcells,
  int *mdim,
  int mlevel[],
  double auxt[],
  int iwk[],
  double wk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g11caf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *ns,
  CONST double z[] /* 2 dimension */,
  CONST int *ldz,
  CONST int isz[],
  CONST int *ip,
  CONST int ic[],
  CONST int isi[],
  double *dev,
  double b[],
  double se[],
  double sc[],
  double cov[],
  int nca[],
  int nct[],
  CONST double *tol,
  CONST int *maxit,
  CONST int *iprint,
  double wk[],
  CONST int *lwk,
  int *ifail
#endif
);

extern void g11saf(
#ifdef __STDC__
  CONST int *n2,
  CONST int *n,
  CONST int *gprob,
  CONST int *s,
  int x[] /* 2 dimension */,
  CONST int *nrowxr,
  int rl[],
  double a[],
  double c[],
  CONST int *iprint,
  CONST double *cgetol,
  CONST int *maxit,
  CONST int *chisqr,
  CONST int *ishow,
  int *niter,
  double alpha[],
  double gamma[],
  double var[] /* 2 dimension */,
  CONST int *iaa,
  double g[],
  double expp[] /* 2 dimension */,
  CONST int *ia,
  double obs[] /* 2 dimension */,
  double p[],
  double y[],
  double xl[],
  int ob[],
  double *ll,
  double *chi,
  int *idf,
  double *siglev,
  double w[],
  CONST int *lw,
  int *ifail
#endif
);

extern void g11sbf(
#ifdef __STDC__
  CONST int *n2,
  CONST int *n,
  int *s,
  int x[] /* 2 dimension */,
  CONST int *nrx,
  int rl[],
  int *ifail
#endif
);

extern void g12aaf(
#ifdef __STDC__
  CONST int *n,
  CONST double t[],
  CONST int ic[],
  CONST char freq[],
  CONST int ifreq[],
  int *nd,
  double tp[],
  double p[],
  double psig[],
  int iwk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g12baf(
#ifdef __STDC__
  CONST char offset[],
  CONST int *n,
  CONST int *m,
  CONST int *ns,
  CONST double z[] /* 2 dimension */,
  CONST int *ldz,
  CONST int isz[],
  CONST int *ip,
  CONST double t[],
  CONST int ic[],
  CONST double omega[],
  CONST int isi[],
  double *dev,
  double b[],
  double se[],
  double sc[],
  double cov[],
  double res[],
  int *nd,
  double tp[],
  double sur[] /* 2 dimension */,
  CONST int *ndmax,
  CONST double *tol,
  CONST int *maxit,
  CONST int *iprint,
  double wk[],
  int iwk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g12zaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *ns,
  CONST double z[] /* 2 dimension */,
  CONST int *ldz,
  CONST int isz[],
  CONST int *ip,
  CONST double t[],
  CONST int ic[],
  CONST int isi[],
  int *num,
  int ixs[],
  int *nxs,
  double x[] /* 2 dimension */,
  CONST int *mxn,
  int id[],
  int *nd,
  double tp[],
  int irs[],
  int *ifail
#endif
);

extern void g13aaf(
#ifdef __STDC__
  CONST double x[],
  CONST int *nx,
  CONST int *nd,
  CONST int *nds,
  CONST int *ns,
  double xd[],
  int *nxd,
  int *ifail
#endif
);

extern void g13abf(
#ifdef __STDC__
  CONST double x[],
  CONST int *nx,
  CONST int *nk,
  double *xm,
  double *xv,
  double r[],
  double *stat,
  int *ifail
#endif
);

extern void g13acf(
#ifdef __STDC__
  CONST double r[],
  CONST int *nk,
  CONST int *nl,
  double p[],
  double v[],
  double ar[],
  int *nvl,
  int *ifail
#endif
);

extern void g13adf(
#ifdef __STDC__
  CONST int mr[],
  CONST double r[],
  CONST int *nk,
  CONST double *xv,
  CONST int *npar,
  double wa[],
  CONST int *nwa,
  double par[],
  double *rv,
  int isf[],
  int *ifail
#endif
);

extern void g13aef(
#ifdef __STDC__
  CONST int mr[],
  double par[],
  CONST int *npar,
  double *c,
  CONST int *kfc,
  CONST double x[],
  CONST int *nx,
  int icount[],
  double ex[],
  double exr[],
  double al[],
  CONST int *iex,
  double *s,
  double g[],
  CONST int *igh,
  double sd[],
  double h[] /* 2 dimension */,
  CONST int *ih,
  double st[],
  CONST int *ist,
  int *nst,
  void (*piv)(int[], double[], int *, double *, int *, int[], double *, 
              double[], double[], int *, int *, int *, double[]),
  CONST int *kpiv,
  CONST int *nit,
  int *itc,
  double zsp[],
  CONST int *kzsp,
  int isf[],
  double wa[],
  CONST int *iwa,
  double hc[] /* 2 dimension */,
  int *ifail
#endif
);

extern void g13aff(
#ifdef __STDC__
  CONST int mr[],
  double par[],
  CONST int *npar,
  double *c,
  CONST int *kfc,
  CONST double x[],
  CONST int *nx,
  double *s,
  int *ndf,
  double sd[],
  CONST int *nppc,
  double cm[] /* 2 dimension */,
  CONST int *icm,
  double st[],
  int *nst,
  CONST int *kpiv,
  CONST int *nit,
  int *itc,
  int isf[],
  double res[],
  CONST int *ires,
  int *nres,
  int *ifail
#endif
);

extern void g13afz(
#ifdef __STDC__
  int mr[],
  double par[],
  int *npar,
  double *c,
  int *kfc,
  int icount[],
  double *s,
  double g[],
  double h[] /* 2 dimension */,
  int *ih,
  int *igh,
  int *itc,
  double zsp[]
#endif
);

extern void g13agf(
#ifdef __STDC__
  double st[],
  CONST int *nst,
  CONST int mr[],
  CONST double par[],
  CONST int *npar,
  CONST double *c,
  double anx[],
  CONST int *nuv,
  double anexr[],
  double wa[],
  CONST int *nwa,
  int *ifail
#endif
);

extern void g13ahf(
#ifdef __STDC__
  CONST double st[],
  CONST int *nst,
  CONST int mr[],
  CONST double par[],
  CONST int *npar,
  double *c,
  CONST double *rms,
  CONST int *nfv,
  double fva[],
  double fsd[],
  double wa[],
  CONST int *nwa,
  int *ifail
#endif
);

extern void g13ajf(
#ifdef __STDC__
  CONST int mr[],
  CONST double par[],
  CONST int *npar,
  CONST double *c,
  CONST int *kfc,
  CONST double x[],
  CONST int *nx,
  double *rms,
  double st[],
  CONST int *ist,
  int *nst,
  CONST int *nfv,
  double fva[],
  double fsd[],
  CONST int *ifv,
  int isf[],
  double w[],
  CONST int *iw,
  int *ifail
#endif
);

extern void g13asf(
#ifdef __STDC__
  CONST int *n,
  CONST double v[],
  CONST int mr[],
  CONST int *m,
  CONST double par[],
  CONST int *npar,
  CONST int *ishow,
  double c[],
  double acfvar[] /* 2 dimension */,
  CONST int *im,
  double *sum2,
  int *idf,
  double *siglev,
  int intgr[],
  CONST int *lmax,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void g13auf(
#ifdef __STDC__
  CONST int *n,
  CONST double z[],
  CONST int *m,
  CONST int *k,
  CONST char rs[],
  double y[],
  double mean[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g13baf(
#ifdef __STDC__
  CONST double y[],
  CONST int *ny,
  CONST int mr[],
  CONST int *nmr,
  CONST double par[],
  CONST int *npar,
  double *cy,
  double wa[],
  CONST int *nwa,
  double b[],
  CONST int *nb,
  int *ifail
#endif
);

extern void g13bbf(
#ifdef __STDC__
  CONST double y[],
  CONST int *ny,
  CONST int mr[],
  CONST int *nmr,
  CONST double par[],
  CONST int *npar,
  double *cy,
  double wa[],
  CONST int *iwa,
  double b[],
  CONST int *nb,
  int *ifail
#endif
);

extern void g13bcf(
#ifdef __STDC__
  CONST double x[],
  CONST double y[],
  CONST int *nxy,
  CONST int *nl,
  double *s,
  double *r0,
  double r[],
  double *stat,
  int *ifail
#endif
);

extern void g13bdf(
#ifdef __STDC__
  CONST double *r0,
  CONST double r[],
  CONST int *nl,
  CONST int nna[],
  CONST double *s,
  CONST int *nwds,
  double wa[],
  CONST int *iwa,
  double wds[],
  int isf[],
  int *ifail
#endif
);

extern void g13bef(
#ifdef __STDC__
  CONST int mr[],
  CONST int *nser,
  CONST int mt[] /* 2 dimension */,
  double para[],
  CONST int *npara,
  CONST int *kfc,
  CONST int *nxxy,
  double xxy[] /* 2 dimension */,
  CONST int *ixxy,
  CONST int *kef,
  CONST int *nit,
  CONST int *kzsp,
  double zsp[],
  int *itc,
  double sd[],
  double cm[] /* 2 dimension */,
  CONST int *icm,
  double *s,
  double *d,
  int *ndf,
  CONST int *kzef,
  double res[],
  double sttf[],
  CONST int *isttf,
  int *nsttf,
  double wa[],
  CONST int *iwa,
  int mwa[],
  CONST int *imwa,
  CONST int *kpriv,
  int *ifail
#endif
);

extern void g13bgf(
#ifdef __STDC__
  double sttf[],
  CONST int *nsttf,
  CONST int mr[],
  CONST int *nser,
  CONST int mt[] /* 2 dimension */,
  CONST double para[],
  CONST int *npara,
  CONST int *nnv,
  double xxyn[] /* 2 dimension */,
  CONST int *ixxyn,
  CONST int *kzef,
  double res[],
  double wa[],
  CONST int *iwa,
  int *ifail
#endif
);

extern void g13bhf(
#ifdef __STDC__
  double sttf[],
  CONST int *nsttf,
  int mr[],
  CONST int *nser,
  CONST int mt[] /* 2 dimension */,
  CONST double para[],
  CONST int *npara,
  CONST int *nfv,
  double xxyn[] /* 2 dimension */,
  CONST int *ixxyn,
  int mrx[] /* 2 dimension */,
  CONST double parx[] /* 2 dimension */,
  CONST int *iparx,
  CONST double rmsxy[],
  CONST int *kzef,
  double fva[],
  double fsd[],
  double wa[],
  CONST int *iwa,
  int *ifail
#endif
);

extern void g13bjf(
#ifdef __STDC__
  int mr[],
  CONST int *nser,
  CONST int mt[] /* 2 dimension */,
  double para[],
  CONST int *npara,
  CONST int *kfc,
  CONST int *nev,
  CONST int *nfv,
  double xxy[] /* 2 dimension */,
  CONST int *ixxy,
  CONST int *kzef,
  double rmsxy[],
  int mrx[] /* 2 dimension */,
  CONST double parx[] /* 2 dimension */,
  CONST int *iparx,
  double fva[],
  double fsd[],
  double sttf[],
  CONST int *isttf,
  int *nsttf,
  double wa[],
  CONST int *iwa,
  int mwa[],
  CONST int *imwa,
  int *ifail
#endif
);

extern void g13caf(
#ifdef __STDC__
  CONST int *nx,
  CONST int *mtx,
  CONST double *px,
  CONST int *iw,
  CONST int *mw,
  CONST int *ic,
  CONST int *nc,
  double c[],
  CONST int *kc,
  CONST int *l,
  CONST int *lg,
  CONST int *nxg,
  double xg[],
  int *ng,
  double stats[],
  int *ifail
#endif
);

extern void g13cbf(
#ifdef __STDC__
  CONST int *nx,
  CONST int *mtx,
  CONST double *px,
  CONST int *mw,
  CONST double *pw,
  CONST int *l,
  CONST int *kc,
  CONST int *lg,
  double xg[],
  int *ng,
  double stats[],
  int *ifail
#endif
);

extern void g13ccf(
#ifdef __STDC__
  CONST int *nxy,
  CONST int *mtxy,
  CONST double *pxy,
  CONST int *iw,
  CONST int *mw,
  CONST int *is,
  CONST int *ic,
  CONST int *nc,
  double cxy[],
  double cyx[],
  CONST int *kc,
  CONST int *l,
  CONST int *nxyg,
  double xg[],
  double yg[],
  int *ng,
  int *ifail
#endif
);

extern void g13cdf(
#ifdef __STDC__
  CONST int *nxy,
  CONST int *mtxy,
  CONST double *pxy,
  CONST int *mw,
  CONST int *is,
  CONST double *pw,
  CONST int *l,
  CONST int *kc,
  double xg[],
  double yg[],
  int *ng,
  int *ifail
#endif
);

extern void g13cef(
#ifdef __STDC__
  CONST double xg[],
  CONST double yg[],
  CONST double xyrg[],
  CONST double xyig[],
  CONST int *ng,
  CONST double stats[],
  double ca[],
  double calw[],
  double caup[],
  double *t,
  double sc[],
  double sclw[],
  double scup[],
  int *ifail
#endif
);

extern void g13cff(
#ifdef __STDC__
  CONST double xg[],
  CONST double yg[],
  CONST double xyrg[],
  CONST double xyig[],
  CONST int *ng,
  CONST double stats[],
  double gn[],
  double gnlw[],
  double gnup[],
  double ph[],
  double phlw[],
  double phup[],
  int *ifail
#endif
);

extern void g13cgf(
#ifdef __STDC__
  CONST double xg[],
  CONST double yg[],
  CONST double xyrg[],
  CONST double xyig[],
  CONST int *ng,
  CONST double stats[],
  CONST int *l,
  CONST int *n,
  double er[],
  double *erlw,
  double *erup,
  double rf[],
  double *rfse,
  int *ifail
#endif
);

extern void g13daf(
#ifdef __STDC__
  CONST double x[] /* 2 dimension */,
  CONST int *nxm,
  CONST int *nx,
  CONST int *nsm,
  CONST int *ns,
  CONST int *nl,
  CONST int *icr,
  double c0[] /* 2 dimension */,
  double c[] /* 3 dimension */,
  int *ifail
#endif
);

extern void g13dbf(
#ifdef __STDC__
  CONST double c0[] /* 2 dimension */,
  CONST double c[] /* 3 dimension */,
  CONST int *nsm,
  CONST int *ns,
  CONST int *nl,
  CONST int *nk,
  double p[],
  double *v0,
  double v[],
  double d[] /* 3 dimension */,
  double db[] /* 2 dimension */,
  double w[] /* 3 dimension */,
  double wb[] /* 3 dimension */,
  int *nvp,
  double wa[],
  CONST int *iwa,
  int *ifail
#endif
);

extern void g13dcf(
#ifdef __STDC__
  CONST int *k,
  CONST int *n,
  CONST int *p,
  CONST int *q,
  CONST int *mean,
  double x[],
  CONST int *n4,
  double qq[] /* 2 dimension */,
  CONST int *ik,
  CONST double w[] /* 2 dimension */,
  CONST int parhld[],
  int *conds,
  int *iprint,
  CONST double *cgetol,
  CONST int *maxcal,
  CONST int *ishow,
  int *niter,
  double *logl,
  double v[] /* 2 dimension */,
  double g[],
  double disp[] /* 2 dimension */,
  CONST int *idisp,
  double w2[],
  CONST int *lw,
  int iw[],
  CONST int *liw,
  int *ifail
#endif
);

extern void g13djf(
#ifdef __STDC__
  CONST int *k,
  CONST int *n,
  CONST double z[] /* 2 dimension */,
  CONST int *ik,
  CONST char tr[],
  CONST int id[],
  CONST double delta[] /* 2 dimension */,
  CONST int *ip,
  CONST int *iq,
  CONST char mean[],
  CONST double par[],
  CONST int *lpar,
  double qq[] /* 2 dimension */,
  CONST double v[] /* 2 dimension */,
  CONST int *lmax,
  double predz[] /* 2 dimension */,
  double sefz[] /* 2 dimension */,
  double ref[],
  CONST int *lref,
  double work[],
  CONST int *lwork,
  int iwork[],
  CONST int *liwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void g13dkf(
#ifdef __STDC__
  CONST int *k,
  CONST int *lmax,
  CONST int *m,
  int *mlast,
  CONST double z[] /* 2 dimension */,
  CONST int *ik,
  double ref[],
  CONST int *lref,
  double v[] /* 2 dimension */,
  double predz[] /* 2 dimension */,
  double sefz[] /* 2 dimension */,
  double work[],
  int *ifail
#endif
);

extern void g13dlf(
#ifdef __STDC__
  CONST int *k,
  CONST int *n,
  CONST double z[] /* 2 dimension */,
  CONST int *ik,
  CONST char tr[],
  CONST int id[],
  CONST double delta[] /* 2 dimension */,
  double w[] /* 2 dimension */,
  int *nd,
  double work[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g13dmf(
#ifdef __STDC__
  CONST char matrix[],
  CONST int *k,
  CONST int *n,
  CONST int *m,
  CONST double w[] /* 2 dimension */,
  CONST int *ik,
  double wmean[],
  double r0[] /* 2 dimension */,
  double r[] /* 3 dimension */,
  int *ifail,
  CONST int length_1
#endif
);

extern void g13dnf(
#ifdef __STDC__
  CONST int *k,
  CONST int *n,
  CONST int *m,
  CONST int *ik,
  CONST double r0[] /* 2 dimension */,
  CONST double r[] /* 3 dimension */,
  int *maxlag,
  double parlag[] /* 3 dimension */,
  double x[],
  double pvalue[],
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void g13dpf(
#ifdef __STDC__
  CONST int *k,
  CONST int *n,
  CONST double z[] /* 2 dimension */,
  CONST int *ik,
  CONST int *m,
  int *maxlag,
  double parlag[] /* 3 dimension */,
  double se[] /* 3 dimension */,
  double qq[] /* 3 dimension */,
  double x[],
  double pvalue[],
  double loglhd[],
  double work[],
  CONST int *lwork,
  int iwork[],
  int *ifail
#endif
);

extern void g13dsf(
#ifdef __STDC__
  CONST int *k,
  CONST int *n,
  CONST double v[] /* 2 dimension */,
  CONST int *ik,
  CONST int *p,
  CONST int *q,
  CONST int *m,
  CONST double par[],
  CONST int parhld[],
  double qq[] /* 2 dimension */,
  CONST int *ishow,
  double r0[] /* 2 dimension */,
  double c[] /* 3 dimension */,
  double acfvar[] /* 2 dimension */,
  CONST int *im,
  double *chi,
  int *idf,
  double *siglev,
  int iw[],
  CONST int *liw,
  double work[],
  CONST int *lwork,
  int *ifail
#endif
);

extern void g13dxf(
#ifdef __STDC__
  CONST int *k,
  CONST int *ip,
  CONST double par[],
  double rr[],
  double ri[],
  double rmod[],
  double work[],
  int iwork[],
  int *ifail
#endif
);

extern void g13eaf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST int *l,
  CONST double a[] /* 2 dimension */,
  CONST int *lds,
  CONST double b[] /* 2 dimension */,
  CONST int *stq,
  CONST double q[] /* 2 dimension */,
  CONST int *ldq,
  CONST double c[] /* 2 dimension */,
  CONST int *ldm,
  CONST double r[] /* 2 dimension */,
  double s[] /* 2 dimension */,
  double k[] /* 2 dimension */,
  double h[] /* 2 dimension */,
  CONST double *tol,
  CONST int iwk[],
  double wk[],
  int *ifail
#endif
);

extern void g13ebf(
#ifdef __STDC__
  CONST char transf[],
  CONST int *n,
  CONST int *m,
  CONST int *l,
  double a[] /* 2 dimension */,
  CONST int *lds,
  double b[] /* 2 dimension */,
  CONST int *stq,
  CONST double q[] /* 2 dimension */,
  CONST int *ldq,
  double c[] /* 2 dimension */,
  CONST int *ldm,
  CONST double r[] /* 2 dimension */,
  double s[] /* 2 dimension */,
  double k[] /* 2 dimension */,
  double h[] /* 2 dimension */,
  double u[] /* 2 dimension */,
  CONST double *tol,
  CONST int iwk[],
  double wk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void g13faf(
#ifdef __STDC__
  CONST char dist[],
  CONST double yt[],
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST int *nreg,
  CONST int *mn,
  CONST int *isym,
  CONST int *npar,
  double theta[],
  double se[],
  double sc[],
  double covar[] /* 2 dimension */,
  CONST int *ldc,
  double *hp,
  double etm[],
  double htm[],
  double *lgf,
  CONST int copts[],
  CONST int *maxit,
  CONST double *tol,
  double wk[],
  CONST int *lwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g13fbf(
#ifdef __STDC__
  CONST int *num,
  CONST int *nt,
  CONST int *ip,
  CONST int *iq,
  CONST double theta[],
  CONST double *gamma,
  double fht[],
  CONST double ht[],
  CONST double et[],
  int *ifail
#endif
);

extern void g13fcf(
#ifdef __STDC__
  CONST char dist[],
  CONST double yt[],
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST int *nreg,
  CONST int *mn,
  CONST int *npar,
  double theta[],
  double se[],
  double sc[],
  double covar[] /* 2 dimension */,
  CONST int *ldc,
  double *hp,
  double etm[],
  double htm[],
  double *lgf,
  CONST int copts[],
  CONST int *maxit,
  CONST double *tol,
  double wk[],
  CONST int *lwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g13fdf(
#ifdef __STDC__
  CONST int *num,
  CONST int *nt,
  CONST int *ip,
  CONST int *iq,
  CONST double theta[],
  CONST double *gamma,
  double fht[],
  CONST double ht[],
  CONST double et[],
  int *ifail
#endif
);

extern void g13fef(
#ifdef __STDC__
  CONST char dist[],
  CONST double yt[],
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST int *nreg,
  CONST int *mn,
  CONST int *npar,
  double theta[],
  double se[],
  double sc[],
  double covar[] /* 2 dimension */,
  CONST int *ldc,
  double *hp,
  double etm[],
  double htm[],
  double *lgf,
  CONST int copts[],
  CONST int *maxit,
  CONST double *tol,
  double wk[],
  CONST int *lwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g13fff(
#ifdef __STDC__
  CONST int *num,
  CONST int *nt,
  CONST int *ip,
  CONST int *iq,
  CONST double theta[],
  CONST double *gamma,
  double fht[],
  CONST double ht[],
  CONST double et[],
  int *ifail
#endif
);

extern void g13fgf(
#ifdef __STDC__
  CONST char dist[],
  CONST double yt[],
  CONST double x[] /* 2 dimension */,
  CONST int *ldx,
  CONST int *num,
  CONST int *ip,
  CONST int *iq,
  CONST int *nreg,
  CONST int *mn,
  CONST int *npar,
  double theta[],
  double se[],
  double sc[],
  double covar[] /* 2 dimension */,
  CONST int *ldc,
  double *hp,
  double etm[],
  double htm[],
  double *lgf,
  CONST int *copt,
  CONST int *maxit,
  CONST double *tol,
  double wk[],
  CONST int *lwk,
  int *ifail,
  CONST int length_1
#endif
);

extern void g13fhf(
#ifdef __STDC__
  CONST int *num,
  CONST int *nt,
  CONST int *ip,
  CONST int *iq,
  CONST double theta[],
  double fht[],
  CONST double ht[],
  CONST double et[],
  int *ifail
#endif
);

extern void h02bbf(
#ifdef __STDC__
  int *itmax,
  CONST int *msglvl,
  CONST int *n,
  CONST int *m,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double bl[],
  CONST double bu[],
  CONST int intvar[],
  CONST double cvec[],
  CONST int *maxnod,
  CONST int *intfst,
  CONST int *maxdpt,
  double *toliv,
  double *tolfes,
  double *bigbnd,
  double x[],
  double *objmip,
  int iwork[],
  CONST int *liwork,
  double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void h02bff(
#ifdef __STDC__
  CONST int *infile,
  CONST int *maxn,
  CONST int *maxm,
  CONST char optim[],
  CONST double *xbldef,
  CONST double *xbudef,
  CONST int *maxdpt,
  CONST int *msglvl,
  int *n,
  int *m,
  double x[],
  char crname[],
  int iwork[],
  CONST int *liwork,
  double rwork[],
  CONST int *lrwork,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void h02buf(
#ifdef __STDC__
  CONST int *infile,
  CONST int *maxn,
  CONST int *maxm,
  CONST char optim[],
  CONST double *xbldef,
  CONST double *xbudef,
  char nmobj[],
  char nmrhs[],
  char nmrng[],
  char nmbnd[],
  CONST int *mpslst,
  int *n,
  int *m,
  double a[] /* 2 dimension */,
  double bl[],
  double bu[],
  double cvec[],
  double x[],
  int intvar[],
  char crname[],
  char nmprob[],
  int iwork[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6,
  CONST int length_7
#endif
);

extern void h02bvf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST double bl[],
  CONST double bu[],
  CONST double x[],
  CONST double clamda[],
  CONST int istate[],
  CONST char crname[],
  int *ifail,
  CONST int length_1
#endif
);

extern void h02bzf(
#ifdef __STDC__
  CONST int *n,
  CONST int *m,
  double bl[],
  double bu[],
  double clamda[],
  int istate[],
  CONST int iwork[],
  CONST int *liwork,
  CONST double rwork[],
  CONST int *lrwork,
  int *ifail
#endif
);

extern void h02cbf(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  double bl[],
  double bu[],
  CONST double cvec[],
  CONST double h[] /* 2 dimension */,
  CONST int *ldh,
  void (*qphess)(int *, int *, double[], int *, double[], double[]),
  CONST int intvar[],
  CONST int *lintvr,
  CONST int *mdepth,
  int istate[],
  double xs[],
  double *obj,
  double ax[],
  double clamda[],
  CONST int *strtgy,
  int iwrk[],
  CONST int *liwrk,
  double wrk[],
  CONST int *lwrk,
  void (*monit)(int *, int *, int *, double *, double[], double *, double[], 
                double[], double[], int *, int *, int *),
  int *ifail
#endif
);

extern void h02cbu(
#ifdef __STDC__
  int *intfnd,
  int *nodes,
  int *depth,
  double *obj,
  double x[],
  double *bstval,
  double bstsol[],
  double bl[],
  double bu[],
  int *n,
  int *halt,
  int *count
#endif
);

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

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

extern void h02cef(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  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[],
  CONST int intvar[],
  CONST int *lintvr,
  CONST int *mdepth,
  int istate[],
  int *miniz,
  int *minz,
  double *obj,
  double clamda[],
  CONST int *strtgy,
  int iwrk[],
  CONST int *liwrk,
  double wrk[],
  CONST int *lwrk,
  void (*monit)(int *, int *, int *, double *, double[], double *, double[], 
                double[], double[], int *, int *, int *),
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void h02cey(
#ifdef __STDC__
  int *intfnd,
  int *nodes,
  int *depth,
  double *obj,
  double x[],
  double *bstval,
  double bstsol[],
  double bl[],
  double bu[],
  int *n,
  int *halt,
  int *count
#endif
);

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

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

extern void m01edf(
#ifdef __STDC__
  Complex cv[],
  CONST int *m1,
  CONST int *m2,
  int irank[],
  int *ifail
#endif
);

extern void x04acf(
#ifdef __STDC__
  CONST int *nout,
  CONST char file[],
  CONST int *mode,
  int *ifail,
  CONST int length_1
#endif
);

extern void x04adf(
#ifdef __STDC__
  CONST int *nout,
  int *ifail
#endif
);

extern void h03abf(
#ifdef __STDC__
  CONST int kost[] /* 2 dimension */,
  CONST int *mmm,
  CONST int *ma,
  CONST int *mb,
  CONST int *m,
  int k15[],
  CONST int *maxit,
  int k7[],
  int k9[],
  int *numit,
  int k6[],
  int k8[],
  int k11[],
  int k12[],
  double *z,
  int *ifail
#endif
);

extern void h03adf(
#ifdef __STDC__
  CONST int *n,
  CONST int *ns,
  CONST int *ne,
  CONST int *direct,
  CONST int *nnz,
  CONST double d[],
  int irow[],
  CONST int icol[],
  double *splen,
  int path[],
  int iwork[],
  double work[],
  int *ifail
#endif
);

extern void m01ajf(
#ifdef __STDC__
  double a[],
  double w[],
  int ind[],
  int indw[],
  CONST int *n,
  CONST int *nw,
  int *ifail
#endif
);

extern void m01akf(
#ifdef __STDC__
  double a[],
  double w[],
  int ind[],
  int indw[],
  CONST int *n,
  CONST int *nw,
  int *ifail
#endif
);

extern void m01apf(
#ifdef __STDC__
  double a[],
  CONST int *ii,
  CONST int *jj,
  int *ifail
#endif
);

extern void m01caf(
#ifdef __STDC__
  double rv[],
  CONST int *m1,
  CONST int *m2,
  CONST char order[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01cbf(
#ifdef __STDC__
  int iv[],
  CONST int *m1,
  CONST int *m2,
  CONST char order[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01ccf(
#ifdef __STDC__
  char ch[],
  CONST int *m1,
  CONST int *m2,
  CONST int *l1,
  CONST int *l2,
  CONST char order[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void m01daf(
#ifdef __STDC__
  CONST double rv[],
  CONST int *m1,
  CONST int *m2,
  CONST char order[],
  int irank[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01dbf(
#ifdef __STDC__
  CONST int iv[],
  CONST int *m1,
  CONST int *m2,
  CONST char order[],
  int irank[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01dcf(
#ifdef __STDC__
  CONST char ch[],
  CONST int *m1,
  CONST int *m2,
  CONST int *l1,
  CONST int *l2,
  CONST char order[],
  int irank[],
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void m01def(
#ifdef __STDC__
  CONST double rm[] /* 2 dimension */,
  CONST int *ldm,
  CONST int *m1,
  CONST int *m2,
  CONST int *n1,
  CONST int *n2,
  CONST char order[],
  int irank[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01dff(
#ifdef __STDC__
  CONST int iv[] /* 2 dimension */,
  CONST int *ldm,
  CONST int *m1,
  CONST int *m2,
  CONST int *n1,
  CONST int *n2,
  CONST char order[],
  int irank[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01djf(
#ifdef __STDC__
  CONST double rm[] /* 2 dimension */,
  CONST int *ldm,
  CONST int *m1,
  CONST int *m2,
  CONST int *n1,
  CONST int *n2,
  CONST char order[],
  int irank[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01dkf(
#ifdef __STDC__
  CONST int im[] /* 2 dimension */,
  CONST int *ldm,
  CONST int *m1,
  CONST int *m2,
  CONST int *n1,
  CONST int *n2,
  CONST char order[],
  int irank[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01dzf(
#ifdef __STDC__
  int (*compar)(int *, int *),
  CONST int *m1,
  CONST int *m2,
  int irank[],
  int *ifail
#endif
);

extern void m01eaf(
#ifdef __STDC__
  double rv[],
  CONST int *m1,
  CONST int *m2,
  int irank[],
  int *ifail
#endif
);

extern void m01ebf(
#ifdef __STDC__
  int iv[],
  CONST int *m1,
  CONST int *m2,
  int irank[],
  int *ifail
#endif
);

extern void m01ecf(
#ifdef __STDC__
  char ch[],
  CONST int *m1,
  CONST int *m2,
  int irank[],
  int *ifail,
  CONST int length_1
#endif
);

extern void m01zaf(
#ifdef __STDC__
  int iperm[],
  CONST int *m1,
  CONST int *m2,
  int *ifail
#endif
);

extern void m01zbf(
#ifdef __STDC__
  int iperm[],
  CONST int *m1,
  CONST int *m2,
  int *ifail
#endif
);

extern void m01zcf(
#ifdef __STDC__
  int iperm[],
  CONST int *m1,
  CONST int *m2,
  int icycl[],
  int *ifail
#endif
);

extern int p01abf(
#ifdef __STDC__
  CONST int *ifail,
  CONST int *ierror,
  CONST char srname[],
  CONST int *nrec,
  CONST char rec[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern int p01acf(
#ifdef __STDC__
  CONST int *ifail,
  CONST int *ierror,
  CONST char srname[],
  CONST char varbnm[],
  CONST int *nrec,
  CONST char rec[],
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern double s01baf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern void s01eaf(
#ifdef __STDC__
  Complex *s01eaf,
  CONST Complex *z,
  int *ifail
#endif
);

extern double s07aaf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s09aaf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s09abf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s10aaf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s10abf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s10acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s11aaf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s11abf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s11acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s13aaf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s13acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s13adf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s14aaf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s14abf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s14acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

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

extern double s14aef(
#ifdef __STDC__
  CONST double *x,
  CONST int *k,
  int *ifail
#endif
);

extern void s14aff(
#ifdef __STDC__
  Complex *s14aff,
  CONST Complex *z,
  CONST int *k,
  int *ifail
#endif
);

extern void s14agf(
#ifdef __STDC__
  Complex *s14agf,
  CONST Complex *z,
  int *ifail
#endif
);

extern void s14baf(
#ifdef __STDC__
  CONST double *a,
  CONST double *x,
  CONST double *tol,
  double *p,
  double *q,
  int *ifail
#endif
);

extern double s15abf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s15acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s15adf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s15aef(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s15aff(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern void s15ddf(
#ifdef __STDC__
  Complex *s15ddf,
  CONST Complex *z,
  int *ifail
#endif
);

extern double s17acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s17adf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s17aef(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s17aff(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s17agf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s17ahf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s17ajf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s17akf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern void s17alf(
#ifdef __STDC__
  CONST double *a,
  CONST int *n,
  CONST int *mode,
  CONST double *rel,
  double x[],
  int *ifail
#endif
);

extern void s17dcf(
#ifdef __STDC__
  CONST double *fnu,
  CONST Complex *z,
  CONST int *n,
  CONST char scal[],
  Complex cy[],
  int *nz,
  Complex cwrk[],
  int *ifail,
  CONST int length_1
#endif
);

extern void s17def(
#ifdef __STDC__
  CONST double *fnu,
  CONST Complex *z,
  CONST int *n,
  CONST char scal[],
  Complex cy[],
  int *nz,
  int *ifail,
  CONST int length_1
#endif
);

extern void s17dgf(
#ifdef __STDC__
  CONST char deriv[],
  CONST Complex *z,
  CONST char scal[],
  Complex *ai,
  int *nz,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void s17dhf(
#ifdef __STDC__
  CONST char deriv[],
  CONST Complex *z,
  CONST char scal[],
  Complex *bi,
  int *ifail,
  CONST int length_1,
  CONST int length_2
#endif
);

extern void s17dlf(
#ifdef __STDC__
  CONST int *m,
  CONST double *fnu,
  CONST Complex *z,
  CONST int *n,
  CONST char scal[],
  Complex cy[],
  int *nz,
  int *ifail,
  CONST int length_1
#endif
);

extern double s18acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s18adf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s18aef(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s18aff(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s18ccf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s18cdf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s18cef(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s18cff(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern void s18dcf(
#ifdef __STDC__
  CONST double *fnu,
  CONST Complex *z,
  CONST int *n,
  CONST char scal[],
  Complex cy[],
  int *nz,
  int *ifail,
  CONST int length_1
#endif
);

extern void s18def(
#ifdef __STDC__
  CONST double *fnu,
  CONST Complex *z,
  CONST int *n,
  CONST char scal[],
  Complex cy[],
  int *nz,
  int *ifail,
  CONST int length_1
#endif
);

extern void s18gkf(
#ifdef __STDC__
  CONST Complex *z,
  CONST double *a,
  CONST int *nl,
  Complex b[],
  int *ifail
#endif
);

extern double s19aaf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s19abf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s19acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s19adf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s20acf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s20adf(
#ifdef __STDC__
  CONST double *x,
  int *ifail
#endif
);

extern double s21baf(
#ifdef __STDC__
  CONST double *x,
  CONST double *y,
  int *ifail
#endif
);

extern double s21bbf(
#ifdef __STDC__
  CONST double *x,
  CONST double *y,
  CONST double *z,
  int *ifail
#endif
);

extern double s21bcf(
#ifdef __STDC__
  CONST double *x,
  CONST double *y,
  CONST double *z,
  int *ifail
#endif
);

extern double s21bdf(
#ifdef __STDC__
  CONST double *x,
  CONST double *y,
  CONST double *z,
  CONST double *r,
  int *ifail
#endif
);

extern void s21caf(
#ifdef __STDC__
  CONST double *u,
  CONST double *m,
  double *sn,
  double *cn,
  double *dn,
  int *ifail
#endif
);

extern void s21cbf(
#ifdef __STDC__
  CONST Complex *z,
  CONST double *ak2,
  Complex *sn,
  Complex *cn,
  Complex *dn,
  int *ifail
#endif
);

extern double s21ccf(
#ifdef __STDC__
  CONST int *k,
  CONST double *x,
  CONST double *q,
  int *ifail
#endif
);

extern void s21daf(
#ifdef __STDC__
  Complex *s21daf,
  CONST Complex *z,
  CONST double *akp,
  CONST double *a,
  CONST double *b,
  int *ifail
#endif
);

extern void s22aaf(
#ifdef __STDC__
  CONST int *mode,
  CONST double *x,
  CONST int *m,
  CONST int *nl,
  double p[],
  int *ifail
#endif
);

extern double x01aaf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double x01abf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double x02aaf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double x02abf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double x02acf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double x02agf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double x02ahf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern double x02ajf(
#ifdef __STDC__
void
#endif
);

extern double x02akf(
#ifdef __STDC__
void
#endif
);

extern double x02alf(
#ifdef __STDC__
void
#endif
);

extern double x02amf(
#ifdef __STDC__
void
#endif
);

extern double x02anf(
#ifdef __STDC__
void
#endif
);

extern int x02bbf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern int x02bef(
#ifdef __STDC__
  CONST double *x
#endif
);

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

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

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

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

extern int x02caf(
#ifdef __STDC__
  CONST double *x
#endif
);

extern int x02daf(
#ifdef __STDC__
  CONST double *x
#endif
);

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

extern void x03aaf(
#ifdef __STDC__
  CONST double a[],
  CONST int *isizea,
  CONST double b[],
  CONST int *isizeb,
  CONST int *n,
  CONST int *istepa,
  CONST int *istepb,
  CONST double *c1,
  CONST double *c2,
  double *d1,
  double *d2,
  CONST int *sw,
  int *ifail
#endif
);

extern void x03abf(
#ifdef __STDC__
  CONST Complex a[],
  CONST int *isizea,
  CONST Complex b[],
  CONST int *isizeb,
  CONST int *n,
  CONST int *istepa,
  CONST int *istepb,
  CONST Complex *cx,
  Complex *dx,
  CONST int *sw,
  int *ifail
#endif
);

extern void x04aaf(
#ifdef __STDC__
  CONST int *i,
  int *nerr
#endif
);

extern void x04abf(
#ifdef __STDC__
  CONST int *i,
  int *nadv
#endif
);

extern void x04baf(
#ifdef __STDC__
  CONST int *nout,
  CONST char rec[],
  CONST int length_1
#endif
);

extern void x04bbf(
#ifdef __STDC__
  CONST int *nin,
  char rec[],
  int *ifail,
  CONST int length_1
#endif
);

extern void x04caf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST char title[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void x04cbf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST char format[],
  CONST char title[],
  CONST char labrow[],
  CONST char rlabs[],
  CONST char labcol[],
  CONST char clabs[],
  CONST int *ncols,
  CONST int *indent,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6,
  CONST int length_7,
  CONST int length_8
#endif
);

extern void x04ccf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST double a[],
  CONST char title[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void x04cdf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST double a[],
  CONST char format[],
  CONST char title[],
  CONST char labrow[],
  CONST char rlabs[],
  CONST char labcol[],
  CONST char clabs[],
  CONST int *ncols,
  CONST int *indent,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6,
  CONST int length_7,
  CONST int length_8
#endif
);

extern void x04cef(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST char title[],
  int *ifail,
  CONST int length_1
#endif
);

extern void x04cff(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST double a[] /* 2 dimension */,
  CONST int *lda,
  CONST char format[],
  CONST char title[],
  CONST char labrow[],
  CONST char rlabs[],
  CONST char labcol[],
  CONST char clabs[],
  CONST int *ncols,
  CONST int *indent,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6
#endif
);

extern void x04daf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST char title[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void x04dbf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST char usefrm[],
  CONST char format[],
  CONST char title[],
  CONST char labrow[],
  CONST char rlabs[],
  CONST char labcol[],
  CONST char clabs[],
  CONST int *ncols,
  CONST int *indent,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6,
  CONST int length_7,
  CONST int length_8,
  CONST int length_9
#endif
);

extern void x04dcf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[],
  CONST char title[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void x04ddf(
#ifdef __STDC__
  CONST char uplo[],
  CONST char diag[],
  CONST int *n,
  CONST Complex a[],
  CONST char usefrm[],
  CONST char format[],
  CONST char title[],
  CONST char labrow[],
  CONST char rlabs[],
  CONST char labcol[],
  CONST char clabs[],
  CONST int *ncols,
  CONST int *indent,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6,
  CONST int length_7,
  CONST int length_8,
  CONST int length_9
#endif
);

extern void x04def(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST char title[],
  int *ifail,
  CONST int length_1
#endif
);

extern void x04dff(
#ifdef __STDC__
  CONST int *m,
  CONST int *n,
  CONST int *kl,
  CONST int *ku,
  CONST Complex a[] /* 2 dimension */,
  CONST int *lda,
  CONST char usefrm[],
  CONST char format[],
  CONST char title[],
  CONST char labrow[],
  CONST char rlabs[],
  CONST char labcol[],
  CONST char clabs[],
  CONST int *ncols,
  CONST int *indent,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6,
  CONST int length_7
#endif
);

extern void x04eaf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST int a[] /* 2 dimension */,
  CONST int *lda,
  CONST char title[],
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3
#endif
);

extern void x04ebf(
#ifdef __STDC__
  CONST char matrix[],
  CONST char diag[],
  CONST int *m,
  CONST int *n,
  CONST int a[] /* 2 dimension */,
  CONST int *lda,
  CONST char format[],
  CONST char title[],
  CONST char labrow[],
  CONST char rlabs[],
  CONST char labcol[],
  CONST char clabs[],
  CONST int *ncols,
  CONST int *indent,
  int *ifail,
  CONST int length_1,
  CONST int length_2,
  CONST int length_3,
  CONST int length_4,
  CONST int length_5,
  CONST int length_6,
  CONST int length_7,
  CONST int length_8
#endif
);

extern void x05aaf(
#ifdef __STDC__
  int itime[]
#endif
);

extern void x05abf(
#ifdef __STDC__
  char [], int,
  CONST int itime[]
#endif
);

extern int x05acf(
#ifdef __STDC__
  CONST char ctime1[],
  CONST char ctime2[],
  CONST int length_1,
  CONST int length_2
#endif
);

extern double x05baf(
#ifdef __STDC__
void
#endif
);

#ifdef __cplusplus
}
#endif
#endif

