          SUBROUTINE ZHSEIN( SIDE, EIGSRC, INITV, SELECT, N, H, LDH, W, VL,
         $                   LDVL, VR, LDVR, MM, M, WORK, RWORK, IFAILL,
         $                   IFAILR, INFO )
    *
    *  -- LAPACK routine (version 3.1) --
    *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
    *     November 2006
    *
    *     .. Scalar Arguments ..
          CHARACTER          EIGSRC, INITV, SIDE
          INTEGER            INFO, LDH, LDVL, LDVR, M, MM, N
    *     ..
    *     .. Array Arguments ..
          LOGICAL            SELECT( * )
          INTEGER            IFAILL( * ), IFAILR( * )
          DOUBLE PRECISION   RWORK( * )
          COMPLEX*16         H( LDH, * ), VL( LDVL, * ), VR( LDVR, * ),
         $                   W( * ), WORK( * )
    *     ..
    *
    *  Purpose
    *  =======
    *
    *  ZHSEIN uses inverse iteration to find specified right and/or left
    *  eigenvectors of a complex upper Hessenberg matrix H.
    *
    *  The right eigenvector x and the left eigenvector y of the matrix H
    *  corresponding to an eigenvalue w are defined by:
    *
    *               H * x = w * x,     y**h * H = w * y**h
    *
    *  where y**h denotes the conjugate transpose of the vector y.
    *
    *  Arguments
    *  =========
    *
    *  SIDE    (input) CHARACTER*1
    *          = 'R': compute right eigenvectors only;
    *          = 'L': compute left eigenvectors only;
    *          = 'B': compute both right and left eigenvectors.
    *
    *  EIGSRC  (input) CHARACTER*1
    *          Specifies the source of eigenvalues supplied in W:
    *          = 'Q': the eigenvalues were found using ZHSEQR; thus, if
    *                 H has zero subdiagonal elements, and so is
    *                 block-triangular, then the j-th eigenvalue can be
    *                 assumed to be an eigenvalue of the block containing
    *                 the j-th row/column.  This property allows ZHSEIN to
    *                 perform inverse iteration on just one diagonal block.
    *          = 'N': no assumptions are made on the correspondence
    *                 between eigenvalues and diagonal blocks.  In this
    *                 case, ZHSEIN must always perform inverse iteration
    *                 using the whole matrix H.
    *
    *  INITV   (input) CHARACTER*1
    *          = 'N': no initial vectors are supplied;
    *          = 'U': user-supplied initial vectors are stored in the arrays
    *                 VL and/or VR.
    *
    *  SELECT  (input) LOGICAL array, dimension (N)
    *          Specifies the eigenvectors to be computed. To select the
    *          eigenvector corresponding to the eigenvalue W(j),
    *          SELECT(j) must be set to .TRUE..
    *
    *  N       (input) INTEGER
    *          The order of the matrix H.  N >= 0.
    *
    *  H       (input) COMPLEX*16 array, dimension (LDH,N)
    *          The upper Hessenberg matrix H.
    *
    *  LDH     (input) INTEGER
    *          The leading dimension of the array H.  LDH >= max(1,N).
    *
    *  W       (input/output) COMPLEX*16 array, dimension (N)
    *          On entry, the eigenvalues of H.
    *          On exit, the real parts of W may have been altered since
    *          close eigenvalues are perturbed slightly in searching for
    *          independent eigenvectors.
    *
    *  VL      (input/output) COMPLEX*16 array, dimension (LDVL,MM)
    *          On entry, if INITV = 'U' and SIDE = 'L' or 'B', VL must
    *          contain starting vectors for the inverse iteration for the
    *          left eigenvectors; the starting vector for each eigenvector
    *          must be in the same column in which the eigenvector will be
    *          stored.
    *          On exit, if SIDE = 'L' or 'B', the left eigenvectors
    *          specified by SELECT will be stored consecutively in the
    *          columns of VL, in the same order as their eigenvalues.
    *          If SIDE = 'R', VL is not referenced.
    *
    *  LDVL    (input) INTEGER
    *          The leading dimension of the array VL.
    *          LDVL >= max(1,N) if SIDE = 'L' or 'B'; LDVL >= 1 otherwise.
    *
    *  VR      (input/output) COMPLEX*16 array, dimension (LDVR,MM)
    *          On entry, if INITV = 'U' and SIDE = 'R' or 'B', VR must
    *          contain starting vectors for the inverse iteration for the
    *          right eigenvectors; the starting vector for each eigenvector
    *          must be in the same column in which the eigenvector will be
    *          stored.
    *          On exit, if SIDE = 'R' or 'B', the right eigenvectors
    *          specified by SELECT will be stored consecutively in the
    *          columns of VR, in the same order as their eigenvalues.
    *          If SIDE = 'L', VR is not referenced.
    *
    *  LDVR    (input) INTEGER
    *          The leading dimension of the array VR.
    *          LDVR >= max(1,N) if SIDE = 'R' or 'B'; LDVR >= 1 otherwise.
    *
    *  MM      (input) INTEGER
    *          The number of columns in the arrays VL and/or VR. MM >= M.
    *
    *  M       (output) INTEGER
    *          The number of columns in the arrays VL and/or VR required to
    *          store the eigenvectors (= the number of .TRUE. elements in
    *          SELECT).
    *
    *  WORK    (workspace) COMPLEX*16 array, dimension (N*N)
    *
    *  RWORK   (workspace) DOUBLE PRECISION array, dimension (N)
    *
    *  IFAILL  (output) INTEGER array, dimension (MM)
    *          If SIDE = 'L' or 'B', IFAILL(i) = j > 0 if the left
    *          eigenvector in the i-th column of VL (corresponding to the
    *          eigenvalue w(j)) failed to converge; IFAILL(i) = 0 if the
    *          eigenvector converged satisfactorily.
    *          If SIDE = 'R', IFAILL is not referenced.
    *
    *  IFAILR  (output) INTEGER array, dimension (MM)
    *          If SIDE = 'R' or 'B', IFAILR(i) = j > 0 if the right
    *          eigenvector in the i-th column of VR (corresponding to the
    *          eigenvalue w(j)) failed to converge; IFAILR(i) = 0 if the
    *          eigenvector converged satisfactorily.
    *          If SIDE = 'L', IFAILR is not referenced.
    *
    *  INFO    (output) INTEGER
    *          = 0:  successful exit
    *          < 0:  if INFO = -i, the i-th argument had an illegal value
    *          > 0:  if INFO = i, i is the number of eigenvectors which
    *                failed to converge; see IFAILL and IFAILR for further
    *                details.
    *
    *  Further Details
    *  ===============
    *
    *  Each eigenvector is normalized so that the element of largest
    *  magnitude has magnitude 1; here the magnitude of a complex number
    *  (x,y) is taken to be |x|+|y|.
    *
    *  =====================================================================
    *
    *     .. Parameters ..
          COMPLEX*16         ZERO
          PARAMETER          ( ZERO = ( 0.0D+0, 0.0D+0 ) )
          DOUBLE PRECISION   RZERO
          PARAMETER          ( RZERO = 0.0D+0 )
    *     ..
    *     .. Local Scalars ..
          LOGICAL            BOTHV, FROMQR, LEFTV, NOINIT, RIGHTV
          INTEGER            I, IINFO, K, KL, KLN, KR, KS, LDWORK
          DOUBLE PRECISION   EPS3, HNORM, SMLNUM, ULP, UNFL
          COMPLEX*16         CDUM, WK
    *     ..
    *     .. External Functions ..
          LOGICAL            LSAME
          DOUBLE PRECISION   DLAMCH, ZLANHS
          EXTERNAL           LSAME, DLAMCH, ZLANHS
    *     ..
    *     .. External Subroutines ..
          EXTERNAL           XERBLA, ZLAEIN
    *     ..
    *     .. Intrinsic Functions ..
          INTRINSIC          ABS, DBLE, DIMAG, MAX
    *     ..
    *     .. Statement Functions ..
          DOUBLE PRECISION   CABS1
    *     ..
    *     .. Statement Function definitions ..
          CABS1( CDUM ) = ABS( DBLE( CDUM ) ) + ABS( DIMAG( CDUM ) )
    *     ..
    *     .. Executable Statements ..
    *
    *     Decode and test the input parameters.
    *
          BOTHV = LSAME( SIDE, 'B' )
          RIGHTV = LSAME( SIDE, 'R' ) .OR. BOTHV
          LEFTV = LSAME( SIDE, 'L' ) .OR. BOTHV
    *
          FROMQR = LSAME( EIGSRC, 'Q' )
    *
          NOINIT = LSAME( INITV, 'N' )
    *
    *     Set M to the number of columns required to store the selected
    *     eigenvectors.
    *
          M = 0
          DO 10 K = 1, N
             IF( SELECT( K ) )
         $      M = M + 1
       10 CONTINUE
    *
          INFO = 0
          IF( .NOT.RIGHTV .AND. .NOT.LEFTV ) THEN
             INFO = -1
          ELSE IF( .NOT.FROMQR .AND. .NOT.LSAME( EIGSRC, 'N' ) ) THEN
             INFO = -2
          ELSE IF( .NOT.NOINIT .AND. .NOT.LSAME( INITV, 'U' ) ) THEN
             INFO = -3
          ELSE IF( N.LT.0 ) THEN
             INFO = -5
          ELSE IF( LDH.LT.MAX( 1, N ) ) THEN
             INFO = -7
          ELSE IF( LDVL.LT.1 .OR. ( LEFTV .AND. LDVL.LT.N ) ) THEN
             INFO = -10
          ELSE IF( LDVR.LT.1 .OR. ( RIGHTV .AND. LDVR.LT.N ) ) THEN
             INFO = -12
          ELSE IF( MM.LT.M ) THEN
             INFO = -13
          END IF
          IF( INFO.NE.0 ) THEN
             CALL XERBLA( 'ZHSEIN', -INFO )
             RETURN
          END IF
    *
    *     Quick return if possible.
    *
          IF( N.EQ.0 )
         $   RETURN
    *
    *     Set machine-dependent constants.
    *
          UNFL = DLAMCH( 'Safe minimum' )
          ULP = DLAMCH( 'Precision' )
          SMLNUM = UNFL*( N / ULP )
    *
          LDWORK = N
    *
          KL = 1
          KLN = 0
          IF( FROMQR ) THEN
             KR = 0
          ELSE
             KR = N
          END IF
          KS = 1
    *
          DO 100 K = 1, N
             IF( SELECT( K ) ) THEN
    *
    *           Compute eigenvector(s) corresponding to W(K).
    *
                IF( FROMQR ) THEN
    *
    *              If affiliation of eigenvalues is known, check whether
    *              the matrix splits.
    *
    *              Determine KL and KR such that 1 <= KL <= K <= KR <= N
    *              and H(KL,KL-1) and H(KR+1,KR) are zero (or KL = 1 or
    *              KR = N).
    *
    *              Then inverse iteration can be performed with the
    *              submatrix H(KL:N,KL:N) for a left eigenvector, and with
    *              the submatrix H(1:KR,1:KR) for a right eigenvector.
    *
                   DO 20 I = K, KL + 1, -1
                      IF( H( I, I-1 ).EQ.ZERO )
         $               GO TO 30
       20          CONTINUE
       30          CONTINUE
                   KL = I
                   IF( K.GT.KR ) THEN
                      DO 40 I = K, N - 1
                         IF( H( I+1, I ).EQ.ZERO )
         $                  GO TO 50
       40             CONTINUE
       50             CONTINUE
                      KR = I
                   END IF
                END IF
    *
                IF( KL.NE.KLN ) THEN
                   KLN = KL
    *
    *              Compute infinity-norm of submatrix H(KL:KR,KL:KR) if it
    *              has not ben computed before.
    *
                   HNORM = ZLANHS( 'I', KR-KL+1, H( KL, KL ), LDH, RWORK )
                   IF( HNORM.GT.RZERO ) THEN
                      EPS3 = HNORM*ULP
                   ELSE
                      EPS3 = SMLNUM
                   END IF
                END IF
    *
    *           Perturb eigenvalue if it is close to any previous
    *           selected eigenvalues affiliated to the submatrix
    *           H(KL:KR,KL:KR). Close roots are modified by EPS3.
    *
                WK = W( K )
       60       CONTINUE
                DO 70 I = K - 1, KL, -1
                   IF( SELECT( I ) .AND. CABS1( W( I )-WK ).LT.EPS3 ) THEN
                      WK = WK + EPS3
                      GO TO 60
                   END IF
       70       CONTINUE
                W( K ) = WK
    *
                IF( LEFTV ) THEN
    *
    *              Compute left eigenvector.
    *
                   CALL ZLAEIN( .FALSE., NOINIT, N-KL+1, H( KL, KL ), LDH,
         $                      WK, VL( KL, KS ), WORK, LDWORK, RWORK, EPS3,
         $                      SMLNUM, IINFO )
                   IF( IINFO.GT.0 ) THEN
                      INFO = INFO + 1
                      IFAILL( KS ) = K
                   ELSE
                      IFAILL( KS ) = 0
                   END IF
                   DO 80 I = 1, KL - 1
                      VL( I, KS ) = ZERO
       80          CONTINUE
                END IF
                IF( RIGHTV ) THEN
    *
    *              Compute right eigenvector.
    *
                   CALL ZLAEIN( .TRUE., NOINIT, KR, H, LDH, WK, VR( 1, KS ),
         $                      WORK, LDWORK, RWORK, EPS3, SMLNUM, IINFO )
                   IF( IINFO.GT.0 ) THEN
                      INFO = INFO + 1
                      IFAILR( KS ) = K
                   ELSE
                      IFAILR( KS ) = 0
                   END IF
                   DO 90 I = KR + 1, N
                      VR( I, KS ) = ZERO
       90          CONTINUE
                END IF
                KS = KS + 1
             END IF
      100 CONTINUE
    *
          RETURN
    *
    *     End of ZHSEIN
    *
          END