/* schkee.f -- translated by f2c (version 20061008).
   You must link the resulting object file with libf2c:
	on Microsoft Windows system, link with libf2c.lib;
	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
	or, if you install libf2c.a in a standard place, with -lf2c -lm
	-- in that order, at the end of the command line, as in
		cc *.o -lf2c -lm
	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,

		http://www.netlib.org/f2c/libf2c.zip
*/

#include "f2c.h"
#include "blaswrap.h"

/* Common Block Declarations */

struct {
    integer nproc, nshift, maxb;
} cenvir_;

#define cenvir_1 cenvir_

struct {
    integer iparms[100];
} claenv_;

#define claenv_1 claenv_

struct {
    integer infot, nunit;
    logical ok, lerr;
} infoc_;

#define infoc_1 infoc_

struct {
    char srnamt[32];
} srnamc_;

#define srnamc_1 srnamc_

struct {
    integer selopt, seldim;
    logical selval[20];
    real selwr[20], selwi[20];
} sslct_;

#define sslct_1 sslct_

/* Table of constant values */

static integer c__1 = 1;
static integer c__3 = 3;
static integer c__5 = 5;
static integer c__6 = 6;
static integer c__4 = 4;
static integer c__12 = 12;
static integer c__11 = 11;
static integer c__13 = 13;
static integer c__2 = 2;
static integer c__14 = 14;
static integer c__0 = 0;
static integer c__15 = 15;
static integer c__16 = 16;
static integer c__20 = 20;
static integer c__132 = 132;
static integer c__8 = 8;
static integer c__87781 = 87781;
static integer c__9 = 9;
static integer c__25 = 25;
static integer c__89760 = 89760;
static integer c__18 = 18;
static integer c__400 = 400;
static integer c__89758 = 89758;
static integer c__264 = 264;

/* Main program */ int MAIN__(void)
{
    /* Initialized data */

    static char intstr[10] = "0123456789";
    static integer ioldsd[4] = { 0,0,0,1 };

    /* Format strings */
    static char fmt_9987[] = "(\002 Tests of the Nonsymmetric Eigenvalue Pro"
	    "blem routines\002)";
    static char fmt_9986[] = "(\002 Tests of the Symmetric Eigenvalue Proble"
	    "m routines\002)";
    static char fmt_9985[] = "(\002 Tests of the Singular Value Decompositio"
	    "n routines\002)";
    static char fmt_9979[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
	    "oblem Driver\002,/\002    SGEEV (eigenvalues and eigevectors)"
	    "\002)";
    static char fmt_9978[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
	    "oblem Driver\002,/\002    SGEES (Schur form)\002)";
    static char fmt_9977[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
	    "oblem Expert\002,\002 Driver\002,/\002    SGEEVX (eigenvalues, e"
	    "igenvectors and\002,\002 condition numbers)\002)";
    static char fmt_9976[] = "(/\002 Tests of the Nonsymmetric Eigenvalue Pr"
	    "oblem Expert\002,\002 Driver\002,/\002    SGEESX (Schur form and"
	    " condition\002,\002 numbers)\002)";
    static char fmt_9975[] = "(/\002 Tests of the Generalized Nonsymmetric E"
	    "igenvalue \002,\002Problem routines\002)";
    static char fmt_9964[] = "(/\002 Tests of the Generalized Nonsymmetric E"
	    "igenvalue \002,\002Problem Driver SGGES\002)";
    static char fmt_9965[] = "(/\002 Tests of the Generalized Nonsymmetric E"
	    "igenvalue \002,\002Problem Expert Driver SGGESX\002)";
    static char fmt_9963[] = "(/\002 Tests of the Generalized Nonsymmetric E"
	    "igenvalue \002,\002Problem Driver SGGEV\002)";
    static char fmt_9962[] = "(/\002 Tests of the Generalized Nonsymmetric E"
	    "igenvalue \002,\002Problem Expert Driver SGGEVX\002)";
    static char fmt_9974[] = "(\002 Tests of SSBTRD\002,/\002 (reduction of "
	    "a symmetric band \002,\002matrix to tridiagonal form)\002)";
    static char fmt_9967[] = "(\002 Tests of SGBBRD\002,/\002 (reduction of "
	    "a general band \002,\002matrix to real bidiagonal form)\002)";
    static char fmt_9971[] = "(/\002 Tests of the Generalized Linear Regress"
	    "ion Model \002,\002routines\002)";
    static char fmt_9970[] = "(/\002 Tests of the Generalized QR and RQ rout"
	    "ines\002)";
    static char fmt_9969[] = "(/\002 Tests of the Generalized Singular Valu"
	    "e\002,\002 Decomposition routines\002)";
    static char fmt_9968[] = "(/\002 Tests of the Linear Least Squares routi"
	    "nes\002)";
    static char fmt_9992[] = "(1x,a3,\002:  Unrecognized path name\002)";
    static char fmt_9972[] = "(/\002 LAPACK VERSION \002,i1,\002.\002,i1,"
	    "\002.\002,i1)";
    static char fmt_9984[] = "(/\002 The following parameter values will be "
	    "used:\002)";
    static char fmt_9989[] = "(\002 Invalid input value: \002,a,\002=\002,"
	    "i6,\002; must be >=\002,i6)";
    static char fmt_9988[] = "(\002 Invalid input value: \002,a,\002=\002,"
	    "i6,\002; must be <=\002,i6)";
    static char fmt_9983[] = "(4x,a,10i6,/10x,10i6)";
    static char fmt_9981[] = "(\002 Relative machine \002,a,\002 is taken to"
	    " be\002,e16.6)";
    static char fmt_9982[] = "(/\002 Routines pass computational tests if te"
	    "st ratio is \002,\002less than\002,f8.2,/)";
    static char fmt_9999[] = "(/\002 Execution not attempted due to input er"
	    "rors\002)";
    static char fmt_9991[] = "(//\002 *** Invalid integer value in column"
	    " \002,i2,\002 of input\002,\002 line:\002,/a79)";
    static char fmt_9990[] = "(//1x,a3,\002 routines were not tested\002)";
    static char fmt_9961[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
	    "i4,\002, NX =\002,i4,\002, INMIN=\002,i4,\002, INWIN =\002,i4"
	    ",\002, INIBL =\002,i4,\002, ISHFTS =\002,i4,\002, IACC22 =\002,i"
	    "4)";
    static char fmt_9980[] = "(\002 *** Error code from \002,a,\002 = \002,i"
	    "4)";
    static char fmt_9997[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
	    "i4,\002, NX =\002,i4)";
    static char fmt_9995[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
	    "i4,\002, NX =\002,i4,\002, NRHS =\002,i4)";
    static char fmt_9973[] = "(/1x,71(\002-\002))";
    static char fmt_9996[] = "(//1x,a3,\002:  NB =\002,i4,\002, NBMIN =\002,"
	    "i4,\002, NS =\002,i4,\002, MAXB =\002,i4,\002, NBCOL =\002,i4)";
    static char fmt_9966[] = "(//1x,a3,\002:  NRHS =\002,i4)";
    static char fmt_9994[] = "(//\002 End of tests\002)";
    static char fmt_9993[] = "(\002 Total time used = \002,f12.2,\002 seco"
	    "nds\002,/)";

    /* System generated locals */
    integer i__1, i__2, i__3, i__4;
    real r__1;
    cilist ci__1;

    /* Builtin functions */
    integer s_rsfe(cilist *), do_fio(integer *, char *, ftnlen), e_rsfe(void);
    /* Subroutine */ int s_copy(char *, char *, ftnlen, ftnlen);
    integer s_cmp(char *, char *, ftnlen, ftnlen), s_wsfe(cilist *), e_wsfe(
	    void), s_rsle(cilist *), do_lio(integer *, integer *, char *, 
	    ftnlen), e_rsle(void), s_wsle(cilist *), e_wsle(void);
    /* Subroutine */ int s_stop(char *, ftnlen);
    integer i_len(char *, ftnlen);

    /* Local variables */
    real a[243936]	/* was [17424][14] */, b[87120]	/* was [17424][5] */, 
	    c__[160000]	/* was [400][400] */, d__[1584]	/* was [132][12] */;
    integer i__, k;
    real x[660];
    char c1[1], c3[3];
    integer i1;
    real s1, s2;
    integer ic, nk, nn, vers_patch__, vers_major__, vers_minor__;
    logical sbb, glm, sbk, sbl, nep, lse, sgg, sep, sgk, gqr, ses, sgl, sgs, 
	    sev, ssb, gsv, sgv, sgx, svd;
    real eps;
    logical ssx, svx, sxv;
    char line[80];
    real taua[132];
    integer info;
    char path[3];
    integer kval[20], lenp, mval[20], nval[20];
    real taub[132];
    integer pval[20], itmp, nrhs;
    real work[87781];
    integer iacc22[20];
    logical fatal;
    integer iseed[4], nbcol[20], inibl[20], nbval[20], nbmin[20];
    char vname[32];
    integer inmin[20], newsd, nsval[20], inwin[20], nxval[20], iwork[89760];
    extern /* Subroutine */ int schkbb_(integer *, integer *, integer *, 
	    integer *, integer *, integer *, logical *, integer *, integer *, 
	    real *, integer *, real *, integer *, real *, integer *, real *, 
	    real *, real *, integer *, real *, integer *, real *, integer *, 
	    real *, real *, integer *, real *, integer *), schkbd_(integer *, 
	    integer *, integer *, integer *, logical *, integer *, integer *, 
	    real *, real *, integer *, real *, real *, real *, real *, real *, 
	     integer *, real *, real *, real *, integer *, real *, integer *, 
	    real *, real *, real *, integer *, integer *, integer *, integer *
), schkec_(real *, logical *, integer *, integer *), alareq_(char 
	    *, integer *, logical *, integer *, integer *, integer *),
	     schkbk_(integer *, integer *);
    extern doublereal slamch_(char *);
    extern /* Subroutine */ int schkbl_(integer *, integer *), schkgg_(
	    integer *, integer *, integer *, logical *, integer *, real *, 
	    logical *, real *, integer *, real *, integer *, real *, real *, 
	    real *, real *, real *, real *, real *, real *, integer *, real *, 
	     real *, real *, real *, real *, real *, real *, real *, real *, 
	    real *, real *, real *, integer *, logical *, real *, integer *), 
	    schkgk_(integer *, integer *);
    extern doublereal second_(void);
    extern /* Subroutine */ int schkgl_(integer *, integer *), schksb_(
	    integer *, integer *, integer *, integer *, integer *, logical *, 
	    integer *, real *, integer *, real *, integer *, real *, real *, 
	    real *, integer *, real *, integer *, real *, integer *);
    extern logical lsamen_(integer *, char *, char *);
    extern /* Subroutine */ int sckglm_(integer *, integer *, integer *, 
	    integer *, integer *, integer *, real *, integer *, real *, real *
, real *, real *, real *, real *, real *, integer *, integer *, 
	    integer *), serrbd_(char *, integer *), ilaver_(integer *, 
	     integer *, integer *), schkhs_(integer *, integer *, integer *, 
	    logical *, integer *, real *, integer *, real *, integer *, real *
, real *, real *, real *, integer *, real *, real *, real *, real 
	    *, real *, real *, real *, real *, real *, real *, real *, real *, 
	     real *, integer *, integer *, logical *, real *, integer *), 
	    scklse_(integer *, integer *, integer *, integer *, integer *, 
	    integer *, real *, integer *, real *, real *, real *, real *, 
	    real *, real *, real *, integer *, integer *, integer *), sdrvbd_(
	    integer *, integer *, integer *, integer *, logical *, integer *, 
	    real *, real *, integer *, real *, integer *, real *, integer *, 
	    real *, real *, real *, real *, real *, real *, real *, integer *, 
	     integer *, integer *, integer *), serred_(char *, integer *), sdrges_(integer *, integer *, integer *, logical *, 
	    integer *, real *, integer *, real *, integer *, real *, real *, 
	    real *, real *, integer *, real *, real *, real *, real *, real *, 
	     integer *, real *, logical *, integer *);
    integer mxbval[20];
    extern /* Subroutine */ int sckgqr_(integer *, integer *, integer *, 
	    integer *, integer *, integer *, integer *, integer *, real *, 
	    integer *, real *, real *, real *, real *, real *, real *, real *, 
	     real *, real *, real *, real *, real *, real *, integer *, 
	    integer *, integer *), sdrgev_(integer *, integer *, integer *, 
	    logical *, integer *, real *, integer *, real *, integer *, real *
, real *, real *, real *, integer *, real *, real *, integer *, 
	    real *, real *, real *, real *, real *, real *, real *, integer *, 
	     real *, integer *), sdrvgg_(integer *, integer *, integer *, 
	    logical *, integer *, real *, real *, integer *, real *, integer *
, real *, real *, real *, real *, real *, real *, integer *, real 
	    *, real *, real *, real *, real *, real *, real *, real *, real *, 
	     real *, integer *, real *, integer *);
    logical tstdif;
    real thresh;
    extern /* Subroutine */ int schkst_(integer *, integer *, integer *, 
	    logical *, integer *, real *, integer *, real *, integer *, real *
, real *, real *, real *, real *, real *, real *, real *, real *, 
	    real *, real *, real *, real *, integer *, real *, real *, real *, 
	     real *, real *, integer *, integer *, integer *, real *, integer 
	    *);
    logical tstchk;
    integer nparms, ishfts[20];
    extern /* Subroutine */ int sckgsv_(integer *, integer *, integer *, 
	    integer *, integer *, integer *, real *, integer *, real *, real *
, real *, real *, real *, real *, real *, real *, real *, real *, 
	    integer *, real *, real *, integer *, integer *, integer *);
    logical dotype[30], logwrk[132];
    real thrshn;
    extern /* Subroutine */ int sdrves_(integer *, integer *, integer *, 
	    logical *, integer *, real *, integer *, real *, integer *, real *
, real *, real *, real *, real *, real *, real *, integer *, real 
	    *, real *, integer *, integer *, logical *, integer *), sdrvev_(
	    integer *, integer *, integer *, logical *, integer *, real *, 
	    integer *, real *, integer *, real *, real *, real *, real *, 
	    real *, real *, integer *, real *, integer *, real *, integer *, 
	    real *, real *, integer *, integer *, integer *), sdrgsx_(integer 
	    *, integer *, real *, integer *, integer *, real *, integer *, 
	    real *, real *, real *, real *, real *, real *, real *, real *, 
	    real *, integer *, real *, real *, integer *, integer *, integer *
, logical *, integer *), sdrvsg_(integer *, integer *, integer *, 
	    logical *, integer *, real *, integer *, real *, integer *, real *
, integer *, real *, real *, integer *, real *, real *, real *, 
	    real *, real *, integer *, integer *, integer *, real *, integer *
), serrgg_(char *, integer *), sdrgvx_(integer *, real *, 
	    integer *, integer *, real *, integer *, real *, real *, real *, 
	    real *, real *, real *, real *, real *, integer *, integer *, 
	    real *, real *, real *, real *, real *, real *, real *, integer *, 
	     integer *, integer *, real *, logical *, integer *);
    real result[500];
    extern /* Subroutine */ int serrhs_(char *, integer *), xlaenv_(
	    integer *, integer *);
    integer maxtyp;
    logical tsterr;
    integer ntypes;
    logical tstdrv;
    extern /* Subroutine */ int sdrvst_(integer *, integer *, integer *, 
	    logical *, integer *, real *, integer *, real *, integer *, real *
, real *, real *, real *, real *, real *, real *, real *, real *, 
	    integer *, real *, real *, real *, real *, integer *, integer *, 
	    integer *, real *, integer *), serrst_(char *, integer *),
	     sdrvsx_(integer *, integer *, integer *, logical *, integer *, 
	    real *, integer *, integer *, real *, integer *, real *, real *, 
	    real *, real *, real *, real *, real *, real *, real *, integer *, 
	     real *, real *, real *, integer *, integer *, logical *, integer 
	    *), sdrvvx_(integer *, integer *, integer *, logical *, integer *, 
	     real *, integer *, integer *, real *, integer *, real *, real *, 
	    real *, real *, real *, real *, integer *, real *, integer *, 
	    real *, integer *, real *, real *, real *, real *, real *, real *, 
	     real *, real *, real *, real *, integer *, integer *, integer *);

    /* Fortran I/O blocks */
    static cilist io___29 = { 0, 6, 0, fmt_9987, 0 };
    static cilist io___30 = { 0, 6, 0, fmt_9986, 0 };
    static cilist io___31 = { 0, 6, 0, fmt_9985, 0 };
    static cilist io___32 = { 0, 6, 0, fmt_9979, 0 };
    static cilist io___33 = { 0, 6, 0, fmt_9978, 0 };
    static cilist io___34 = { 0, 6, 0, fmt_9977, 0 };
    static cilist io___35 = { 0, 6, 0, fmt_9976, 0 };
    static cilist io___36 = { 0, 6, 0, fmt_9975, 0 };
    static cilist io___37 = { 0, 6, 0, fmt_9964, 0 };
    static cilist io___38 = { 0, 6, 0, fmt_9965, 0 };
    static cilist io___39 = { 0, 6, 0, fmt_9963, 0 };
    static cilist io___40 = { 0, 6, 0, fmt_9962, 0 };
    static cilist io___41 = { 0, 6, 0, fmt_9974, 0 };
    static cilist io___42 = { 0, 6, 0, fmt_9967, 0 };
    static cilist io___43 = { 0, 6, 0, fmt_9971, 0 };
    static cilist io___44 = { 0, 6, 0, fmt_9970, 0 };
    static cilist io___45 = { 0, 6, 0, fmt_9969, 0 };
    static cilist io___46 = { 0, 6, 0, fmt_9968, 0 };
    static cilist io___47 = { 0, 5, 0, 0, 0 };
    static cilist io___50 = { 0, 6, 0, fmt_9992, 0 };
    static cilist io___54 = { 0, 6, 0, fmt_9972, 0 };
    static cilist io___55 = { 0, 6, 0, fmt_9984, 0 };
    static cilist io___56 = { 0, 5, 0, 0, 0 };
    static cilist io___58 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___59 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___60 = { 0, 5, 0, 0, 0 };
    static cilist io___64 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___65 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___66 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___67 = { 0, 5, 0, 0, 0 };
    static cilist io___69 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___70 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___71 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___72 = { 0, 5, 0, 0, 0 };
    static cilist io___74 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___75 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___76 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___77 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___78 = { 0, 5, 0, 0, 0 };
    static cilist io___80 = { 0, 5, 0, 0, 0 };
    static cilist io___82 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___83 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___84 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___85 = { 0, 5, 0, 0, 0 };
    static cilist io___94 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___95 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___96 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___97 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___98 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___99 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___100 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___101 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___102 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___103 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___104 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___105 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___106 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___107 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___108 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___109 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___110 = { 0, 5, 0, 0, 0 };
    static cilist io___113 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___114 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___115 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___116 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___117 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___118 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___119 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___120 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___121 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___122 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___123 = { 0, 5, 0, 0, 0 };
    static cilist io___125 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___126 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___127 = { 0, 5, 0, 0, 0 };
    static cilist io___128 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___129 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___130 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___131 = { 0, 5, 0, 0, 0 };
    static cilist io___132 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___133 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___134 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___135 = { 0, 5, 0, 0, 0 };
    static cilist io___136 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___137 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___138 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___139 = { 0, 5, 0, 0, 0 };
    static cilist io___140 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___141 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___142 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___143 = { 0, 5, 0, 0, 0 };
    static cilist io___144 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___145 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___146 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___147 = { 0, 5, 0, 0, 0 };
    static cilist io___148 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___149 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___150 = { 0, 5, 0, 0, 0 };
    static cilist io___151 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___152 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___153 = { 0, 5, 0, 0, 0 };
    static cilist io___154 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___155 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___156 = { 0, 5, 0, 0, 0 };
    static cilist io___157 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___158 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___159 = { 0, 5, 0, 0, 0 };
    static cilist io___160 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___161 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___162 = { 0, 5, 0, 0, 0 };
    static cilist io___164 = { 0, 6, 0, fmt_9989, 0 };
    static cilist io___165 = { 0, 6, 0, fmt_9988, 0 };
    static cilist io___166 = { 0, 6, 0, fmt_9983, 0 };
    static cilist io___167 = { 0, 6, 0, 0, 0 };
    static cilist io___169 = { 0, 6, 0, fmt_9981, 0 };
    static cilist io___170 = { 0, 6, 0, fmt_9981, 0 };
    static cilist io___171 = { 0, 6, 0, fmt_9981, 0 };
    static cilist io___172 = { 0, 5, 0, 0, 0 };
    static cilist io___173 = { 0, 6, 0, fmt_9982, 0 };
    static cilist io___174 = { 0, 5, 0, 0, 0 };
    static cilist io___176 = { 0, 5, 0, 0, 0 };
    static cilist io___178 = { 0, 5, 0, 0, 0 };
    static cilist io___179 = { 0, 5, 0, 0, 0 };
    static cilist io___181 = { 0, 5, 0, 0, 0 };
    static cilist io___183 = { 0, 6, 0, fmt_9999, 0 };
    static cilist io___192 = { 0, 6, 0, fmt_9991, 0 };
    static cilist io___193 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___196 = { 0, 6, 0, fmt_9961, 0 };
    static cilist io___204 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___205 = { 0, 6, 0, fmt_9997, 0 };
    static cilist io___206 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___207 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___208 = { 0, 6, 0, fmt_9997, 0 };
    static cilist io___209 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___211 = { 0, 6, 0, fmt_9995, 0 };
    static cilist io___212 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___213 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___214 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___215 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___216 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___217 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___218 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___219 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___220 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___221 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___222 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___223 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___224 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___225 = { 0, 6, 0, fmt_9996, 0 };
    static cilist io___228 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___229 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___230 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___231 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___232 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___233 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___235 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___236 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___237 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___238 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___239 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___240 = { 0, 6, 0, fmt_9990, 0 };
    static cilist io___241 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___242 = { 0, 6, 0, fmt_9973, 0 };
    static cilist io___243 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___244 = { 0, 6, 0, fmt_9966, 0 };
    static cilist io___245 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___248 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___251 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___252 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___253 = { 0, 6, 0, fmt_9980, 0 };
    static cilist io___254 = { 0, 6, 0, 0, 0 };
    static cilist io___255 = { 0, 6, 0, 0, 0 };
    static cilist io___256 = { 0, 6, 0, fmt_9992, 0 };
    static cilist io___257 = { 0, 6, 0, fmt_9994, 0 };
    static cilist io___259 = { 0, 6, 0, fmt_9993, 0 };



/*  -- LAPACK test routine (version 3.1.1) -- */
/*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
/*     February 2007 */

/*  Purpose */
/*  ======= */

/*  SCHKEE tests the REAL LAPACK subroutines for the matrix */
/*  eigenvalue problem.  The test paths in this version are */

/*  NEP (Nonsymmetric Eigenvalue Problem): */
/*      Test SGEHRD, SORGHR, SHSEQR, STREVC, SHSEIN, and SORMHR */

/*  SEP (Symmetric Eigenvalue Problem): */
/*      Test SSYTRD, SORGTR, SSTEQR, SSTERF, SSTEIN, SSTEDC, */
/*      and drivers SSYEV(X), SSBEV(X), SSPEV(X), SSTEV(X), */
/*                  SSYEVD,   SSBEVD,   SSPEVD,   SSTEVD */

/*  SVD (Singular Value Decomposition): */
/*      Test SGEBRD, SORGBR, SBDSQR, SBDSDC */
/*      and the drivers SGESVD, SGESDD */

/*  SEV (Nonsymmetric Eigenvalue/eigenvector Driver): */
/*      Test SGEEV */

/*  SES (Nonsymmetric Schur form Driver): */
/*      Test SGEES */

/*  SVX (Nonsymmetric Eigenvalue/eigenvector Expert Driver): */
/*      Test SGEEVX */

/*  SSX (Nonsymmetric Schur form Expert Driver): */
/*      Test SGEESX */

/*  SGG (Generalized Nonsymmetric Eigenvalue Problem): */
/*      Test SGGHRD, SGGBAL, SGGBAK, SHGEQZ, and STGEVC */
/*      and the driver routines SGEGS and SGEGV */

/*  SGS (Generalized Nonsymmetric Schur form Driver): */
/*      Test SGGES */

/*  SGV (Generalized Nonsymmetric Eigenvalue/eigenvector Driver): */
/*      Test SGGEV */

/*  SGX (Generalized Nonsymmetric Schur form Expert Driver): */
/*      Test SGGESX */

/*  SXV (Generalized Nonsymmetric Eigenvalue/eigenvector Expert Driver): */
/*      Test SGGEVX */

/*  SSG (Symmetric Generalized Eigenvalue Problem): */
/*      Test SSYGST, SSYGV, SSYGVD, SSYGVX, SSPGST, SSPGV, SSPGVD, */
/*      SSPGVX, SSBGST, SSBGV, SSBGVD, and SSBGVX */

/*  SSB (Symmetric Band Eigenvalue Problem): */
/*      Test SSBTRD */

/*  SBB (Band Singular Value Decomposition): */
/*      Test SGBBRD */

/*  SEC (Eigencondition estimation): */
/*      Test SLALN2, SLASY2, SLAEQU, SLAEXC, STRSYL, STREXC, STRSNA, */
/*      STRSEN, and SLAQTR */

/*  SBL (Balancing a general matrix) */
/*      Test SGEBAL */

/*  SBK (Back transformation on a balanced matrix) */
/*      Test SGEBAK */

/*  SGL (Balancing a matrix pair) */
/*      Test SGGBAL */

/*  SGK (Back transformation on a matrix pair) */
/*      Test SGGBAK */

/*  GLM (Generalized Linear Regression Model): */
/*      Tests SGGGLM */

/*  GQR (Generalized QR and RQ factorizations): */
/*      Tests SGGQRF and SGGRQF */

/*  GSV (Generalized Singular Value Decomposition): */
/*      Tests SGGSVD, SGGSVP, STGSJA, SLAGS2, SLAPLL, and SLAPMT */

/*  LSE (Constrained Linear Least Squares): */
/*      Tests SGGLSE */

/*  Each test path has a different set of inputs, but the data sets for */
/*  the driver routines xEV, xES, xVX, and xSX can be concatenated in a */
/*  single input file.  The first line of input should contain one of the */
/*  3-character path names in columns 1-3.  The number of remaining lines */
/*  depends on what is found on the first line. */

/*  The number of matrix types used in testing is often controllable from */
/*  the input file.  The number of matrix types for each path, and the */
/*  test routine that describes them, is as follows: */

/*  Path name(s)  Types    Test routine */

/*  SHS or NEP      21     SCHKHS */
/*  SST or SEP      21     SCHKST (routines) */
/*                  18     SDRVST (drivers) */
/*  SBD or SVD      16     SCHKBD (routines) */
/*                   5     SDRVBD (drivers) */
/*  SEV             21     SDRVEV */
/*  SES             21     SDRVES */
/*  SVX             21     SDRVVX */
/*  SSX             21     SDRVSX */
/*  SGG             26     SCHKGG (routines) */
/*                  26     SDRVGG (drivers) */
/*  SGS             26     SDRGES */
/*  SGX              5     SDRGSX */
/*  SGV             26     SDRGEV */
/*  SXV              2     SDRGVX */
/*  SSG             21     SDRVSG */
/*  SSB             15     SCHKSB */
/*  SBB             15     SCHKBB */
/*  SEC              -     SCHKEC */
/*  SBL              -     SCHKBL */
/*  SBK              -     SCHKBK */
/*  SGL              -     SCHKGL */
/*  SGK              -     SCHKGK */
/*  GLM              8     SCKGLM */
/*  GQR              8     SCKGQR */
/*  GSV              8     SCKGSV */
/*  LSE              8     SCKLSE */

/* ----------------------------------------------------------------------- */

/*  NEP input file: */

/*  line 2:  NN, INTEGER */
/*           Number of values of N. */

/*  line 3:  NVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix dimension N. */

/*  line 4:  NPARMS, INTEGER */
/*           Number of values of the parameters NB, NBMIN, NX, NS, and */
/*           MAXB. */

/*  line 5:  NBVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the blocksize NB. */

/*  line 6:  NBMIN, INTEGER array, dimension (NPARMS) */
/*           The values for the minimum blocksize NBMIN. */

/*  line 7:  NXVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the crossover point NX. */

/*  line 8:  INMIN, INTEGER array, dimension (NPARMS) */
/*           LAHQR vs TTQRE crossover point, >= 11 */

/*  line 9:  INWIN, INTEGER array, dimension (NPARMS) */
/*           recommended deflation window size */

/*  line 10: INIBL, INTEGER array, dimension (NPARMS) */
/*           nibble crossover point */

/*  line 11:  ISHFTS, INTEGER array, dimension (NPARMS) */
/*           number of simultaneous shifts) */

/*  line 12:  IACC22, INTEGER array, dimension (NPARMS) */
/*           select structured matrix multiply: 0, 1 or 2) */

/*  line 13: THRESH */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold.  To have all of the test */
/*           ratios printed, use THRESH = 0.0 . */

/*  line 14: NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 14 was 2: */

/*  line 15: INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 15-EOF:  The remaining lines occur in sets of 1 or 2 and allow */
/*           the user to specify the matrix types.  Each line contains */
/*           a 3-character path name in columns 1-3, and the number */
/*           of matrix types must be the first nonblank item in columns */
/*           4-80.  If the number of matrix types is at least 1 but is */
/*           less than the maximum number of possible types, a second */
/*           line will be read to get the numbers of the matrix types to */
/*           be used.  For example, */
/*  NEP 21 */
/*           requests all of the matrix types for the nonsymmetric */
/*           eigenvalue problem, while */
/*  NEP  4 */
/*  9 10 11 12 */
/*           requests only matrices of type 9, 10, 11, and 12. */

/*           The valid 3-character path names are 'NEP' or 'SHS' for the */
/*           nonsymmetric eigenvalue routines. */

/* ----------------------------------------------------------------------- */

/*  SEP or SSG input file: */

/*  line 2:  NN, INTEGER */
/*           Number of values of N. */

/*  line 3:  NVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix dimension N. */

/*  line 4:  NPARMS, INTEGER */
/*           Number of values of the parameters NB, NBMIN, and NX. */

/*  line 5:  NBVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the blocksize NB. */

/*  line 6:  NBMIN, INTEGER array, dimension (NPARMS) */
/*           The values for the minimum blocksize NBMIN. */

/*  line 7:  NXVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the crossover point NX. */

/*  line 8:  THRESH */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 9:  TSTCHK, LOGICAL */
/*           Flag indicating whether or not to test the LAPACK routines. */

/*  line 10: TSTDRV, LOGICAL */
/*           Flag indicating whether or not to test the driver routines. */

/*  line 11: TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 12: NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 12 was 2: */

/*  line 13: INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 13-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path names are 'SEP' or 'SST' for the */
/*           symmetric eigenvalue routines and driver routines, and */
/*           'SSG' for the routines for the symmetric generalized */
/*           eigenvalue problem. */

/* ----------------------------------------------------------------------- */

/*  SVD input file: */

/*  line 2:  NN, INTEGER */
/*           Number of values of M and N. */

/*  line 3:  MVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix row dimension M. */

/*  line 4:  NVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix column dimension N. */

/*  line 5:  NPARMS, INTEGER */
/*           Number of values of the parameter NB, NBMIN, NX, and NRHS. */

/*  line 6:  NBVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the blocksize NB. */

/*  line 7:  NBMIN, INTEGER array, dimension (NPARMS) */
/*           The values for the minimum blocksize NBMIN. */

/*  line 8:  NXVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the crossover point NX. */

/*  line 9:  NSVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the number of right hand sides NRHS. */

/*  line 10: THRESH */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 11: TSTCHK, LOGICAL */
/*           Flag indicating whether or not to test the LAPACK routines. */

/*  line 12: TSTDRV, LOGICAL */
/*           Flag indicating whether or not to test the driver routines. */

/*  line 13: TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 14: NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 14 was 2: */

/*  line 15: INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 15-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path names are 'SVD' or 'SBD' for both the */
/*           SVD routines and the SVD driver routines. */

/* ----------------------------------------------------------------------- */

/*  SEV and SES data files: */

/*  line 1:  'SEV' or 'SES' in columns 1 to 3. */

/*  line 2:  NSIZES, INTEGER */
/*           Number of sizes of matrices to use. Should be at least 0 */
/*           and at most 20. If NSIZES = 0, no testing is done */
/*           (although the remaining  3 lines are still read). */

/*  line 3:  NN, INTEGER array, dimension(NSIZES) */
/*           Dimensions of matrices to be tested. */

/*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
/*           These integer parameters determine how blocking is done */
/*           (see ILAENV for details) */
/*           NB     : block size */
/*           NBMIN  : minimum block size */
/*           NX     : minimum dimension for blocking */
/*           NS     : number of shifts in xHSEQR */
/*           NBCOL  : minimum column dimension for blocking */

/*  line 5:  THRESH, REAL */
/*           The test threshold against which computed residuals are */
/*           compared. Should generally be in the range from 10. to 20. */
/*           If it is 0., all test case data will be printed. */

/*  line 6:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits. */

/*  line 7:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 7 was 2: */

/*  line 8:  INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 9 and following:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'SEV' to test SGEEV, or */
/*           'SES' to test SGEES. */

/* ----------------------------------------------------------------------- */

/*  The SVX data has two parts. The first part is identical to SEV, */
/*  and the second part consists of test matrices with precomputed */
/*  solutions. */

/*  line 1:  'SVX' in columns 1-3. */

/*  line 2:  NSIZES, INTEGER */
/*           If NSIZES = 0, no testing of randomly generated examples */
/*           is done, but any precomputed examples are tested. */

/*  line 3:  NN, INTEGER array, dimension(NSIZES) */

/*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */

/*  line 5:  THRESH, REAL */

/*  line 6:  TSTERR, LOGICAL */

/*  line 7:  NEWSD, INTEGER */

/*  If line 7 was 2: */

/*  line 8:  INTEGER array, dimension (4) */

/*  lines 9 and following: The first line contains 'SVX' in columns 1-3 */
/*           followed by the number of matrix types, possibly with */
/*           a second line to specify certain matrix types. */
/*           If the number of matrix types = 0, no testing of randomly */
/*           generated examples is done, but any precomputed examples */
/*           are tested. */

/*  remaining lines : Each matrix is stored on 1+2*N lines, where N is */
/*           its dimension. The first line contains the dimension (a */
/*           single integer). The next N lines contain the matrix, one */
/*           row per line. The last N lines correspond to each */
/*           eigenvalue. Each of these last N lines contains 4 real */
/*           values: the real part of the eigenvalue, the imaginary */
/*           part of the eigenvalue, the reciprocal condition number of */
/*           the eigenvalues, and the reciprocal condition number of the */
/*           eigenvector.  The end of data is indicated by dimension N=0. */
/*           Even if no data is to be tested, there must be at least one */
/*           line containing N=0. */

/* ----------------------------------------------------------------------- */

/*  The SSX data is like SVX. The first part is identical to SEV, and the */
/*  second part consists of test matrices with precomputed solutions. */

/*  line 1:  'SSX' in columns 1-3. */

/*  line 2:  NSIZES, INTEGER */
/*           If NSIZES = 0, no testing of randomly generated examples */
/*           is done, but any precomputed examples are tested. */

/*  line 3:  NN, INTEGER array, dimension(NSIZES) */

/*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */

/*  line 5:  THRESH, REAL */

/*  line 6:  TSTERR, LOGICAL */

/*  line 7:  NEWSD, INTEGER */

/*  If line 7 was 2: */

/*  line 8:  INTEGER array, dimension (4) */

/*  lines 9 and following: The first line contains 'SSX' in columns 1-3 */
/*           followed by the number of matrix types, possibly with */
/*           a second line to specify certain matrix types. */
/*           If the number of matrix types = 0, no testing of randomly */
/*           generated examples is done, but any precomputed examples */
/*           are tested. */

/*  remaining lines : Each matrix is stored on 3+N lines, where N is its */
/*           dimension. The first line contains the dimension N and the */
/*           dimension M of an invariant subspace. The second line */
/*           contains M integers, identifying the eigenvalues in the */
/*           invariant subspace (by their position in a list of */
/*           eigenvalues ordered by increasing real part). The next N */
/*           lines contain the matrix. The last line contains the */
/*           reciprocal condition number for the average of the selected */
/*           eigenvalues, and the reciprocal condition number for the */
/*           corresponding right invariant subspace. The end of data is */
/*           indicated by a line containing N=0 and M=0. Even if no data */
/*           is to be tested, there must be at least one line containing */
/*           N=0 and M=0. */

/* ----------------------------------------------------------------------- */

/*  SGG input file: */

/*  line 2:  NN, INTEGER */
/*           Number of values of N. */

/*  line 3:  NVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix dimension N. */

/*  line 4:  NPARMS, INTEGER */
/*           Number of values of the parameters NB, NBMIN, NS, MAXB, and */
/*           NBCOL. */

/*  line 5:  NBVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the blocksize NB. */

/*  line 6:  NBMIN, INTEGER array, dimension (NPARMS) */
/*           The values for NBMIN, the minimum row dimension for blocks. */

/*  line 7:  NSVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the number of shifts. */

/*  line 8:  MXBVAL, INTEGER array, dimension (NPARMS) */
/*           The values for MAXB, used in determining minimum blocksize. */

/*  line 9:  NBCOL, INTEGER array, dimension (NPARMS) */
/*           The values for NBCOL, the minimum column dimension for */
/*           blocks. */

/*  line 10: THRESH */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 11: TSTCHK, LOGICAL */
/*           Flag indicating whether or not to test the LAPACK routines. */

/*  line 12: TSTDRV, LOGICAL */
/*           Flag indicating whether or not to test the driver routines. */

/*  line 13: TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 14: NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 14 was 2: */

/*  line 15: INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 15-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'SGG' for the generalized */
/*           eigenvalue problem routines and driver routines. */

/* ----------------------------------------------------------------------- */

/*  SGS and SGV input files: */

/*  line 1:  'SGS' or 'SGV' in columns 1 to 3. */

/*  line 2:  NN, INTEGER */
/*           Number of values of N. */

/*  line 3:  NVAL, INTEGER array, dimension(NN) */
/*           Dimensions of matrices to be tested. */

/*  line 4:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
/*           These integer parameters determine how blocking is done */
/*           (see ILAENV for details) */
/*           NB     : block size */
/*           NBMIN  : minimum block size */
/*           NX     : minimum dimension for blocking */
/*           NS     : number of shifts in xHGEQR */
/*           NBCOL  : minimum column dimension for blocking */

/*  line 5:  THRESH, REAL */
/*           The test threshold against which computed residuals are */
/*           compared. Should generally be in the range from 10. to 20. */
/*           If it is 0., all test case data will be printed. */

/*  line 6:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits. */

/*  line 7:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 17 was 2: */

/*  line 7:  INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 7-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'SGS' for the generalized */
/*           eigenvalue problem routines and driver routines. */

/* ----------------------------------------------------------------------- */

/*  SXV input files: */

/*  line 1:  'SXV' in columns 1 to 3. */

/*  line 2:  N, INTEGER */
/*           Value of N. */

/*  line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
/*           These integer parameters determine how blocking is done */
/*           (see ILAENV for details) */
/*           NB     : block size */
/*           NBMIN  : minimum block size */
/*           NX     : minimum dimension for blocking */
/*           NS     : number of shifts in xHGEQR */
/*           NBCOL  : minimum column dimension for blocking */

/*  line 4:  THRESH, REAL */
/*           The test threshold against which computed residuals are */
/*           compared. Should generally be in the range from 10. to 20. */
/*           Information will be printed about each test for which the */
/*           test ratio is greater than or equal to the threshold. */

/*  line 5:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 6:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 6 was 2: */

/*  line 7: INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  If line 2 was 0: */

/*  line 7-EOF: Precomputed examples are tested. */

/*  remaining lines : Each example is stored on 3+2*N lines, where N is */
/*           its dimension. The first line contains the dimension (a */
/*           single integer). The next N lines contain the matrix A, one */
/*           row per line. The next N lines contain the matrix B.  The */
/*           next line contains the reciprocals of the eigenvalue */
/*           condition numbers.  The last line contains the reciprocals of */
/*           the eigenvector condition numbers.  The end of data is */
/*           indicated by dimension N=0.  Even if no data is to be tested, */
/*           there must be at least one line containing N=0. */

/* ----------------------------------------------------------------------- */

/*  SGX input files: */

/*  line 1:  'SGX' in columns 1 to 3. */

/*  line 2:  N, INTEGER */
/*           Value of N. */

/*  line 3:  NB, NBMIN, NX, NS, NBCOL, INTEGERs */
/*           These integer parameters determine how blocking is done */
/*           (see ILAENV for details) */
/*           NB     : block size */
/*           NBMIN  : minimum block size */
/*           NX     : minimum dimension for blocking */
/*           NS     : number of shifts in xHGEQR */
/*           NBCOL  : minimum column dimension for blocking */

/*  line 4:  THRESH, REAL */
/*           The test threshold against which computed residuals are */
/*           compared. Should generally be in the range from 10. to 20. */
/*           Information will be printed about each test for which the */
/*           test ratio is greater than or equal to the threshold. */

/*  line 5:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 6:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 6 was 2: */

/*  line 7: INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  If line 2 was 0: */

/*  line 7-EOF: Precomputed examples are tested. */

/*  remaining lines : Each example is stored on 3+2*N lines, where N is */
/*           its dimension. The first line contains the dimension (a */
/*           single integer).  The next line contains an integer k such */
/*           that only the last k eigenvalues will be selected and appear */
/*           in the leading diagonal blocks of $A$ and $B$. The next N */
/*           lines contain the matrix A, one row per line.  The next N */
/*           lines contain the matrix B.  The last line contains the */
/*           reciprocal of the eigenvalue cluster condition number and the */
/*           reciprocal of the deflating subspace (associated with the */
/*           selected eigencluster) condition number.  The end of data is */
/*           indicated by dimension N=0.  Even if no data is to be tested, */
/*           there must be at least one line containing N=0. */

/* ----------------------------------------------------------------------- */

/*  SSB input file: */

/*  line 2:  NN, INTEGER */
/*           Number of values of N. */

/*  line 3:  NVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix dimension N. */

/*  line 4:  NK, INTEGER */
/*           Number of values of K. */

/*  line 5:  KVAL, INTEGER array, dimension (NK) */
/*           The values for the matrix dimension K. */

/*  line 6:  THRESH */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 7:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 7 was 2: */

/*  line 8:  INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 8-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'SSB'. */

/* ----------------------------------------------------------------------- */

/*  SBB input file: */

/*  line 2:  NN, INTEGER */
/*           Number of values of M and N. */

/*  line 3:  MVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix row dimension M. */

/*  line 4:  NVAL, INTEGER array, dimension (NN) */
/*           The values for the matrix column dimension N. */

/*  line 4:  NK, INTEGER */
/*           Number of values of K. */

/*  line 5:  KVAL, INTEGER array, dimension (NK) */
/*           The values for the matrix bandwidth K. */

/*  line 6:  NPARMS, INTEGER */
/*           Number of values of the parameter NRHS */

/*  line 7:  NSVAL, INTEGER array, dimension (NPARMS) */
/*           The values for the number of right hand sides NRHS. */

/*  line 8:  THRESH */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 9:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 9 was 2: */

/*  line 10: INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 10-EOF:  Lines specifying matrix types, as for SVD. */
/*           The 3-character path name is 'SBB'. */

/* ----------------------------------------------------------------------- */

/*  SEC input file: */

/*  line  2: THRESH, REAL */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  lines  3-EOF: */

/*  Input for testing the eigencondition routines consists of a set of */
/*  specially constructed test cases and their solutions.  The data */
/*  format is not intended to be modified by the user. */

/* ----------------------------------------------------------------------- */

/*  SBL and SBK input files: */

/*  line 1:  'SBL' in columns 1-3 to test SGEBAL, or 'SBK' in */
/*           columns 1-3 to test SGEBAK. */

/*  The remaining lines consist of specially constructed test cases. */

/* ----------------------------------------------------------------------- */

/*  SGL and SGK input files: */

/*  line 1:  'SGL' in columns 1-3 to test SGGBAL, or 'SGK' in */
/*           columns 1-3 to test SGGBAK. */

/*  The remaining lines consist of specially constructed test cases. */

/* ----------------------------------------------------------------------- */

/*  GLM data file: */

/*  line 1:  'GLM' in columns 1 to 3. */

/*  line 2:  NN, INTEGER */
/*           Number of values of M, P, and N. */

/*  line 3:  MVAL, INTEGER array, dimension(NN) */
/*           Values of M (row dimension). */

/*  line 4:  PVAL, INTEGER array, dimension(NN) */
/*           Values of P (row dimension). */

/*  line 5:  NVAL, INTEGER array, dimension(NN) */
/*           Values of N (column dimension), note M <= N <= M+P. */

/*  line 6:  THRESH, REAL */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 7:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 8:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 8 was 2: */

/*  line 9:  INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'GLM' for the generalized */
/*           linear regression model routines. */

/* ----------------------------------------------------------------------- */

/*  GQR data file: */

/*  line 1:  'GQR' in columns 1 to 3. */

/*  line 2:  NN, INTEGER */
/*           Number of values of M, P, and N. */

/*  line 3:  MVAL, INTEGER array, dimension(NN) */
/*           Values of M. */

/*  line 4:  PVAL, INTEGER array, dimension(NN) */
/*           Values of P. */

/*  line 5:  NVAL, INTEGER array, dimension(NN) */
/*           Values of N. */

/*  line 6:  THRESH, REAL */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 7:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 8:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 8 was 2: */

/*  line 9:  INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'GQR' for the generalized */
/*           QR and RQ routines. */

/* ----------------------------------------------------------------------- */

/*  GSV data file: */

/*  line 1:  'GSV' in columns 1 to 3. */

/*  line 2:  NN, INTEGER */
/*           Number of values of M, P, and N. */

/*  line 3:  MVAL, INTEGER array, dimension(NN) */
/*           Values of M (row dimension). */

/*  line 4:  PVAL, INTEGER array, dimension(NN) */
/*           Values of P (row dimension). */

/*  line 5:  NVAL, INTEGER array, dimension(NN) */
/*           Values of N (column dimension). */

/*  line 6:  THRESH, REAL */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 7:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 8:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 8 was 2: */

/*  line 9:  INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'GSV' for the generalized */
/*           SVD routines. */

/* ----------------------------------------------------------------------- */

/*  LSE data file: */

/*  line 1:  'LSE' in columns 1 to 3. */

/*  line 2:  NN, INTEGER */
/*           Number of values of M, P, and N. */

/*  line 3:  MVAL, INTEGER array, dimension(NN) */
/*           Values of M. */

/*  line 4:  PVAL, INTEGER array, dimension(NN) */
/*           Values of P. */

/*  line 5:  NVAL, INTEGER array, dimension(NN) */
/*           Values of N, note P <= N <= P+M. */

/*  line 6:  THRESH, REAL */
/*           Threshold value for the test ratios.  Information will be */
/*           printed about each test for which the test ratio is greater */
/*           than or equal to the threshold. */

/*  line 7:  TSTERR, LOGICAL */
/*           Flag indicating whether or not to test the error exits for */
/*           the LAPACK routines and driver routines. */

/*  line 8:  NEWSD, INTEGER */
/*           A code indicating how to set the random number seed. */
/*           = 0:  Set the seed to a default value before each run */
/*           = 1:  Initialize the seed to a default value only before the */
/*                 first run */
/*           = 2:  Like 1, but use the seed values on the next line */

/*  If line 8 was 2: */

/*  line 9:  INTEGER array, dimension (4) */
/*           Four integer values for the random number seed. */

/*  lines 9-EOF:  Lines specifying matrix types, as for NEP. */
/*           The 3-character path name is 'GSV' for the generalized */
/*           SVD routines. */

/* ----------------------------------------------------------------------- */

/*  NMAX is currently set to 132 and must be at least 12 for some of the */
/*  precomputed examples, and LWORK = NMAX*(5*NMAX+5)+1 in the parameter */
/*  statements below.  For SVD, we assume NRHS may be as big as N.  The */
/*  parameter NEED is set to 14 to allow for 14 N-by-N matrices for SGG. */

/*  ===================================================================== */

/*     .. Parameters .. */
/*     .. */
/*     .. Local Scalars .. */
/*     .. */
/*     .. Local Arrays .. */
/*     .. */
/*     .. External Functions .. */
/*     .. */
/*     .. External Subroutines .. */
/*     .. */
/*     .. Intrinsic Functions .. */
/*     .. */
/*     .. Scalars in Common .. */
/*     .. */
/*     .. Arrays in Common .. */
/*     .. */
/*     .. Common blocks .. */
/*     .. */
/*     .. Data statements .. */
/*     .. */
/*     .. Executable Statements .. */

    s1 = second_();
    fatal = FALSE_;
    infoc_1.nunit = 6;

/*     Return to here to read multiple sets of data */

L10:

/*     Read the first line and set the 3-character test path */

    ci__1.cierr = 0;
    ci__1.ciend = 1;
    ci__1.ciunit = 5;
    ci__1.cifmt = "(A80)";
    i__1 = s_rsfe(&ci__1);
    if (i__1 != 0) {
	goto L380;
    }
    i__1 = do_fio(&c__1, line, (ftnlen)80);
    if (i__1 != 0) {
	goto L380;
    }
    i__1 = e_rsfe();
    if (i__1 != 0) {
	goto L380;
    }
    s_copy(path, line, (ftnlen)3, (ftnlen)3);
    nep = lsamen_(&c__3, path, "NEP") || lsamen_(&c__3, 
	    path, "SHS");
    sep = lsamen_(&c__3, path, "SEP") || lsamen_(&c__3, 
	    path, "SST") || lsamen_(&c__3, path, "SSG");
    svd = lsamen_(&c__3, path, "SVD") || lsamen_(&c__3, 
	    path, "SBD");
    sev = lsamen_(&c__3, path, "SEV");
    ses = lsamen_(&c__3, path, "SES");
    svx = lsamen_(&c__3, path, "SVX");
    ssx = lsamen_(&c__3, path, "SSX");
    sgg = lsamen_(&c__3, path, "SGG");
    sgs = lsamen_(&c__3, path, "SGS");
    sgx = lsamen_(&c__3, path, "SGX");
    sgv = lsamen_(&c__3, path, "SGV");
    sxv = lsamen_(&c__3, path, "SXV");
    ssb = lsamen_(&c__3, path, "SSB");
    sbb = lsamen_(&c__3, path, "SBB");
    glm = lsamen_(&c__3, path, "GLM");
    gqr = lsamen_(&c__3, path, "GQR") || lsamen_(&c__3, 
	    path, "GRQ");
    gsv = lsamen_(&c__3, path, "GSV");
    lse = lsamen_(&c__3, path, "LSE");
    sbl = lsamen_(&c__3, path, "SBL");
    sbk = lsamen_(&c__3, path, "SBK");
    sgl = lsamen_(&c__3, path, "SGL");
    sgk = lsamen_(&c__3, path, "SGK");

/*     Report values of parameters. */

    if (s_cmp(path, "   ", (ftnlen)3, (ftnlen)3) == 0) {
	goto L10;
    } else if (nep) {
	s_wsfe(&io___29);
	e_wsfe();
    } else if (sep) {
	s_wsfe(&io___30);
	e_wsfe();
    } else if (svd) {
	s_wsfe(&io___31);
	e_wsfe();
    } else if (sev) {
	s_wsfe(&io___32);
	e_wsfe();
    } else if (ses) {
	s_wsfe(&io___33);
	e_wsfe();
    } else if (svx) {
	s_wsfe(&io___34);
	e_wsfe();
    } else if (ssx) {
	s_wsfe(&io___35);
	e_wsfe();
    } else if (sgg) {
	s_wsfe(&io___36);
	e_wsfe();
    } else if (sgs) {
	s_wsfe(&io___37);
	e_wsfe();
    } else if (sgx) {
	s_wsfe(&io___38);
	e_wsfe();
    } else if (sgv) {
	s_wsfe(&io___39);
	e_wsfe();
    } else if (sxv) {
	s_wsfe(&io___40);
	e_wsfe();
    } else if (ssb) {
	s_wsfe(&io___41);
	e_wsfe();
    } else if (sbb) {
	s_wsfe(&io___42);
	e_wsfe();
    } else if (glm) {
	s_wsfe(&io___43);
	e_wsfe();
    } else if (gqr) {
	s_wsfe(&io___44);
	e_wsfe();
    } else if (gsv) {
	s_wsfe(&io___45);
	e_wsfe();
    } else if (lse) {
	s_wsfe(&io___46);
	e_wsfe();
    } else if (sbl) {

/*        SGEBAL:  Balancing */

	schkbl_(&c__5, &c__6);
	goto L10;
    } else if (sbk) {

/*        SGEBAK:  Back transformation */

	schkbk_(&c__5, &c__6);
	goto L10;
    } else if (sgl) {

/*        SGGBAL:  Balancing */

	schkgl_(&c__5, &c__6);
	goto L10;
    } else if (sgk) {

/*        SGGBAK:  Back transformation */

	schkgk_(&c__5, &c__6);
	goto L10;
    } else if (lsamen_(&c__3, path, "SEC")) {

/*        SEC:  Eigencondition estimation */

	s_rsle(&io___47);
	do_lio(&c__4, &c__1, (char *)&thresh, (ftnlen)sizeof(real));
	e_rsle();
	xlaenv_(&c__1, &c__1);
	xlaenv_(&c__12, &c__11);
	xlaenv_(&c__13, &c__2);
	xlaenv_(&c__14, &c__0);
	xlaenv_(&c__15, &c__2);
	xlaenv_(&c__16, &c__2);
	tsterr = TRUE_;
	schkec_(&thresh, &tsterr, &c__5, &c__6);
	goto L10;
    } else {
	s_wsfe(&io___50);
	do_fio(&c__1, path, (ftnlen)3);
	e_wsfe();
	goto L10;
    }
    ilaver_(&vers_major__, &vers_minor__, &vers_patch__);
    s_wsfe(&io___54);
    do_fio(&c__1, (char *)&vers_major__, (ftnlen)sizeof(integer));
    do_fio(&c__1, (char *)&vers_minor__, (ftnlen)sizeof(integer));
    do_fio(&c__1, (char *)&vers_patch__, (ftnlen)sizeof(integer));
    e_wsfe();
    s_wsfe(&io___55);
    e_wsfe();

/*     Read the number of values of M, P, and N. */

    s_rsle(&io___56);
    do_lio(&c__3, &c__1, (char *)&nn, (ftnlen)sizeof(integer));
    e_rsle();
    if (nn < 0) {
	s_wsfe(&io___58);
	do_fio(&c__1, "   NN ", (ftnlen)6);
	do_fio(&c__1, (char *)&nn, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	e_wsfe();
	nn = 0;
	fatal = TRUE_;
    } else if (nn > 20) {
	s_wsfe(&io___59);
	do_fio(&c__1, "   NN ", (ftnlen)6);
	do_fio(&c__1, (char *)&nn, (ftnlen)sizeof(integer));
	do_fio(&c__1, (char *)&c__20, (ftnlen)sizeof(integer));
	e_wsfe();
	nn = 0;
	fatal = TRUE_;
    }

/*     Read the values of M */

    if (! (sgx || sxv)) {
	s_rsle(&io___60);
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_lio(&c__3, &c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(
		    integer));
	}
	e_rsle();
	if (svd) {
	    s_copy(vname, "    M ", (ftnlen)32, (ftnlen)6);
	} else {
	    s_copy(vname, "    N ", (ftnlen)32, (ftnlen)6);
	}
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (mval[i__ - 1] < 0) {
		s_wsfe(&io___64);
		do_fio(&c__1, vname, (ftnlen)32);
		do_fio(&c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    } else if (mval[i__ - 1] > 132) {
		s_wsfe(&io___65);
		do_fio(&c__1, vname, (ftnlen)32);
		do_fio(&c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    }
/* L20: */
	}
	s_wsfe(&io___66);
	do_fio(&c__1, "M:    ", (ftnlen)6);
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_fio(&c__1, (char *)&mval[i__ - 1], (ftnlen)sizeof(integer));
	}
	e_wsfe();
    }

/*     Read the values of P */

    if (glm || gqr || gsv || lse) {
	s_rsle(&io___67);
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_lio(&c__3, &c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(
		    integer));
	}
	e_rsle();
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (pval[i__ - 1] < 0) {
		s_wsfe(&io___69);
		do_fio(&c__1, " P  ", (ftnlen)4);
		do_fio(&c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    } else if (pval[i__ - 1] > 132) {
		s_wsfe(&io___70);
		do_fio(&c__1, " P  ", (ftnlen)4);
		do_fio(&c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    }
/* L30: */
	}
	s_wsfe(&io___71);
	do_fio(&c__1, "P:    ", (ftnlen)6);
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_fio(&c__1, (char *)&pval[i__ - 1], (ftnlen)sizeof(integer));
	}
	e_wsfe();
    }

/*     Read the values of N */

    if (svd || sbb || glm || gqr || gsv || lse) {
	s_rsle(&io___72);
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_lio(&c__3, &c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(
		    integer));
	}
	e_rsle();
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (nval[i__ - 1] < 0) {
		s_wsfe(&io___74);
		do_fio(&c__1, "    N ", (ftnlen)6);
		do_fio(&c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    } else if (nval[i__ - 1] > 132) {
		s_wsfe(&io___75);
		do_fio(&c__1, "    N ", (ftnlen)6);
		do_fio(&c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    }
/* L40: */
	}
    } else {
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    nval[i__ - 1] = mval[i__ - 1];
/* L50: */
	}
    }
    if (! (sgx || sxv)) {
	s_wsfe(&io___76);
	do_fio(&c__1, "N:    ", (ftnlen)6);
	i__1 = nn;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_fio(&c__1, (char *)&nval[i__ - 1], (ftnlen)sizeof(integer));
	}
	e_wsfe();
    } else {
	s_wsfe(&io___77);
	do_fio(&c__1, "N:    ", (ftnlen)6);
	do_fio(&c__1, (char *)&nn, (ftnlen)sizeof(integer));
	e_wsfe();
    }

/*     Read the number of values of K, followed by the values of K */

    if (ssb || sbb) {
	s_rsle(&io___78);
	do_lio(&c__3, &c__1, (char *)&nk, (ftnlen)sizeof(integer));
	e_rsle();
	s_rsle(&io___80);
	i__1 = nk;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_lio(&c__3, &c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(
		    integer));
	}
	e_rsle();
	i__1 = nk;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    if (kval[i__ - 1] < 0) {
		s_wsfe(&io___82);
		do_fio(&c__1, "    K ", (ftnlen)6);
		do_fio(&c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    } else if (kval[i__ - 1] > 132) {
		s_wsfe(&io___83);
		do_fio(&c__1, "    K ", (ftnlen)6);
		do_fio(&c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(integer))
			;
		do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		e_wsfe();
		fatal = TRUE_;
	    }
/* L60: */
	}
	s_wsfe(&io___84);
	do_fio(&c__1, "K:    ", (ftnlen)6);
	i__1 = nk;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    do_fio(&c__1, (char *)&kval[i__ - 1], (ftnlen)sizeof(integer));
	}
	e_wsfe();
    }

    if (sev || ses || svx || ssx) {

/*        For the nonsymmetric QR driver routines, only one set of */
/*        parameters is allowed. */

	s_rsle(&io___85);
	do_lio(&c__3, &c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&inmin[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&inwin[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&inibl[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&ishfts[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&iacc22[0], (ftnlen)sizeof(integer));
	e_rsle();
	if (nbval[0] < 1) {
	    s_wsfe(&io___94);
	    do_fio(&c__1, "   NB ", (ftnlen)6);
	    do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (nbmin[0] < 1) {
	    s_wsfe(&io___95);
	    do_fio(&c__1, "NBMIN ", (ftnlen)6);
	    do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (nxval[0] < 1) {
	    s_wsfe(&io___96);
	    do_fio(&c__1, "   NX ", (ftnlen)6);
	    do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (inmin[0] < 1) {
	    s_wsfe(&io___97);
	    do_fio(&c__1, "   INMIN ", (ftnlen)9);
	    do_fio(&c__1, (char *)&inmin[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (inwin[0] < 1) {
	    s_wsfe(&io___98);
	    do_fio(&c__1, "   INWIN ", (ftnlen)9);
	    do_fio(&c__1, (char *)&inwin[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (inibl[0] < 1) {
	    s_wsfe(&io___99);
	    do_fio(&c__1, "   INIBL ", (ftnlen)9);
	    do_fio(&c__1, (char *)&inibl[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (ishfts[0] < 1) {
	    s_wsfe(&io___100);
	    do_fio(&c__1, "   ISHFTS ", (ftnlen)10);
	    do_fio(&c__1, (char *)&ishfts[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (iacc22[0] < 0) {
	    s_wsfe(&io___101);
	    do_fio(&c__1, "   IACC22 ", (ftnlen)10);
	    do_fio(&c__1, (char *)&iacc22[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	}
	xlaenv_(&c__1, nbval);
	xlaenv_(&c__2, nbmin);
	xlaenv_(&c__3, nxval);
	i__1 = max(11,inmin[0]);
	xlaenv_(&c__12, &i__1);
	xlaenv_(&c__13, inwin);
	xlaenv_(&c__14, inibl);
	xlaenv_(&c__15, ishfts);
	xlaenv_(&c__16, iacc22);
	s_wsfe(&io___102);
	do_fio(&c__1, "NB:   ", (ftnlen)6);
	do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___103);
	do_fio(&c__1, "NBMIN:", (ftnlen)6);
	do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___104);
	do_fio(&c__1, "NX:   ", (ftnlen)6);
	do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___105);
	do_fio(&c__1, "INMIN:   ", (ftnlen)9);
	do_fio(&c__1, (char *)&inmin[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___106);
	do_fio(&c__1, "INWIN: ", (ftnlen)7);
	do_fio(&c__1, (char *)&inwin[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___107);
	do_fio(&c__1, "INIBL: ", (ftnlen)7);
	do_fio(&c__1, (char *)&inibl[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___108);
	do_fio(&c__1, "ISHFTS: ", (ftnlen)8);
	do_fio(&c__1, (char *)&ishfts[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___109);
	do_fio(&c__1, "IACC22: ", (ftnlen)8);
	do_fio(&c__1, (char *)&iacc22[0], (ftnlen)sizeof(integer));
	e_wsfe();

    } else if (sgs || sgx || sgv || sxv) {

/*        For the nonsymmetric generalized driver routines, only one set */
/*        of parameters is allowed. */

	s_rsle(&io___110);
	do_lio(&c__3, &c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&nsval[0], (ftnlen)sizeof(integer));
	do_lio(&c__3, &c__1, (char *)&mxbval[0], (ftnlen)sizeof(integer));
	e_rsle();
	if (nbval[0] < 1) {
	    s_wsfe(&io___113);
	    do_fio(&c__1, "   NB ", (ftnlen)6);
	    do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (nbmin[0] < 1) {
	    s_wsfe(&io___114);
	    do_fio(&c__1, "NBMIN ", (ftnlen)6);
	    do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (nxval[0] < 1) {
	    s_wsfe(&io___115);
	    do_fio(&c__1, "   NX ", (ftnlen)6);
	    do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (nsval[0] < 2) {
	    s_wsfe(&io___116);
	    do_fio(&c__1, "   NS ", (ftnlen)6);
	    do_fio(&c__1, (char *)&nsval[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__2, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	} else if (mxbval[0] < 1) {
	    s_wsfe(&io___117);
	    do_fio(&c__1, " MAXB ", (ftnlen)6);
	    do_fio(&c__1, (char *)&mxbval[0], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    fatal = TRUE_;
	}
	xlaenv_(&c__1, nbval);
	xlaenv_(&c__2, nbmin);
	xlaenv_(&c__3, nxval);
	xlaenv_(&c__4, nsval);
	xlaenv_(&c__8, mxbval);
	s_wsfe(&io___118);
	do_fio(&c__1, "NB:   ", (ftnlen)6);
	do_fio(&c__1, (char *)&nbval[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___119);
	do_fio(&c__1, "NBMIN:", (ftnlen)6);
	do_fio(&c__1, (char *)&nbmin[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___120);
	do_fio(&c__1, "NX:   ", (ftnlen)6);
	do_fio(&c__1, (char *)&nxval[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___121);
	do_fio(&c__1, "NS:   ", (ftnlen)6);
	do_fio(&c__1, (char *)&nsval[0], (ftnlen)sizeof(integer));
	e_wsfe();
	s_wsfe(&io___122);
	do_fio(&c__1, "MAXB: ", (ftnlen)6);
	do_fio(&c__1, (char *)&mxbval[0], (ftnlen)sizeof(integer));
	e_wsfe();

    } else if (! ssb && ! glm && ! gqr && ! gsv && ! lse) {

/*        For the other paths, the number of parameters can be varied */
/*        from the input file.  Read the number of parameter values. */

	s_rsle(&io___123);
	do_lio(&c__3, &c__1, (char *)&nparms, (ftnlen)sizeof(integer));
	e_rsle();
	if (nparms < 1) {
	    s_wsfe(&io___125);
	    do_fio(&c__1, "NPARMS", (ftnlen)6);
	    do_fio(&c__1, (char *)&nparms, (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__1, (ftnlen)sizeof(integer));
	    e_wsfe();
	    nparms = 0;
	    fatal = TRUE_;
	} else if (nparms > 20) {
	    s_wsfe(&io___126);
	    do_fio(&c__1, "NPARMS", (ftnlen)6);
	    do_fio(&c__1, (char *)&nparms, (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&c__20, (ftnlen)sizeof(integer));
	    e_wsfe();
	    nparms = 0;
	    fatal = TRUE_;
	}

/*        Read the values of NB */

	if (! sbb) {
	    s_rsle(&io___127);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (nbval[i__ - 1] < 0) {
		    s_wsfe(&io___128);
		    do_fio(&c__1, "   NB ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		} else if (nbval[i__ - 1] > 132) {
		    s_wsfe(&io___129);
		    do_fio(&c__1, "   NB ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L70: */
	    }
	    s_wsfe(&io___130);
	    do_fio(&c__1, "NB:   ", (ftnlen)6);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	}

/*        Read the values of NBMIN */

	if (nep || sep || svd || sgg) {
	    s_rsle(&io___131);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (nbmin[i__ - 1] < 0) {
		    s_wsfe(&io___132);
		    do_fio(&c__1, "NBMIN ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		} else if (nbmin[i__ - 1] > 132) {
		    s_wsfe(&io___133);
		    do_fio(&c__1, "NBMIN ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L80: */
	    }
	    s_wsfe(&io___134);
	    do_fio(&c__1, "NBMIN:", (ftnlen)6);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		nbmin[i__ - 1] = 1;
/* L90: */
	    }
	}

/*        Read the values of NX */

	if (nep || sep || svd) {
	    s_rsle(&io___135);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (nxval[i__ - 1] < 0) {
		    s_wsfe(&io___136);
		    do_fio(&c__1, "   NX ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		} else if (nxval[i__ - 1] > 132) {
		    s_wsfe(&io___137);
		    do_fio(&c__1, "   NX ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L100: */
	    }
	    s_wsfe(&io___138);
	    do_fio(&c__1, "NX:   ", (ftnlen)6);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		nxval[i__ - 1] = 1;
/* L110: */
	    }
	}

/*        Read the values of NSHIFT (if SGG) or NRHS (if SVD */
/*        or SBB). */

	if (svd || sbb || sgg) {
	    s_rsle(&io___139);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (nsval[i__ - 1] < 0) {
		    s_wsfe(&io___140);
		    do_fio(&c__1, "   NS ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		} else if (nsval[i__ - 1] > 132) {
		    s_wsfe(&io___141);
		    do_fio(&c__1, "   NS ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L120: */
	    }
	    s_wsfe(&io___142);
	    do_fio(&c__1, "NS:   ", (ftnlen)6);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		nsval[i__ - 1] = 1;
/* L130: */
	    }
	}

/*        Read the values for MAXB. */

	if (sgg) {
	    s_rsle(&io___143);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (mxbval[i__ - 1] < 0) {
		    s_wsfe(&io___144);
		    do_fio(&c__1, " MAXB ", (ftnlen)6);
		    do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		} else if (mxbval[i__ - 1] > 132) {
		    s_wsfe(&io___145);
		    do_fio(&c__1, " MAXB ", (ftnlen)6);
		    do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L140: */
	    }
	    s_wsfe(&io___146);
	    do_fio(&c__1, "MAXB: ", (ftnlen)6);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		mxbval[i__ - 1] = 1;
/* L150: */
	    }
	}

/*        Read the values for INMIN. */

	if (nep) {
	    s_rsle(&io___147);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&inmin[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (inmin[i__ - 1] < 0) {
		    s_wsfe(&io___148);
		    do_fio(&c__1, " INMIN ", (ftnlen)7);
		    do_fio(&c__1, (char *)&inmin[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L540: */
	    }
	    s_wsfe(&io___149);
	    do_fio(&c__1, "INMIN: ", (ftnlen)7);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&inmin[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		inmin[i__ - 1] = 1;
/* L550: */
	    }
	}

/*        Read the values for INWIN. */

	if (nep) {
	    s_rsle(&io___150);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (inwin[i__ - 1] < 0) {
		    s_wsfe(&io___151);
		    do_fio(&c__1, " INWIN ", (ftnlen)7);
		    do_fio(&c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L560: */
	    }
	    s_wsfe(&io___152);
	    do_fio(&c__1, "INWIN: ", (ftnlen)7);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		inwin[i__ - 1] = 1;
/* L570: */
	    }
	}

/*        Read the values for INIBL. */

	if (nep) {
	    s_rsle(&io___153);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (inibl[i__ - 1] < 0) {
		    s_wsfe(&io___154);
		    do_fio(&c__1, " INIBL ", (ftnlen)7);
		    do_fio(&c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L580: */
	    }
	    s_wsfe(&io___155);
	    do_fio(&c__1, "INIBL: ", (ftnlen)7);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		inibl[i__ - 1] = 1;
/* L590: */
	    }
	}

/*        Read the values for ISHFTS. */

	if (nep) {
	    s_rsle(&io___156);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (ishfts[i__ - 1] < 0) {
		    s_wsfe(&io___157);
		    do_fio(&c__1, " ISHFTS ", (ftnlen)8);
		    do_fio(&c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L600: */
	    }
	    s_wsfe(&io___158);
	    do_fio(&c__1, "ISHFTS: ", (ftnlen)8);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		ishfts[i__ - 1] = 1;
/* L610: */
	    }
	}

/*        Read the values for IACC22. */

	if (nep) {
	    s_rsle(&io___159);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (iacc22[i__ - 1] < 0) {
		    s_wsfe(&io___160);
		    do_fio(&c__1, " IACC22 ", (ftnlen)8);
		    do_fio(&c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L620: */
	    }
	    s_wsfe(&io___161);
	    do_fio(&c__1, "IACC22: ", (ftnlen)8);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		iacc22[i__ - 1] = 1;
/* L630: */
	    }
	}

/*        Read the values for NBCOL. */

	if (sgg) {
	    s_rsle(&io___162);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_lio(&c__3, &c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(
			integer));
	    }
	    e_rsle();
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		if (nbcol[i__ - 1] < 0) {
		    s_wsfe(&io___164);
		    do_fio(&c__1, "NBCOL ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__0, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		} else if (nbcol[i__ - 1] > 132) {
		    s_wsfe(&io___165);
		    do_fio(&c__1, "NBCOL ", (ftnlen)6);
		    do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(
			    integer));
		    do_fio(&c__1, (char *)&c__132, (ftnlen)sizeof(integer));
		    e_wsfe();
		    fatal = TRUE_;
		}
/* L160: */
	    }
	    s_wsfe(&io___166);
	    do_fio(&c__1, "NBCOL:", (ftnlen)6);
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(integer)
			);
	    }
	    e_wsfe();
	} else {
	    i__1 = nparms;
	    for (i__ = 1; i__ <= i__1; ++i__) {
		nbcol[i__ - 1] = 1;
/* L170: */
	    }
	}
    }

/*     Calculate and print the machine dependent constants. */

    s_wsle(&io___167);
    e_wsle();
    eps = slamch_("Underflow threshold");
    s_wsfe(&io___169);
    do_fio(&c__1, "underflow", (ftnlen)9);
    do_fio(&c__1, (char *)&eps, (ftnlen)sizeof(real));
    e_wsfe();
    eps = slamch_("Overflow threshold");
    s_wsfe(&io___170);
    do_fio(&c__1, "overflow ", (ftnlen)9);
    do_fio(&c__1, (char *)&eps, (ftnlen)sizeof(real));
    e_wsfe();
    eps = slamch_("Epsilon");
    s_wsfe(&io___171);
    do_fio(&c__1, "precision", (ftnlen)9);
    do_fio(&c__1, (char *)&eps, (ftnlen)sizeof(real));
    e_wsfe();

/*     Read the threshold value for the test ratios. */

    s_rsle(&io___172);
    do_lio(&c__4, &c__1, (char *)&thresh, (ftnlen)sizeof(real));
    e_rsle();
    s_wsfe(&io___173);
    do_fio(&c__1, (char *)&thresh, (ftnlen)sizeof(real));
    e_wsfe();
    if (sep || svd || sgg) {

/*        Read the flag that indicates whether to test LAPACK routines. */

	s_rsle(&io___174);
	do_lio(&c__8, &c__1, (char *)&tstchk, (ftnlen)sizeof(logical));
	e_rsle();

/*        Read the flag that indicates whether to test driver routines. */

	s_rsle(&io___176);
	do_lio(&c__8, &c__1, (char *)&tstdrv, (ftnlen)sizeof(logical));
	e_rsle();
    }

/*     Read the flag that indicates whether to test the error exits. */

    s_rsle(&io___178);
    do_lio(&c__8, &c__1, (char *)&tsterr, (ftnlen)sizeof(logical));
    e_rsle();

/*     Read the code describing how to set the random number seed. */

    s_rsle(&io___179);
    do_lio(&c__3, &c__1, (char *)&newsd, (ftnlen)sizeof(integer));
    e_rsle();

/*     If NEWSD = 2, read another line with 4 integers for the seed. */

    if (newsd == 2) {
	s_rsle(&io___181);
	for (i__ = 1; i__ <= 4; ++i__) {
	    do_lio(&c__3, &c__1, (char *)&ioldsd[i__ - 1], (ftnlen)sizeof(
		    integer));
	}
	e_rsle();
    }

    for (i__ = 1; i__ <= 4; ++i__) {
	iseed[i__ - 1] = ioldsd[i__ - 1];
/* L180: */
    }

    if (fatal) {
	s_wsfe(&io___183);
	e_wsfe();
	s_stop("", (ftnlen)0);
    }

/*     Read the input lines indicating the test path and its parameters. */
/*     The first three characters indicate the test path, and the number */
/*     of test matrix types must be the first nonblank item in columns */
/*     4-80. */

L190:

    if (! (sgx || sxv)) {

L200:
	ci__1.cierr = 0;
	ci__1.ciend = 1;
	ci__1.ciunit = 5;
	ci__1.cifmt = "(A80)";
	i__1 = s_rsfe(&ci__1);
	if (i__1 != 0) {
	    goto L380;
	}
	i__1 = do_fio(&c__1, line, (ftnlen)80);
	if (i__1 != 0) {
	    goto L380;
	}
	i__1 = e_rsfe();
	if (i__1 != 0) {
	    goto L380;
	}
	s_copy(c3, line, (ftnlen)3, (ftnlen)3);
	lenp = i_len(line, (ftnlen)80);
	i__ = 3;
	itmp = 0;
	i1 = 0;
L210:
	++i__;
	if (i__ > lenp) {
	    if (i1 > 0) {
		goto L240;
	    } else {
		ntypes = 30;
		goto L240;
	    }
	}
	if (*(unsigned char *)&line[i__ - 1] != ' ' && *(unsigned char *)&
		line[i__ - 1] != ',') {
	    i1 = i__;
	    *(unsigned char *)c1 = *(unsigned char *)&line[i1 - 1];

/*        Check that a valid integer was read */

	    for (k = 1; k <= 10; ++k) {
		if (*(unsigned char *)c1 == *(unsigned char *)&intstr[k - 1]) 
			{
		    ic = k - 1;
		    goto L230;
		}
/* L220: */
	    }
	    s_wsfe(&io___192);
	    do_fio(&c__1, (char *)&i__, (ftnlen)sizeof(integer));
	    do_fio(&c__1, line, (ftnlen)80);
	    e_wsfe();
	    goto L200;
L230:
	    itmp = itmp * 10 + ic;
	    goto L210;
	} else if (i1 > 0) {
	    goto L240;
	} else {
	    goto L210;
	}
L240:
	ntypes = itmp;

/*     Skip the tests if NTYPES is <= 0. */

	if (! (sev || ses || svx || ssx || sgv || sgs) && ntypes <= 0) {
	    s_wsfe(&io___193);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	    goto L200;
	}

    } else {
	if (sxv) {
	    s_copy(c3, "SXV", (ftnlen)3, (ftnlen)3);
	}
	if (sgx) {
	    s_copy(c3, "SGX", (ftnlen)3, (ftnlen)3);
	}
    }

/*     Reset the random number seed. */

    if (newsd == 0) {
	for (k = 1; k <= 4; ++k) {
	    iseed[k - 1] = ioldsd[k - 1];
/* L250: */
	}
    }

    if (lsamen_(&c__3, c3, "SHS") || lsamen_(&c__3, c3, 
	    "NEP")) {

/*        ------------------------------------- */
/*        NEP:  Nonsymmetric Eigenvalue Problem */
/*        ------------------------------------- */
/*        Vary the parameters */
/*           NB    = block size */
/*           NBMIN = minimum block size */
/*           NX    = crossover point */
/*           NS    = number of shifts */
/*           MAXB  = minimum submatrix size */

	maxtyp = 21;
	ntypes = min(maxtyp,ntypes);
	alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	xlaenv_(&c__1, &c__1);
	if (tsterr) {
	    serrhs_("SHSEQR", &c__6);
	}
	i__1 = nparms;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    xlaenv_(&c__1, &nbval[i__ - 1]);
	    xlaenv_(&c__2, &nbmin[i__ - 1]);
	    xlaenv_(&c__3, &nxval[i__ - 1]);
/* Computing MAX */
	    i__3 = 11, i__4 = inmin[i__ - 1];
	    i__2 = max(i__3,i__4);
	    xlaenv_(&c__12, &i__2);
	    xlaenv_(&c__13, &inwin[i__ - 1]);
	    xlaenv_(&c__14, &inibl[i__ - 1]);
	    xlaenv_(&c__15, &ishfts[i__ - 1]);
	    xlaenv_(&c__16, &iacc22[i__ - 1]);

	    if (newsd == 0) {
		for (k = 1; k <= 4; ++k) {
		    iseed[k - 1] = ioldsd[k - 1];
/* L260: */
		}
	    }
	    s_wsfe(&io___196);
	    do_fio(&c__1, c3, (ftnlen)3);
	    do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
/* Computing MAX */
	    i__3 = 11, i__4 = inmin[i__ - 1];
	    i__2 = max(i__3,i__4);
	    do_fio(&c__1, (char *)&i__2, (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&inwin[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&inibl[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&ishfts[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&iacc22[i__ - 1], (ftnlen)sizeof(integer));
	    e_wsfe();
	    schkhs_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, &
		    c__132, &a[17424], &a[34848], &a[52272], &a[69696], &
		    c__132, &a[87120], &a[104544], d__, &d__[132], &d__[264], 
		    &d__[396], &a[121968], &a[139392], &a[156816], &a[174240], 
		     &a[191664], &d__[528], work, &c__87781, iwork, logwrk, 
		    result, &info);
	    if (info != 0) {
		s_wsfe(&io___204);
		do_fio(&c__1, "SCHKHS", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
/* L270: */
	}

    } else if (lsamen_(&c__3, c3, "SST") || lsamen_(&
	    c__3, c3, "SEP")) {

/*        ---------------------------------- */
/*        SEP:  Symmetric Eigenvalue Problem */
/*        ---------------------------------- */
/*        Vary the parameters */
/*           NB    = block size */
/*           NBMIN = minimum block size */
/*           NX    = crossover point */

	maxtyp = 21;
	ntypes = min(maxtyp,ntypes);
	alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	xlaenv_(&c__1, &c__1);
	xlaenv_(&c__9, &c__25);
	if (tsterr) {
	    serrst_("SST", &c__6);
	}
	i__1 = nparms;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    xlaenv_(&c__1, &nbval[i__ - 1]);
	    xlaenv_(&c__2, &nbmin[i__ - 1]);
	    xlaenv_(&c__3, &nxval[i__ - 1]);

	    if (newsd == 0) {
		for (k = 1; k <= 4; ++k) {
		    iseed[k - 1] = ioldsd[k - 1];
/* L280: */
		}
	    }
	    s_wsfe(&io___205);
	    do_fio(&c__1, c3, (ftnlen)3);
	    do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
	    e_wsfe();
	    if (tstchk) {
		schkst_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, 
			&c__132, &a[17424], d__, &d__[132], &d__[264], &d__[
			396], &d__[528], &d__[660], &d__[792], &d__[924], &
			d__[1056], &d__[1188], &d__[1320], &a[34848], &c__132, 
			 &a[52272], &a[69696], &d__[1452], &a[87120], work, &
			c__87781, iwork, &c__89760, result, &info);
		if (info != 0) {
		    s_wsfe(&io___206);
		    do_fio(&c__1, "SCHKST", (ftnlen)6);
		    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		    e_wsfe();
		}
	    }
	    if (tstdrv) {
		sdrvst_(&nn, nval, &c__18, dotype, iseed, &thresh, &c__6, a, &
			c__132, &d__[264], &d__[396], &d__[528], &d__[660], &
			d__[924], &d__[1056], &d__[1188], &d__[1320], &a[
			17424], &c__132, &a[34848], &d__[1452], &a[52272], 
			work, &c__87781, iwork, &c__89760, result, &info);
		if (info != 0) {
		    s_wsfe(&io___207);
		    do_fio(&c__1, "SDRVST", (ftnlen)6);
		    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		    e_wsfe();
		}
	    }
/* L290: */
	}

    } else if (lsamen_(&c__3, c3, "SSG")) {

/*        ---------------------------------------------- */
/*        SSG:  Symmetric Generalized Eigenvalue Problem */
/*        ---------------------------------------------- */
/*        Vary the parameters */
/*           NB    = block size */
/*           NBMIN = minimum block size */
/*           NX    = crossover point */

	maxtyp = 21;
	ntypes = min(maxtyp,ntypes);
	alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	xlaenv_(&c__9, &c__25);
	i__1 = nparms;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    xlaenv_(&c__1, &nbval[i__ - 1]);
	    xlaenv_(&c__2, &nbmin[i__ - 1]);
	    xlaenv_(&c__3, &nxval[i__ - 1]);

	    if (newsd == 0) {
		for (k = 1; k <= 4; ++k) {
		    iseed[k - 1] = ioldsd[k - 1];
/* L300: */
		}
	    }
	    s_wsfe(&io___208);
	    do_fio(&c__1, c3, (ftnlen)3);
	    do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
	    e_wsfe();
	    if (tstchk) {
		sdrvsg_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, 
			&c__132, &a[17424], &c__132, &d__[264], &a[34848], &
			c__132, &a[52272], &a[69696], &a[87120], &a[104544], 
			work, &c__87781, iwork, &c__89760, result, &info);
		if (info != 0) {
		    s_wsfe(&io___209);
		    do_fio(&c__1, "SDRVSG", (ftnlen)6);
		    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		    e_wsfe();
		}
	    }
/* L310: */
	}

    } else if (lsamen_(&c__3, c3, "SBD") || lsamen_(&
	    c__3, c3, "SVD")) {

/*        ---------------------------------- */
/*        SVD:  Singular Value Decomposition */
/*        ---------------------------------- */
/*        Vary the parameters */
/*           NB    = block size */
/*           NBMIN = minimum block size */
/*           NX    = crossover point */
/*           NRHS  = number of right hand sides */

	maxtyp = 16;
	ntypes = min(maxtyp,ntypes);
	alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	xlaenv_(&c__1, &c__1);
	xlaenv_(&c__9, &c__25);

/*        Test the error exits */

	if (tsterr && tstchk) {
	    serrbd_("SBD", &c__6);
	}
	if (tsterr && tstdrv) {
	    serred_("SBD", &c__6);
	}

	i__1 = nparms;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    nrhs = nsval[i__ - 1];
	    xlaenv_(&c__1, &nbval[i__ - 1]);
	    xlaenv_(&c__2, &nbmin[i__ - 1]);
	    xlaenv_(&c__3, &nxval[i__ - 1]);
	    if (newsd == 0) {
		for (k = 1; k <= 4; ++k) {
		    iseed[k - 1] = ioldsd[k - 1];
/* L320: */
		}
	    }
	    s_wsfe(&io___211);
	    do_fio(&c__1, c3, (ftnlen)3);
	    do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nxval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nrhs, (ftnlen)sizeof(integer));
	    e_wsfe();
	    if (tstchk) {
		schkbd_(&nn, mval, nval, &maxtyp, dotype, &nrhs, iseed, &
			thresh, a, &c__132, d__, &d__[132], &d__[264], &d__[
			396], &a[17424], &c__132, &a[34848], &a[52272], &a[
			69696], &c__132, &a[87120], &c__132, &a[104544], &a[
			121968], work, &c__87781, iwork, &c__6, &info);
		if (info != 0) {
		    s_wsfe(&io___212);
		    do_fio(&c__1, "SCHKBD", (ftnlen)6);
		    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		    e_wsfe();
		}
	    }
	    if (tstdrv) {
		sdrvbd_(&nn, mval, nval, &maxtyp, dotype, iseed, &thresh, a, &
			c__132, &a[17424], &c__132, &a[34848], &c__132, &a[
			52272], &a[69696], &a[87120], d__, &d__[132], &d__[
			264], work, &c__87781, iwork, &c__6, &info);
	    }
/* L330: */
	}

    } else if (lsamen_(&c__3, c3, "SEV")) {

/*        -------------------------------------------- */
/*        SEV:  Nonsymmetric Eigenvalue Problem Driver */
/*              SGEEV (eigenvalues and eigenvectors) */
/*        -------------------------------------------- */

	maxtyp = 21;
	ntypes = min(maxtyp,ntypes);
	if (ntypes <= 0) {
	    s_wsfe(&io___213);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serred_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    sdrvev_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__6, a, &
		    c__132, &a[17424], d__, &d__[132], &d__[264], &d__[396], &
		    a[34848], &c__132, &a[52272], &c__132, &a[69696], &c__132, 
		     result, work, &c__87781, iwork, &info);
	    if (info != 0) {
		s_wsfe(&io___214);
		do_fio(&c__1, "SGEEV", (ftnlen)5);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___215);
	e_wsfe();
	goto L10;

    } else if (lsamen_(&c__3, c3, "SES")) {

/*        -------------------------------------------- */
/*        SES:  Nonsymmetric Eigenvalue Problem Driver */
/*              SGEES (Schur form) */
/*        -------------------------------------------- */

	maxtyp = 21;
	ntypes = min(maxtyp,ntypes);
	if (ntypes <= 0) {
	    s_wsfe(&io___216);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serred_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    sdrves_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__6, a, &
		    c__132, &a[17424], &a[34848], d__, &d__[132], &d__[264], &
		    d__[396], &a[52272], &c__132, result, work, &c__87781, 
		    iwork, logwrk, &info);
	    if (info != 0) {
		s_wsfe(&io___217);
		do_fio(&c__1, "SGEES", (ftnlen)5);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___218);
	e_wsfe();
	goto L10;

    } else if (lsamen_(&c__3, c3, "SVX")) {

/*        -------------------------------------------------------------- */
/*        SVX:  Nonsymmetric Eigenvalue Problem Expert Driver */
/*              SGEEVX (eigenvalues, eigenvectors and condition numbers) */
/*        -------------------------------------------------------------- */

	maxtyp = 21;
	ntypes = min(maxtyp,ntypes);
	if (ntypes < 0) {
	    s_wsfe(&io___219);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serred_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    sdrvvx_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__5, &c__6, 
		    a, &c__132, &a[17424], d__, &d__[132], &d__[264], &d__[
		    396], &a[34848], &c__132, &a[52272], &c__132, &a[69696], &
		    c__132, &d__[528], &d__[660], &d__[792], &d__[924], &d__[
		    1056], &d__[1188], &d__[1320], &d__[1452], result, work, &
		    c__87781, iwork, &info);
	    if (info != 0) {
		s_wsfe(&io___220);
		do_fio(&c__1, "SGEEVX", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___221);
	e_wsfe();
	goto L10;

    } else if (lsamen_(&c__3, c3, "SSX")) {

/*        --------------------------------------------------- */
/*        SSX:  Nonsymmetric Eigenvalue Problem Expert Driver */
/*              SGEESX (Schur form and condition numbers) */
/*        --------------------------------------------------- */

	maxtyp = 21;
	ntypes = min(maxtyp,ntypes);
	if (ntypes < 0) {
	    s_wsfe(&io___222);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serred_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    sdrvsx_(&nn, nval, &ntypes, dotype, iseed, &thresh, &c__5, &c__6, 
		    a, &c__132, &a[17424], &a[34848], d__, &d__[132], &d__[
		    264], &d__[396], &d__[528], &d__[660], &a[52272], &c__132, 
		     &a[69696], result, work, &c__87781, iwork, logwrk, &info)
		    ;
	    if (info != 0) {
		s_wsfe(&io___223);
		do_fio(&c__1, "SGEESX", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___224);
	e_wsfe();
	goto L10;

    } else if (lsamen_(&c__3, c3, "SGG")) {

/*        ------------------------------------------------- */
/*        SGG:  Generalized Nonsymmetric Eigenvalue Problem */
/*        ------------------------------------------------- */
/*        Vary the parameters */
/*           NB    = block size */
/*           NBMIN = minimum block size */
/*           NS    = number of shifts */
/*           MAXB  = minimum submatrix size */
/*           NBCOL = minimum column dimension for blocks */

	maxtyp = 26;
	ntypes = min(maxtyp,ntypes);
	alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	if (tstchk && tsterr) {
	    serrgg_(c3, &c__6);
	}
	i__1 = nparms;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    xlaenv_(&c__1, &nbval[i__ - 1]);
	    xlaenv_(&c__2, &nbmin[i__ - 1]);
	    xlaenv_(&c__4, &nsval[i__ - 1]);
	    xlaenv_(&c__8, &mxbval[i__ - 1]);
	    xlaenv_(&c__5, &nbcol[i__ - 1]);

	    if (newsd == 0) {
		for (k = 1; k <= 4; ++k) {
		    iseed[k - 1] = ioldsd[k - 1];
/* L340: */
		}
	    }
	    s_wsfe(&io___225);
	    do_fio(&c__1, c3, (ftnlen)3);
	    do_fio(&c__1, (char *)&nbval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nbmin[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nsval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&mxbval[i__ - 1], (ftnlen)sizeof(integer));
	    do_fio(&c__1, (char *)&nbcol[i__ - 1], (ftnlen)sizeof(integer));
	    e_wsfe();
	    tstdif = FALSE_;
	    thrshn = 10.f;
	    if (tstchk) {
		schkgg_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &tstdif, &
			thrshn, &c__6, a, &c__132, &a[17424], &a[34848], &a[
			52272], &a[69696], &a[87120], &a[104544], &a[121968], 
			&a[139392], &c__132, &a[156816], &a[174240], &a[
			191664], d__, &d__[132], &d__[264], &d__[396], &d__[
			528], &d__[660], &a[209088], &a[226512], work, &
			c__87781, logwrk, result, &info);
		if (info != 0) {
		    s_wsfe(&io___228);
		    do_fio(&c__1, "SCHKGG", (ftnlen)6);
		    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		    e_wsfe();
		}
	    }
	    xlaenv_(&c__1, &c__1);
	    if (tstdrv) {
		sdrvgg_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &thrshn, &
			c__6, a, &c__132, &a[17424], &a[34848], &a[52272], &a[
			69696], &a[87120], &a[104544], &c__132, &a[121968], 
			d__, &d__[132], &d__[264], &d__[396], &d__[528], &d__[
			660], &a[209088], &a[226512], work, &c__87781, result, 
			 &info);
		if (info != 0) {
		    s_wsfe(&io___229);
		    do_fio(&c__1, "SDRVGG", (ftnlen)6);
		    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		    e_wsfe();
		}
	    }
/* L350: */
	}

    } else if (lsamen_(&c__3, c3, "SGS")) {

/*        ------------------------------------------------- */
/*        SGS:  Generalized Nonsymmetric Eigenvalue Problem */
/*              SGGES (Schur form) */
/*        ------------------------------------------------- */

	maxtyp = 26;
	ntypes = min(maxtyp,ntypes);
	if (ntypes <= 0) {
	    s_wsfe(&io___230);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serrgg_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    sdrges_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, &
		    c__132, &a[17424], &a[34848], &a[52272], &a[104544], &
		    c__132, &a[121968], d__, &d__[132], &d__[264], work, &
		    c__87781, result, logwrk, &info);

	    if (info != 0) {
		s_wsfe(&io___231);
		do_fio(&c__1, "SDRGES", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___232);
	e_wsfe();
	goto L10;

    } else if (sgx) {

/*        ------------------------------------------------- */
/*        SGX:  Generalized Nonsymmetric Eigenvalue Problem */
/*              SGGESX (Schur form and condition numbers) */
/*        ------------------------------------------------- */

	maxtyp = 5;
	ntypes = maxtyp;
	if (nn < 0) {
	    s_wsfe(&io___233);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serrgg_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    xlaenv_(&c__5, &c__2);
	    sdrgsx_(&nn, &c__20, &thresh, &c__5, &c__6, a, &c__132, &a[17424], 
		     &a[34848], &a[52272], &a[69696], &a[87120], d__, &d__[
		    132], &d__[264], c__, &c__400, &a[191664], work, &
		    c__87781, iwork, &c__89760, logwrk, &info);
	    if (info != 0) {
		s_wsfe(&io___235);
		do_fio(&c__1, "SDRGSX", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___236);
	e_wsfe();
	goto L10;

    } else if (lsamen_(&c__3, c3, "SGV")) {

/*        ------------------------------------------------- */
/*        SGV:  Generalized Nonsymmetric Eigenvalue Problem */
/*              SGGEV (Eigenvalue/vector form) */
/*        ------------------------------------------------- */

	maxtyp = 26;
	ntypes = min(maxtyp,ntypes);
	if (ntypes <= 0) {
	    s_wsfe(&io___237);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serrgg_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    sdrgev_(&nn, nval, &maxtyp, dotype, iseed, &thresh, &c__6, a, &
		    c__132, &a[17424], &a[34848], &a[52272], &a[104544], &
		    c__132, &a[121968], &a[139392], &c__132, d__, &d__[132], &
		    d__[264], &d__[396], &d__[528], &d__[660], work, &
		    c__87781, result, &info);
	    if (info != 0) {
		s_wsfe(&io___238);
		do_fio(&c__1, "SDRGEV", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___239);
	e_wsfe();
	goto L10;

    } else if (sxv) {

/*        ------------------------------------------------- */
/*        SXV:  Generalized Nonsymmetric Eigenvalue Problem */
/*              SGGEVX (eigenvalue/vector with condition numbers) */
/*        ------------------------------------------------- */

	maxtyp = 2;
	ntypes = maxtyp;
	if (nn < 0) {
	    s_wsfe(&io___240);
	    do_fio(&c__1, c3, (ftnlen)3);
	    e_wsfe();
	} else {
	    if (tsterr) {
		serrgg_(c3, &c__6);
	    }
	    alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	    sdrgvx_(&nn, &thresh, &c__5, &c__6, a, &c__132, &a[17424], &a[
		    34848], &a[52272], d__, &d__[132], &d__[264], &a[69696], &
		    a[87120], iwork, &iwork[1], &d__[396], &d__[528], &d__[
		    660], &d__[792], &d__[924], &d__[1056], work, &c__87781, &
		    iwork[2], &c__89758, result, logwrk, &info);

	    if (info != 0) {
		s_wsfe(&io___241);
		do_fio(&c__1, "SDRGVX", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
	}
	s_wsfe(&io___242);
	e_wsfe();
	goto L10;

    } else if (lsamen_(&c__3, c3, "SSB")) {

/*        ------------------------------ */
/*        SSB:  Symmetric Band Reduction */
/*        ------------------------------ */

	maxtyp = 15;
	ntypes = min(maxtyp,ntypes);
	alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	if (tsterr) {
	    serrst_("SSB", &c__6);
	}
	schksb_(&nn, nval, &nk, kval, &maxtyp, dotype, iseed, &thresh, &c__6, 
		a, &c__132, d__, &d__[132], &a[17424], &c__132, work, &
		c__87781, result, &info);
	if (info != 0) {
	    s_wsfe(&io___243);
	    do_fio(&c__1, "SCHKSB", (ftnlen)6);
	    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
	    e_wsfe();
	}

    } else if (lsamen_(&c__3, c3, "SBB")) {

/*        ------------------------------ */
/*        SBB:  General Band Reduction */
/*        ------------------------------ */

	maxtyp = 15;
	ntypes = min(maxtyp,ntypes);
	alareq_(c3, &ntypes, dotype, &maxtyp, &c__5, &c__6);
	i__1 = nparms;
	for (i__ = 1; i__ <= i__1; ++i__) {
	    nrhs = nsval[i__ - 1];

	    if (newsd == 0) {
		for (k = 1; k <= 4; ++k) {
		    iseed[k - 1] = ioldsd[k - 1];
/* L360: */
		}
	    }
	    s_wsfe(&io___244);
	    do_fio(&c__1, c3, (ftnlen)3);
	    do_fio(&c__1, (char *)&nrhs, (ftnlen)sizeof(integer));
	    e_wsfe();
	    schkbb_(&nn, mval, nval, &nk, kval, &maxtyp, dotype, &nrhs, iseed, 
		     &thresh, &c__6, a, &c__132, &a[17424], &c__264, d__, &
		    d__[132], &a[52272], &c__132, &a[69696], &c__132, &a[
		    87120], &c__132, &a[104544], work, &c__87781, result, &
		    info);
	    if (info != 0) {
		s_wsfe(&io___245);
		do_fio(&c__1, "SCHKBB", (ftnlen)6);
		do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
		e_wsfe();
	    }
/* L370: */
	}

    } else if (lsamen_(&c__3, c3, "GLM")) {

/*        ----------------------------------------- */
/*        GLM:  Generalized Linear Regression Model */
/*        ----------------------------------------- */

	xlaenv_(&c__1, &c__1);
	if (tsterr) {
	    serrgg_("GLM", &c__6);
	}
	sckglm_(&nn, mval, pval, nval, &ntypes, iseed, &thresh, &c__132, a, &
		a[17424], b, &b[17424], x, work, d__, &c__5, &c__6, &info);
	if (info != 0) {
	    s_wsfe(&io___248);
	    do_fio(&c__1, "SCKGLM", (ftnlen)6);
	    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
	    e_wsfe();
	}

    } else if (lsamen_(&c__3, c3, "GQR")) {

/*        ------------------------------------------ */
/*        GQR:  Generalized QR and RQ factorizations */
/*        ------------------------------------------ */

	xlaenv_(&c__1, &c__1);
	if (tsterr) {
	    serrgg_("GQR", &c__6);
	}
	sckgqr_(&nn, mval, &nn, pval, &nn, nval, &ntypes, iseed, &thresh, &
		c__132, a, &a[17424], &a[34848], &a[52272], taua, b, &b[17424]
, &b[34848], &b[52272], &b[69696], taub, work, d__, &c__5, &
		c__6, &info);
	if (info != 0) {
	    s_wsfe(&io___251);
	    do_fio(&c__1, "SCKGQR", (ftnlen)6);
	    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
	    e_wsfe();
	}

    } else if (lsamen_(&c__3, c3, "GSV")) {

/*        ---------------------------------------------- */
/*        GSV:  Generalized Singular Value Decomposition */
/*        ---------------------------------------------- */

	if (tsterr) {
	    serrgg_("GSV", &c__6);
	}
	sckgsv_(&nn, mval, pval, nval, &ntypes, iseed, &thresh, &c__132, a, &
		a[17424], b, &b[17424], &a[34848], &b[34848], &a[52272], taua, 
		 taub, &b[52272], iwork, work, d__, &c__5, &c__6, &info);
	if (info != 0) {
	    s_wsfe(&io___252);
	    do_fio(&c__1, "SCKGSV", (ftnlen)6);
	    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
	    e_wsfe();
	}

    } else if (lsamen_(&c__3, c3, "LSE")) {

/*        -------------------------------------- */
/*        LSE:  Constrained Linear Least Squares */
/*        -------------------------------------- */

	xlaenv_(&c__1, &c__1);
	if (tsterr) {
	    serrgg_("LSE", &c__6);
	}
	scklse_(&nn, mval, pval, nval, &ntypes, iseed, &thresh, &c__132, a, &
		a[17424], b, &b[17424], x, work, d__, &c__5, &c__6, &info);
	if (info != 0) {
	    s_wsfe(&io___253);
	    do_fio(&c__1, "SCKLSE", (ftnlen)6);
	    do_fio(&c__1, (char *)&info, (ftnlen)sizeof(integer));
	    e_wsfe();
	}

    } else {
	s_wsle(&io___254);
	e_wsle();
	s_wsle(&io___255);
	e_wsle();
	s_wsfe(&io___256);
	do_fio(&c__1, c3, (ftnlen)3);
	e_wsfe();
    }
    if (! (sgx || sxv)) {
	goto L190;
    }
L380:
    s_wsfe(&io___257);
    e_wsfe();
    s2 = second_();
    s_wsfe(&io___259);
    r__1 = s2 - s1;
    do_fio(&c__1, (char *)&r__1, (ftnlen)sizeof(real));
    e_wsfe();

/* L9998: */

/*     End of SCHKEE */

    return 0;
} /* MAIN__ */

/* Main program alias */ int schkee_ () { MAIN__ (); return 0; }
