          SUBROUTINE SLASD1( NL, NR, SQRE, D, ALPHA, BETA, U, LDU, VT, LDVT,
         $                   IDXQ, IWORK, WORK, INFO )
    *
    *  -- LAPACK auxiliary routine (version 3.1) --
    *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
    *     November 2006
    *
    *     .. Scalar Arguments ..
          INTEGER            INFO, LDU, LDVT, NL, NR, SQRE
          REAL               ALPHA, BETA
    *     ..
    *     .. Array Arguments ..
          INTEGER            IDXQ( * ), IWORK( * )
          REAL               D( * ), U( LDU, * ), VT( LDVT, * ), WORK( * )
    *     ..
    *
    *  Purpose
    *  =======
    *
    *  SLASD1 computes the SVD of an upper bidiagonal N-by-M matrix B,
    *  where N = NL + NR + 1 and M = N + SQRE. SLASD1 is called from SLASD0.
    *
    *  A related subroutine SLASD7 handles the case in which the singular
    *  values (and the singular vectors in factored form) are desired.
    *
    *  SLASD1 computes the SVD as follows:
    *
    *                ( D1(in)  0    0     0 )
    *    B = U(in) * (   Z1'   a   Z2'    b ) * VT(in)
    *                (   0     0   D2(in) 0 )
    *
    *      = U(out) * ( D(out) 0) * VT(out)
    *
    *  where Z' = (Z1' a Z2' b) = u' VT', and u is a vector of dimension M
    *  with ALPHA and BETA in the NL+1 and NL+2 th entries and zeros
    *  elsewhere; and the entry b is empty if SQRE = 0.
    *
    *  The left singular vectors of the original matrix are stored in U, and
    *  the transpose of the right singular vectors are stored in VT, and the
    *  singular values are in D.  The algorithm consists of three stages:
    *
    *     The first stage consists of deflating the size of the problem
    *     when there are multiple singular values or when there are zeros in
    *     the Z vector.  For each such occurence the dimension of the
    *     secular equation problem is reduced by one.  This stage is
    *     performed by the routine SLASD2.
    *
    *     The second stage consists of calculating the updated
    *     singular values. This is done by finding the square roots of the
    *     roots of the secular equation via the routine SLASD4 (as called
    *     by SLASD3). This routine also calculates the singular vectors of
    *     the current problem.
    *
    *     The final stage consists of computing the updated singular vectors
    *     directly using the updated singular values.  The singular vectors
    *     for the current problem are multiplied with the singular vectors
    *     from the overall problem.
    *
    *  Arguments
    *  =========
    *
    *  NL     (input) INTEGER
    *         The row dimension of the upper block.  NL >= 1.
    *
    *  NR     (input) INTEGER
    *         The row dimension of the lower block.  NR >= 1.
    *
    *  SQRE   (input) INTEGER
    *         = 0: the lower block is an NR-by-NR square matrix.
    *         = 1: the lower block is an NR-by-(NR+1) rectangular matrix.
    *
    *         The bidiagonal matrix has row dimension N = NL + NR + 1,
    *         and column dimension M = N + SQRE.
    *
    *  D      (input/output) REAL array, dimension (NL+NR+1).
    *         N = NL+NR+1
    *         On entry D(1:NL,1:NL) contains the singular values of the
    *         upper block; and D(NL+2:N) contains the singular values of
    *         the lower block. On exit D(1:N) contains the singular values
    *         of the modified matrix.
    *
    *  ALPHA  (input/output) REAL
    *         Contains the diagonal element associated with the added row.
    *
    *  BETA   (input/output) REAL
    *         Contains the off-diagonal element associated with the added
    *         row.
    *
    *  U      (input/output) REAL array, dimension (LDU,N)
    *         On entry U(1:NL, 1:NL) contains the left singular vectors of
    *         the upper block; U(NL+2:N, NL+2:N) contains the left singular
    *         vectors of the lower block. On exit U contains the left
    *         singular vectors of the bidiagonal matrix.
    *
    *  LDU    (input) INTEGER
    *         The leading dimension of the array U.  LDU >= max( 1, N ).
    *
    *  VT     (input/output) REAL array, dimension (LDVT,M)
    *         where M = N + SQRE.
    *         On entry VT(1:NL+1, 1:NL+1)' contains the right singular
    *         vectors of the upper block; VT(NL+2:M, NL+2:M)' contains
    *         the right singular vectors of the lower block. On exit
    *         VT' contains the right singular vectors of the
    *         bidiagonal matrix.
    *
    *  LDVT   (input) INTEGER
    *         The leading dimension of the array VT.  LDVT >= max( 1, M ).
    *
    *  IDXQ  (output) INTEGER array, dimension (N)
    *         This contains the permutation which will reintegrate the
    *         subproblem just solved back into sorted order, i.e.
    *         D( IDXQ( I = 1, N ) ) will be in ascending order.
    *
    *  IWORK  (workspace) INTEGER array, dimension (4*N)
    *
    *  WORK   (workspace) REAL array, dimension (3*M**2+2*M)
    *
    *  INFO   (output) INTEGER
    *          = 0:  successful exit.
    *          < 0:  if INFO = -i, the i-th argument had an illegal value.
    *          > 0:  if INFO = 1, an singular value did not converge
    *
    *  Further Details
    *  ===============
    *
    *  Based on contributions by
    *     Ming Gu and Huan Ren, Computer Science Division, University of
    *     California at Berkeley, USA
    *
    *  =====================================================================
    *
    *     .. Parameters ..
    *
          REAL               ONE, ZERO
          PARAMETER          ( ONE = 1.0E+0, ZERO = 0.0E+0 )
    *     ..
    *     .. Local Scalars ..
          INTEGER            COLTYP, I, IDX, IDXC, IDXP, IQ, ISIGMA, IU2,
         $                   IVT2, IZ, K, LDQ, LDU2, LDVT2, M, N, N1, N2
          REAL               ORGNRM
    *     ..
    *     .. External Subroutines ..
          EXTERNAL           SLAMRG, SLASCL, SLASD2, SLASD3, XERBLA
    *     ..
    *     .. Intrinsic Functions ..
          INTRINSIC          ABS, MAX
    *     ..
    *     .. Executable Statements ..
    *
    *     Test the input parameters.
    *
          INFO = 0
    *
          IF( NL.LT.1 ) THEN
             INFO = -1
          ELSE IF( NR.LT.1 ) THEN
             INFO = -2
          ELSE IF( ( SQRE.LT.0 ) .OR. ( SQRE.GT.1 ) ) THEN
             INFO = -3
          END IF
          IF( INFO.NE.0 ) THEN
             CALL XERBLA( 'SLASD1', -INFO )
             RETURN
          END IF
    *
          N = NL + NR + 1
          M = N + SQRE
    *
    *     The following values are for bookkeeping purposes only.  They are
    *     integer pointers which indicate the portion of the workspace
    *     used by a particular array in SLASD2 and SLASD3.
    *
          LDU2 = N
          LDVT2 = M
    *
          IZ = 1
          ISIGMA = IZ + M
          IU2 = ISIGMA + N
          IVT2 = IU2 + LDU2*N
          IQ = IVT2 + LDVT2*M
    *
          IDX = 1
          IDXC = IDX + N
          COLTYP = IDXC + N
          IDXP = COLTYP + N
    *
    *     Scale.
    *
          ORGNRM = MAX( ABS( ALPHA ), ABS( BETA ) )
          D( NL+1 ) = ZERO
          DO 10 I = 1, N
             IF( ABS( D( I ) ).GT.ORGNRM ) THEN
                ORGNRM = ABS( D( I ) )
             END IF
       10 CONTINUE
          CALL SLASCL( 'G', 0, 0, ORGNRM, ONE, N, 1, D, N, INFO )
          ALPHA = ALPHA / ORGNRM
          BETA = BETA / ORGNRM
    *
    *     Deflate singular values.
    *
          CALL SLASD2( NL, NR, SQRE, K, D, WORK( IZ ), ALPHA, BETA, U, LDU,
         $             VT, LDVT, WORK( ISIGMA ), WORK( IU2 ), LDU2,
         $             WORK( IVT2 ), LDVT2, IWORK( IDXP ), IWORK( IDX ),
         $             IWORK( IDXC ), IDXQ, IWORK( COLTYP ), INFO )
    *
    *     Solve Secular Equation and update singular vectors.
    *
          LDQ = K
          CALL SLASD3( NL, NR, SQRE, K, D, WORK( IQ ), LDQ, WORK( ISIGMA ),
         $             U, LDU, WORK( IU2 ), LDU2, VT, LDVT, WORK( IVT2 ),
         $             LDVT2, IWORK( IDXC ), IWORK( COLTYP ), WORK( IZ ),
         $             INFO )
          IF( INFO.NE.0 ) THEN
             RETURN
          END IF
    *
    *     Unscale.
    *
          CALL SLASCL( 'G', 0, 0, ONE, ORGNRM, N, 1, D, N, INFO )
    *
    *     Prepare the IDXQ sorting permutation.
    *
          N1 = K
          N2 = N - K
          CALL SLAMRG( N1, N2, D, 1, -1, IDXQ )
    *
          RETURN
    *
    *     End of SLASD1
    *
          END