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

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

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

   Author: Mike Dewar, University of Bath

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

*/

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

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

#ifdef __cplusplus
extern "C" {
#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern void e04ucf_(
#ifdef __STDC__
  CONST int *n,
  CONST int *nclin,
  CONST int *ncnln,
  CONST int *lda,
  CONST int *ldcju,
  CONST int *ldr,
  double a[] /* 2 dimension */,
  CONST double bl[],
  CONST double bu[],
  void (*confun)(int *, int *, int *, int *, int[], double[], double[], 
                 double[], int *, int[], double[]),
  void (*objfun)(int *, int *, double[], double *, double[], int *, int[], 
                 double[]),
  int *iter,
  int istate[],
  double c[],
  double cjacu[] /* 2 dimension */,
  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 Complex f06clf_(
#ifdef __STDC__

  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 Complex f06gaf_(
#ifdef __STDC__

  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy
#endif
);

extern Complex f06gbf_(
#ifdef __STDC__

  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 Complex f06grf_(
#ifdef __STDC__

  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  CONST Complex y[]
#endif
);

extern Complex f06gsf_(
#ifdef __STDC__

  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 Complex zdotu_(
#ifdef __STDC__

  CONST int *n,
  CONST Complex x[],
  CONST int *incx,
  CONST Complex y[],
  CONST int *incy
#endif
);

extern Complex zdotc_(
#ifdef __STDC__

  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 Complex zdotui_(
#ifdef __STDC__

  CONST int *nz,
  CONST Complex x[],
  CONST int indx[],
  CONST Complex y[]
#endif
);

extern Complex zdotci_(
#ifdef __STDC__

  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 Complex s01eaf_(
#ifdef __STDC__

  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 Complex s14aff_(
#ifdef __STDC__

  CONST Complex *z,
  CONST int *k,
  int *ifail
#endif
);

extern Complex s14agf_(
#ifdef __STDC__

  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 Complex s15ddf_(
#ifdef __STDC__

  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 Complex s21daf_(
#ifdef __STDC__

  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