```      SUBROUTINE DSBGST( VECT, UPLO, N, KA, KB, AB, LDAB, BB, LDBB, X,
\$                   LDX, WORK, INFO )
*
*  -- LAPACK routine (version 3.1) --
*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
*     November 2006
*
*     .. Scalar Arguments ..
CHARACTER          UPLO, VECT
INTEGER            INFO, KA, KB, LDAB, LDBB, LDX, N
*     ..
*     .. Array Arguments ..
DOUBLE PRECISION   AB( LDAB, * ), BB( LDBB, * ), WORK( * ),
\$                   X( LDX, * )
*     ..
*
*  Purpose
*  =======
*
*  DSBGST reduces a real symmetric-definite banded generalized
*  eigenproblem  A*x = lambda*B*x  to standard form  C*y = lambda*y,
*  such that C has the same bandwidth as A.
*
*  B must have been previously factorized as S**T*S by DPBSTF, using a
*  split Cholesky factorization. A is overwritten by C = X**T*A*X, where
*  X = S**(-1)*Q and Q is an orthogonal matrix chosen to preserve the
*  bandwidth of A.
*
*  Arguments
*  =========
*
*  VECT    (input) CHARACTER*1
*          = 'N':  do not form the transformation matrix X;
*          = 'V':  form X.
*
*  UPLO    (input) CHARACTER*1
*          = 'U':  Upper triangle of A is stored;
*          = 'L':  Lower triangle of A is stored.
*
*  N       (input) INTEGER
*          The order of the matrices A and B.  N >= 0.
*
*  KA      (input) INTEGER
*          The number of superdiagonals of the matrix A if UPLO = 'U',
*          or the number of subdiagonals if UPLO = 'L'.  KA >= 0.
*
*  KB      (input) INTEGER
*          The number of superdiagonals of the matrix B if UPLO = 'U',
*          or the number of subdiagonals if UPLO = 'L'.  KA >= KB >= 0.
*
*  AB      (input/output) DOUBLE PRECISION array, dimension (LDAB,N)
*          On entry, the upper or lower triangle of the symmetric band
*          matrix A, stored in the first ka+1 rows of the array.  The
*          j-th column of A is stored in the j-th column of the array AB
*          as follows:
*          if UPLO = 'U', AB(ka+1+i-j,j) = A(i,j) for max(1,j-ka)<=i<=j;
*          if UPLO = 'L', AB(1+i-j,j)    = A(i,j) for j<=i<=min(n,j+ka).
*
*          On exit, the transformed matrix X**T*A*X, stored in the same
*          format as A.
*
*  LDAB    (input) INTEGER
*          The leading dimension of the array AB.  LDAB >= KA+1.
*
*  BB      (input) DOUBLE PRECISION array, dimension (LDBB,N)
*          The banded factor S from the split Cholesky factorization of
*          B, as returned by DPBSTF, stored in the first KB+1 rows of
*          the array.
*
*  LDBB    (input) INTEGER
*          The leading dimension of the array BB.  LDBB >= KB+1.
*
*  X       (output) DOUBLE PRECISION array, dimension (LDX,N)
*          If VECT = 'V', the n-by-n matrix X.
*          If VECT = 'N', the array X is not referenced.
*
*  LDX     (input) INTEGER
*          The leading dimension of the array X.
*          LDX >= max(1,N) if VECT = 'V'; LDX >= 1 otherwise.
*
*  WORK    (workspace) DOUBLE PRECISION array, dimension (2*N)
*
*  INFO    (output) INTEGER
*          = 0:  successful exit
*          < 0:  if INFO = -i, the i-th argument had an illegal value.
*
*  =====================================================================
*
*     .. Parameters ..
DOUBLE PRECISION   ZERO, ONE
PARAMETER          ( ZERO = 0.0D+0, ONE = 1.0D+0 )
*     ..
*     .. Local Scalars ..
LOGICAL            UPDATE, UPPER, WANTX
INTEGER            I, I0, I1, I2, INCA, J, J1, J1T, J2, J2T, K,
\$                   KA1, KB1, KBT, L, M, NR, NRT, NX
DOUBLE PRECISION   BII, RA, RA1, T
*     ..
*     .. External Functions ..
LOGICAL            LSAME
EXTERNAL           LSAME
*     ..
*     .. External Subroutines ..
EXTERNAL           DGER, DLAR2V, DLARGV, DLARTG, DLARTV, DLASET,
\$                   DROT, DSCAL, XERBLA
*     ..
*     .. Intrinsic Functions ..
INTRINSIC          MAX, MIN
*     ..
*     .. Executable Statements ..
*
*     Test the input parameters
*
WANTX = LSAME( VECT, 'V' )
UPPER = LSAME( UPLO, 'U' )
KA1 = KA + 1
KB1 = KB + 1
INFO = 0
IF( .NOT.WANTX .AND. .NOT.LSAME( VECT, 'N' ) ) THEN
INFO = -1
ELSE IF( .NOT.UPPER .AND. .NOT.LSAME( UPLO, 'L' ) ) THEN
INFO = -2
ELSE IF( N.LT.0 ) THEN
INFO = -3
ELSE IF( KA.LT.0 ) THEN
INFO = -4
ELSE IF( KB.LT.0 .OR. KB.GT.KA ) THEN
INFO = -5
ELSE IF( LDAB.LT.KA+1 ) THEN
INFO = -7
ELSE IF( LDBB.LT.KB+1 ) THEN
INFO = -9
ELSE IF( LDX.LT.1 .OR. WANTX .AND. LDX.LT.MAX( 1, N ) ) THEN
INFO = -11
END IF
IF( INFO.NE.0 ) THEN
CALL XERBLA( 'DSBGST', -INFO )
RETURN
END IF
*
*     Quick return if possible
*
IF( N.EQ.0 )
\$   RETURN
*
INCA = LDAB*KA1
*
*     Initialize X to the unit matrix, if needed
*
IF( WANTX )
\$   CALL DLASET( 'Full', N, N, ZERO, ONE, X, LDX )
*
*     Set M to the splitting point m. It must be the same value as is
*     used in DPBSTF. The chosen value allows the arrays WORK and RWORK
*     to be of dimension (N).
*
M = ( N+KB ) / 2
*
*     The routine works in two phases, corresponding to the two halves
*     of the split Cholesky factorization of B as S**T*S where
*
*     S = ( U    )
*         ( M  L )
*
*     with U upper triangular of order m, and L lower triangular of
*     order n-m. S has the same bandwidth as B.
*
*     S is treated as a product of elementary matrices:
*
*     S = S(m)*S(m-1)*...*S(2)*S(1)*S(m+1)*S(m+2)*...*S(n-1)*S(n)
*
*     where S(i) is determined by the i-th row of S.
*
*     In phase 1, the index i takes the values n, n-1, ... , m+1;
*     in phase 2, it takes the values 1, 2, ... , m.
*
*     For each value of i, the current matrix A is updated by forming
*     inv(S(i))**T*A*inv(S(i)). This creates a triangular bulge outside
*     the band of A. The bulge is then pushed down toward the bottom of
*     A in phase 1, and up toward the top of A in phase 2, by applying
*     plane rotations.
*
*     There are kb*(kb+1)/2 elements in the bulge, but at most 2*kb-1
*     of them are linearly independent, so annihilating a bulge requires
*     only 2*kb-1 plane rotations. The rotations are divided into a 1st
*     set of kb-1 rotations, and a 2nd set of kb rotations.
*
*     Wherever possible, rotations are generated and applied in vector
*     operations of length NR between the indices J1 and J2 (sometimes
*     replaced by modified values NRT, J1T or J2T).
*
*     The cosines and sines of the rotations are stored in the array
*     WORK. The cosines of the 1st set of rotations are stored in
*     elements n+2:n+m-kb-1 and the sines of the 1st set in elements
*     2:m-kb-1; the cosines of the 2nd set are stored in elements
*     n+m-kb+1:2*n and the sines of the second set in elements m-kb+1:n.
*
*     The bulges are not formed explicitly; nonzero elements outside the
*     band are created only when they are required for generating new
*     rotations; they are stored in the array WORK, in positions where
*     they are later overwritten by the sines of the rotations which
*     annihilate them.
*
*     **************************** Phase 1 *****************************
*
*     The logical structure of this phase is:
*
*     UPDATE = .TRUE.
*     DO I = N, M + 1, -1
*        use S(i) to update A and create a new bulge
*        apply rotations to push all bulges KA positions downward
*     END DO
*     UPDATE = .FALSE.
*     DO I = M + KA + 1, N - 1
*        apply rotations to push all bulges KA positions downward
*     END DO
*
*     To avoid duplicating code, the two loops are merged.
*
UPDATE = .TRUE.
I = N + 1
10 CONTINUE
IF( UPDATE ) THEN
I = I - 1
KBT = MIN( KB, I-1 )
I0 = I - 1
I1 = MIN( N, I+KA )
I2 = I - KBT + KA1
IF( I.LT.M+1 ) THEN
UPDATE = .FALSE.
I = I + 1
I0 = M
IF( KA.EQ.0 )
\$         GO TO 480
GO TO 10
END IF
ELSE
I = I + KA
IF( I.GT.N-1 )
\$      GO TO 480
END IF
*
IF( UPPER ) THEN
*
*        Transform A, working with the upper triangle
*
IF( UPDATE ) THEN
*
*           Form  inv(S(i))**T * A * inv(S(i))
*
BII = BB( KB1, I )
DO 20 J = I, I1
AB( I-J+KA1, J ) = AB( I-J+KA1, J ) / BII
20       CONTINUE
DO 30 J = MAX( 1, I-KA ), I
AB( J-I+KA1, I ) = AB( J-I+KA1, I ) / BII
30       CONTINUE
DO 60 K = I - KBT, I - 1
DO 40 J = I - KBT, K
AB( J-K+KA1, K ) = AB( J-K+KA1, K ) -
\$                               BB( J-I+KB1, I )*AB( K-I+KA1, I ) -
\$                               BB( K-I+KB1, I )*AB( J-I+KA1, I ) +
\$                               AB( KA1, I )*BB( J-I+KB1, I )*
\$                               BB( K-I+KB1, I )
40          CONTINUE
DO 50 J = MAX( 1, I-KA ), I - KBT - 1
AB( J-K+KA1, K ) = AB( J-K+KA1, K ) -
\$                               BB( K-I+KB1, I )*AB( J-I+KA1, I )
50          CONTINUE
60       CONTINUE
DO 80 J = I, I1
DO 70 K = MAX( J-KA, I-KBT ), I - 1
AB( K-J+KA1, J ) = AB( K-J+KA1, J ) -
\$                               BB( K-I+KB1, I )*AB( I-J+KA1, J )
70          CONTINUE
80       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by inv(S(i))
*
CALL DSCAL( N-M, ONE / BII, X( M+1, I ), 1 )
IF( KBT.GT.0 )
\$            CALL DGER( N-M, KBT, -ONE, X( M+1, I ), 1,
\$                       BB( KB1-KBT, I ), 1, X( M+1, I-KBT ), LDX )
END IF
*
*           store a(i,i1) in RA1 for use in next loop over K
*
RA1 = AB( I-I1+KA1, I1 )
END IF
*
*        Generate and apply vectors of rotations to chase all the
*        existing bulges KA positions down toward the bottom of the
*        band
*
DO 130 K = 1, KB - 1
IF( UPDATE ) THEN
*
*              Determine the rotations which would annihilate the bulge
*              which has in theory just been created
*
IF( I-K+KA.LT.N .AND. I-K.GT.1 ) THEN
*
*                 generate rotation to annihilate a(i,i-k+ka+1)
*
CALL DLARTG( AB( K+1, I-K+KA ), RA1,
\$                         WORK( N+I-K+KA-M ), WORK( I-K+KA-M ),
\$                         RA )
*
*                 create nonzero element a(i-k,i-k+ka+1) outside the
*                 band and store it in WORK(i-k)
*
T = -BB( KB1-K, I )*RA1
WORK( I-K ) = WORK( N+I-K+KA-M )*T -
\$                          WORK( I-K+KA-M )*AB( 1, I-K+KA )
AB( 1, I-K+KA ) = WORK( I-K+KA-M )*T +
\$                              WORK( N+I-K+KA-M )*AB( 1, I-K+KA )
RA1 = RA
END IF
END IF
J2 = I - K - 1 + MAX( 1, K-I0+2 )*KA1
NR = ( N-J2+KA ) / KA1
J1 = J2 + ( NR-1 )*KA1
IF( UPDATE ) THEN
J2T = MAX( J2, I+2*KA-K+1 )
ELSE
J2T = J2
END IF
NRT = ( N-J2T+KA ) / KA1
DO 90 J = J2T, J1, KA1
*
*              create nonzero element a(j-ka,j+1) outside the band
*              and store it in WORK(j-m)
*
WORK( J-M ) = WORK( J-M )*AB( 1, J+1 )
AB( 1, J+1 ) = WORK( N+J-M )*AB( 1, J+1 )
90       CONTINUE
*
*           generate rotations in 1st set to annihilate elements which
*           have been created outside the band
*
IF( NRT.GT.0 )
\$         CALL DLARGV( NRT, AB( 1, J2T ), INCA, WORK( J2T-M ), KA1,
\$                      WORK( N+J2T-M ), KA1 )
IF( NR.GT.0 ) THEN
*
*              apply rotations in 1st set from the right
*
DO 100 L = 1, KA - 1
CALL DLARTV( NR, AB( KA1-L, J2 ), INCA,
\$                         AB( KA-L, J2+1 ), INCA, WORK( N+J2-M ),
\$                         WORK( J2-M ), KA1 )
100          CONTINUE
*
*              apply rotations in 1st set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( KA1, J2 ), AB( KA1, J2+1 ),
\$                      AB( KA, J2+1 ), INCA, WORK( N+J2-M ),
\$                      WORK( J2-M ), KA1 )
*
END IF
*
*           start applying rotations in 1st set from the left
*
DO 110 L = KA - 1, KB - K + 1, -1
NRT = ( N-J2+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J2+KA1-L ), INCA,
\$                         AB( L+1, J2+KA1-L ), INCA,
\$                         WORK( N+J2-M ), WORK( J2-M ), KA1 )
110       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 1st set
*
DO 120 J = J2, J1, KA1
CALL DROT( N-M, X( M+1, J ), 1, X( M+1, J+1 ), 1,
\$                       WORK( N+J-M ), WORK( J-M ) )
120          CONTINUE
END IF
130    CONTINUE
*
IF( UPDATE ) THEN
IF( I2.LE.N .AND. KBT.GT.0 ) THEN
*
*              create nonzero element a(i-kbt,i-kbt+ka+1) outside the
*              band and store it in WORK(i-kbt)
*
WORK( I-KBT ) = -BB( KB1-KBT, I )*RA1
END IF
END IF
*
DO 170 K = KB, 1, -1
IF( UPDATE ) THEN
J2 = I - K - 1 + MAX( 2, K-I0+1 )*KA1
ELSE
J2 = I - K - 1 + MAX( 1, K-I0+1 )*KA1
END IF
*
*           finish applying rotations in 2nd set from the left
*
DO 140 L = KB - K, 1, -1
NRT = ( N-J2+KA+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J2-L+1 ), INCA,
\$                         AB( L+1, J2-L+1 ), INCA, WORK( N+J2-KA ),
\$                         WORK( J2-KA ), KA1 )
140       CONTINUE
NR = ( N-J2+KA ) / KA1
J1 = J2 + ( NR-1 )*KA1
DO 150 J = J1, J2, -KA1
WORK( J ) = WORK( J-KA )
WORK( N+J ) = WORK( N+J-KA )
150       CONTINUE
DO 160 J = J2, J1, KA1
*
*              create nonzero element a(j-ka,j+1) outside the band
*              and store it in WORK(j)
*
WORK( J ) = WORK( J )*AB( 1, J+1 )
AB( 1, J+1 ) = WORK( N+J )*AB( 1, J+1 )
160       CONTINUE
IF( UPDATE ) THEN
IF( I-K.LT.N-KA .AND. K.LE.KBT )
\$            WORK( I-K+KA ) = WORK( I-K )
END IF
170    CONTINUE
*
DO 210 K = KB, 1, -1
J2 = I - K - 1 + MAX( 1, K-I0+1 )*KA1
NR = ( N-J2+KA ) / KA1
J1 = J2 + ( NR-1 )*KA1
IF( NR.GT.0 ) THEN
*
*              generate rotations in 2nd set to annihilate elements
*              which have been created outside the band
*
CALL DLARGV( NR, AB( 1, J2 ), INCA, WORK( J2 ), KA1,
\$                      WORK( N+J2 ), KA1 )
*
*              apply rotations in 2nd set from the right
*
DO 180 L = 1, KA - 1
CALL DLARTV( NR, AB( KA1-L, J2 ), INCA,
\$                         AB( KA-L, J2+1 ), INCA, WORK( N+J2 ),
\$                         WORK( J2 ), KA1 )
180          CONTINUE
*
*              apply rotations in 2nd set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( KA1, J2 ), AB( KA1, J2+1 ),
\$                      AB( KA, J2+1 ), INCA, WORK( N+J2 ),
\$                      WORK( J2 ), KA1 )
*
END IF
*
*           start applying rotations in 2nd set from the left
*
DO 190 L = KA - 1, KB - K + 1, -1
NRT = ( N-J2+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J2+KA1-L ), INCA,
\$                         AB( L+1, J2+KA1-L ), INCA, WORK( N+J2 ),
\$                         WORK( J2 ), KA1 )
190       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 2nd set
*
DO 200 J = J2, J1, KA1
CALL DROT( N-M, X( M+1, J ), 1, X( M+1, J+1 ), 1,
\$                       WORK( N+J ), WORK( J ) )
200          CONTINUE
END IF
210    CONTINUE
*
DO 230 K = 1, KB - 1
J2 = I - K - 1 + MAX( 1, K-I0+2 )*KA1
*
*           finish applying rotations in 1st set from the left
*
DO 220 L = KB - K, 1, -1
NRT = ( N-J2+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J2+KA1-L ), INCA,
\$                         AB( L+1, J2+KA1-L ), INCA,
\$                         WORK( N+J2-M ), WORK( J2-M ), KA1 )
220       CONTINUE
230    CONTINUE
*
IF( KB.GT.1 ) THEN
DO 240 J = N - 1, I - KB + 2*KA + 1, -1
WORK( N+J-M ) = WORK( N+J-KA-M )
WORK( J-M ) = WORK( J-KA-M )
240       CONTINUE
END IF
*
ELSE
*
*        Transform A, working with the lower triangle
*
IF( UPDATE ) THEN
*
*           Form  inv(S(i))**T * A * inv(S(i))
*
BII = BB( 1, I )
DO 250 J = I, I1
AB( J-I+1, I ) = AB( J-I+1, I ) / BII
250       CONTINUE
DO 260 J = MAX( 1, I-KA ), I
AB( I-J+1, J ) = AB( I-J+1, J ) / BII
260       CONTINUE
DO 290 K = I - KBT, I - 1
DO 270 J = I - KBT, K
AB( K-J+1, J ) = AB( K-J+1, J ) -
\$                             BB( I-J+1, J )*AB( I-K+1, K ) -
\$                             BB( I-K+1, K )*AB( I-J+1, J ) +
\$                             AB( 1, I )*BB( I-J+1, J )*
\$                             BB( I-K+1, K )
270          CONTINUE
DO 280 J = MAX( 1, I-KA ), I - KBT - 1
AB( K-J+1, J ) = AB( K-J+1, J ) -
\$                             BB( I-K+1, K )*AB( I-J+1, J )
280          CONTINUE
290       CONTINUE
DO 310 J = I, I1
DO 300 K = MAX( J-KA, I-KBT ), I - 1
AB( J-K+1, K ) = AB( J-K+1, K ) -
\$                             BB( I-K+1, K )*AB( J-I+1, I )
300          CONTINUE
310       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by inv(S(i))
*
CALL DSCAL( N-M, ONE / BII, X( M+1, I ), 1 )
IF( KBT.GT.0 )
\$            CALL DGER( N-M, KBT, -ONE, X( M+1, I ), 1,
\$                       BB( KBT+1, I-KBT ), LDBB-1,
\$                       X( M+1, I-KBT ), LDX )
END IF
*
*           store a(i1,i) in RA1 for use in next loop over K
*
RA1 = AB( I1-I+1, I )
END IF
*
*        Generate and apply vectors of rotations to chase all the
*        existing bulges KA positions down toward the bottom of the
*        band
*
DO 360 K = 1, KB - 1
IF( UPDATE ) THEN
*
*              Determine the rotations which would annihilate the bulge
*              which has in theory just been created
*
IF( I-K+KA.LT.N .AND. I-K.GT.1 ) THEN
*
*                 generate rotation to annihilate a(i-k+ka+1,i)
*
CALL DLARTG( AB( KA1-K, I ), RA1, WORK( N+I-K+KA-M ),
\$                         WORK( I-K+KA-M ), RA )
*
*                 create nonzero element a(i-k+ka+1,i-k) outside the
*                 band and store it in WORK(i-k)
*
T = -BB( K+1, I-K )*RA1
WORK( I-K ) = WORK( N+I-K+KA-M )*T -
\$                          WORK( I-K+KA-M )*AB( KA1, I-K )
AB( KA1, I-K ) = WORK( I-K+KA-M )*T +
\$                             WORK( N+I-K+KA-M )*AB( KA1, I-K )
RA1 = RA
END IF
END IF
J2 = I - K - 1 + MAX( 1, K-I0+2 )*KA1
NR = ( N-J2+KA ) / KA1
J1 = J2 + ( NR-1 )*KA1
IF( UPDATE ) THEN
J2T = MAX( J2, I+2*KA-K+1 )
ELSE
J2T = J2
END IF
NRT = ( N-J2T+KA ) / KA1
DO 320 J = J2T, J1, KA1
*
*              create nonzero element a(j+1,j-ka) outside the band
*              and store it in WORK(j-m)
*
WORK( J-M ) = WORK( J-M )*AB( KA1, J-KA+1 )
AB( KA1, J-KA+1 ) = WORK( N+J-M )*AB( KA1, J-KA+1 )
320       CONTINUE
*
*           generate rotations in 1st set to annihilate elements which
*           have been created outside the band
*
IF( NRT.GT.0 )
\$         CALL DLARGV( NRT, AB( KA1, J2T-KA ), INCA, WORK( J2T-M ),
\$                      KA1, WORK( N+J2T-M ), KA1 )
IF( NR.GT.0 ) THEN
*
*              apply rotations in 1st set from the left
*
DO 330 L = 1, KA - 1
CALL DLARTV( NR, AB( L+1, J2-L ), INCA,
\$                         AB( L+2, J2-L ), INCA, WORK( N+J2-M ),
\$                         WORK( J2-M ), KA1 )
330          CONTINUE
*
*              apply rotations in 1st set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( 1, J2 ), AB( 1, J2+1 ), AB( 2, J2 ),
\$                      INCA, WORK( N+J2-M ), WORK( J2-M ), KA1 )
*
END IF
*
*           start applying rotations in 1st set from the right
*
DO 340 L = KA - 1, KB - K + 1, -1
NRT = ( N-J2+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J2 ), INCA,
\$                         AB( KA1-L, J2+1 ), INCA, WORK( N+J2-M ),
\$                         WORK( J2-M ), KA1 )
340       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 1st set
*
DO 350 J = J2, J1, KA1
CALL DROT( N-M, X( M+1, J ), 1, X( M+1, J+1 ), 1,
\$                       WORK( N+J-M ), WORK( J-M ) )
350          CONTINUE
END IF
360    CONTINUE
*
IF( UPDATE ) THEN
IF( I2.LE.N .AND. KBT.GT.0 ) THEN
*
*              create nonzero element a(i-kbt+ka+1,i-kbt) outside the
*              band and store it in WORK(i-kbt)
*
WORK( I-KBT ) = -BB( KBT+1, I-KBT )*RA1
END IF
END IF
*
DO 400 K = KB, 1, -1
IF( UPDATE ) THEN
J2 = I - K - 1 + MAX( 2, K-I0+1 )*KA1
ELSE
J2 = I - K - 1 + MAX( 1, K-I0+1 )*KA1
END IF
*
*           finish applying rotations in 2nd set from the right
*
DO 370 L = KB - K, 1, -1
NRT = ( N-J2+KA+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J2-KA ), INCA,
\$                         AB( KA1-L, J2-KA+1 ), INCA,
\$                         WORK( N+J2-KA ), WORK( J2-KA ), KA1 )
370       CONTINUE
NR = ( N-J2+KA ) / KA1
J1 = J2 + ( NR-1 )*KA1
DO 380 J = J1, J2, -KA1
WORK( J ) = WORK( J-KA )
WORK( N+J ) = WORK( N+J-KA )
380       CONTINUE
DO 390 J = J2, J1, KA1
*
*              create nonzero element a(j+1,j-ka) outside the band
*              and store it in WORK(j)
*
WORK( J ) = WORK( J )*AB( KA1, J-KA+1 )
AB( KA1, J-KA+1 ) = WORK( N+J )*AB( KA1, J-KA+1 )
390       CONTINUE
IF( UPDATE ) THEN
IF( I-K.LT.N-KA .AND. K.LE.KBT )
\$            WORK( I-K+KA ) = WORK( I-K )
END IF
400    CONTINUE
*
DO 440 K = KB, 1, -1
J2 = I - K - 1 + MAX( 1, K-I0+1 )*KA1
NR = ( N-J2+KA ) / KA1
J1 = J2 + ( NR-1 )*KA1
IF( NR.GT.0 ) THEN
*
*              generate rotations in 2nd set to annihilate elements
*              which have been created outside the band
*
CALL DLARGV( NR, AB( KA1, J2-KA ), INCA, WORK( J2 ), KA1,
\$                      WORK( N+J2 ), KA1 )
*
*              apply rotations in 2nd set from the left
*
DO 410 L = 1, KA - 1
CALL DLARTV( NR, AB( L+1, J2-L ), INCA,
\$                         AB( L+2, J2-L ), INCA, WORK( N+J2 ),
\$                         WORK( J2 ), KA1 )
410          CONTINUE
*
*              apply rotations in 2nd set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( 1, J2 ), AB( 1, J2+1 ), AB( 2, J2 ),
\$                      INCA, WORK( N+J2 ), WORK( J2 ), KA1 )
*
END IF
*
*           start applying rotations in 2nd set from the right
*
DO 420 L = KA - 1, KB - K + 1, -1
NRT = ( N-J2+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J2 ), INCA,
\$                         AB( KA1-L, J2+1 ), INCA, WORK( N+J2 ),
\$                         WORK( J2 ), KA1 )
420       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 2nd set
*
DO 430 J = J2, J1, KA1
CALL DROT( N-M, X( M+1, J ), 1, X( M+1, J+1 ), 1,
\$                       WORK( N+J ), WORK( J ) )
430          CONTINUE
END IF
440    CONTINUE
*
DO 460 K = 1, KB - 1
J2 = I - K - 1 + MAX( 1, K-I0+2 )*KA1
*
*           finish applying rotations in 1st set from the right
*
DO 450 L = KB - K, 1, -1
NRT = ( N-J2+L ) / KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J2 ), INCA,
\$                         AB( KA1-L, J2+1 ), INCA, WORK( N+J2-M ),
\$                         WORK( J2-M ), KA1 )
450       CONTINUE
460    CONTINUE
*
IF( KB.GT.1 ) THEN
DO 470 J = N - 1, I - KB + 2*KA + 1, -1
WORK( N+J-M ) = WORK( N+J-KA-M )
WORK( J-M ) = WORK( J-KA-M )
470       CONTINUE
END IF
*
END IF
*
GO TO 10
*
480 CONTINUE
*
*     **************************** Phase 2 *****************************
*
*     The logical structure of this phase is:
*
*     UPDATE = .TRUE.
*     DO I = 1, M
*        use S(i) to update A and create a new bulge
*        apply rotations to push all bulges KA positions upward
*     END DO
*     UPDATE = .FALSE.
*     DO I = M - KA - 1, 2, -1
*        apply rotations to push all bulges KA positions upward
*     END DO
*
*     To avoid duplicating code, the two loops are merged.
*
UPDATE = .TRUE.
I = 0
490 CONTINUE
IF( UPDATE ) THEN
I = I + 1
KBT = MIN( KB, M-I )
I0 = I + 1
I1 = MAX( 1, I-KA )
I2 = I + KBT - KA1
IF( I.GT.M ) THEN
UPDATE = .FALSE.
I = I - 1
I0 = M + 1
IF( KA.EQ.0 )
\$         RETURN
GO TO 490
END IF
ELSE
I = I - KA
IF( I.LT.2 )
\$      RETURN
END IF
*
IF( I.LT.M-KBT ) THEN
NX = M
ELSE
NX = N
END IF
*
IF( UPPER ) THEN
*
*        Transform A, working with the upper triangle
*
IF( UPDATE ) THEN
*
*           Form  inv(S(i))**T * A * inv(S(i))
*
BII = BB( KB1, I )
DO 500 J = I1, I
AB( J-I+KA1, I ) = AB( J-I+KA1, I ) / BII
500       CONTINUE
DO 510 J = I, MIN( N, I+KA )
AB( I-J+KA1, J ) = AB( I-J+KA1, J ) / BII
510       CONTINUE
DO 540 K = I + 1, I + KBT
DO 520 J = K, I + KBT
AB( K-J+KA1, J ) = AB( K-J+KA1, J ) -
\$                               BB( I-J+KB1, J )*AB( I-K+KA1, K ) -
\$                               BB( I-K+KB1, K )*AB( I-J+KA1, J ) +
\$                               AB( KA1, I )*BB( I-J+KB1, J )*
\$                               BB( I-K+KB1, K )
520          CONTINUE
DO 530 J = I + KBT + 1, MIN( N, I+KA )
AB( K-J+KA1, J ) = AB( K-J+KA1, J ) -
\$                               BB( I-K+KB1, K )*AB( I-J+KA1, J )
530          CONTINUE
540       CONTINUE
DO 560 J = I1, I
DO 550 K = I + 1, MIN( J+KA, I+KBT )
AB( J-K+KA1, K ) = AB( J-K+KA1, K ) -
\$                               BB( I-K+KB1, K )*AB( J-I+KA1, I )
550          CONTINUE
560       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by inv(S(i))
*
CALL DSCAL( NX, ONE / BII, X( 1, I ), 1 )
IF( KBT.GT.0 )
\$            CALL DGER( NX, KBT, -ONE, X( 1, I ), 1, BB( KB, I+1 ),
\$                       LDBB-1, X( 1, I+1 ), LDX )
END IF
*
*           store a(i1,i) in RA1 for use in next loop over K
*
RA1 = AB( I1-I+KA1, I )
END IF
*
*        Generate and apply vectors of rotations to chase all the
*        existing bulges KA positions up toward the top of the band
*
DO 610 K = 1, KB - 1
IF( UPDATE ) THEN
*
*              Determine the rotations which would annihilate the bulge
*              which has in theory just been created
*
IF( I+K-KA1.GT.0 .AND. I+K.LT.M ) THEN
*
*                 generate rotation to annihilate a(i+k-ka-1,i)
*
CALL DLARTG( AB( K+1, I ), RA1, WORK( N+I+K-KA ),
\$                         WORK( I+K-KA ), RA )
*
*                 create nonzero element a(i+k-ka-1,i+k) outside the
*                 band and store it in WORK(m-kb+i+k)
*
T = -BB( KB1-K, I+K )*RA1
WORK( M-KB+I+K ) = WORK( N+I+K-KA )*T -
\$                               WORK( I+K-KA )*AB( 1, I+K )
AB( 1, I+K ) = WORK( I+K-KA )*T +
\$                           WORK( N+I+K-KA )*AB( 1, I+K )
RA1 = RA
END IF
END IF
J2 = I + K + 1 - MAX( 1, K+I0-M+1 )*KA1
NR = ( J2+KA-1 ) / KA1
J1 = J2 - ( NR-1 )*KA1
IF( UPDATE ) THEN
J2T = MIN( J2, I-2*KA+K-1 )
ELSE
J2T = J2
END IF
NRT = ( J2T+KA-1 ) / KA1
DO 570 J = J1, J2T, KA1
*
*              create nonzero element a(j-1,j+ka) outside the band
*              and store it in WORK(j)
*
WORK( J ) = WORK( J )*AB( 1, J+KA-1 )
AB( 1, J+KA-1 ) = WORK( N+J )*AB( 1, J+KA-1 )
570       CONTINUE
*
*           generate rotations in 1st set to annihilate elements which
*           have been created outside the band
*
IF( NRT.GT.0 )
\$         CALL DLARGV( NRT, AB( 1, J1+KA ), INCA, WORK( J1 ), KA1,
\$                      WORK( N+J1 ), KA1 )
IF( NR.GT.0 ) THEN
*
*              apply rotations in 1st set from the left
*
DO 580 L = 1, KA - 1
CALL DLARTV( NR, AB( KA1-L, J1+L ), INCA,
\$                         AB( KA-L, J1+L ), INCA, WORK( N+J1 ),
\$                         WORK( J1 ), KA1 )
580          CONTINUE
*
*              apply rotations in 1st set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( KA1, J1 ), AB( KA1, J1-1 ),
\$                      AB( KA, J1 ), INCA, WORK( N+J1 ),
\$                      WORK( J1 ), KA1 )
*
END IF
*
*           start applying rotations in 1st set from the right
*
DO 590 L = KA - 1, KB - K + 1, -1
NRT = ( J2+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J1T ), INCA,
\$                         AB( L+1, J1T-1 ), INCA, WORK( N+J1T ),
\$                         WORK( J1T ), KA1 )
590       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 1st set
*
DO 600 J = J1, J2, KA1
CALL DROT( NX, X( 1, J ), 1, X( 1, J-1 ), 1,
\$                       WORK( N+J ), WORK( J ) )
600          CONTINUE
END IF
610    CONTINUE
*
IF( UPDATE ) THEN
IF( I2.GT.0 .AND. KBT.GT.0 ) THEN
*
*              create nonzero element a(i+kbt-ka-1,i+kbt) outside the
*              band and store it in WORK(m-kb+i+kbt)
*
WORK( M-KB+I+KBT ) = -BB( KB1-KBT, I+KBT )*RA1
END IF
END IF
*
DO 650 K = KB, 1, -1
IF( UPDATE ) THEN
J2 = I + K + 1 - MAX( 2, K+I0-M )*KA1
ELSE
J2 = I + K + 1 - MAX( 1, K+I0-M )*KA1
END IF
*
*           finish applying rotations in 2nd set from the right
*
DO 620 L = KB - K, 1, -1
NRT = ( J2+KA+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J1T+KA ), INCA,
\$                         AB( L+1, J1T+KA-1 ), INCA,
\$                         WORK( N+M-KB+J1T+KA ),
\$                         WORK( M-KB+J1T+KA ), KA1 )
620       CONTINUE
NR = ( J2+KA-1 ) / KA1
J1 = J2 - ( NR-1 )*KA1
DO 630 J = J1, J2, KA1
WORK( M-KB+J ) = WORK( M-KB+J+KA )
WORK( N+M-KB+J ) = WORK( N+M-KB+J+KA )
630       CONTINUE
DO 640 J = J1, J2, KA1
*
*              create nonzero element a(j-1,j+ka) outside the band
*              and store it in WORK(m-kb+j)
*
WORK( M-KB+J ) = WORK( M-KB+J )*AB( 1, J+KA-1 )
AB( 1, J+KA-1 ) = WORK( N+M-KB+J )*AB( 1, J+KA-1 )
640       CONTINUE
IF( UPDATE ) THEN
IF( I+K.GT.KA1 .AND. K.LE.KBT )
\$            WORK( M-KB+I+K-KA ) = WORK( M-KB+I+K )
END IF
650    CONTINUE
*
DO 690 K = KB, 1, -1
J2 = I + K + 1 - MAX( 1, K+I0-M )*KA1
NR = ( J2+KA-1 ) / KA1
J1 = J2 - ( NR-1 )*KA1
IF( NR.GT.0 ) THEN
*
*              generate rotations in 2nd set to annihilate elements
*              which have been created outside the band
*
CALL DLARGV( NR, AB( 1, J1+KA ), INCA, WORK( M-KB+J1 ),
\$                      KA1, WORK( N+M-KB+J1 ), KA1 )
*
*              apply rotations in 2nd set from the left
*
DO 660 L = 1, KA - 1
CALL DLARTV( NR, AB( KA1-L, J1+L ), INCA,
\$                         AB( KA-L, J1+L ), INCA,
\$                         WORK( N+M-KB+J1 ), WORK( M-KB+J1 ), KA1 )
660          CONTINUE
*
*              apply rotations in 2nd set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( KA1, J1 ), AB( KA1, J1-1 ),
\$                      AB( KA, J1 ), INCA, WORK( N+M-KB+J1 ),
\$                      WORK( M-KB+J1 ), KA1 )
*
END IF
*
*           start applying rotations in 2nd set from the right
*
DO 670 L = KA - 1, KB - K + 1, -1
NRT = ( J2+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J1T ), INCA,
\$                         AB( L+1, J1T-1 ), INCA,
\$                         WORK( N+M-KB+J1T ), WORK( M-KB+J1T ),
\$                         KA1 )
670       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 2nd set
*
DO 680 J = J1, J2, KA1
CALL DROT( NX, X( 1, J ), 1, X( 1, J-1 ), 1,
\$                       WORK( N+M-KB+J ), WORK( M-KB+J ) )
680          CONTINUE
END IF
690    CONTINUE
*
DO 710 K = 1, KB - 1
J2 = I + K + 1 - MAX( 1, K+I0-M+1 )*KA1
*
*           finish applying rotations in 1st set from the right
*
DO 700 L = KB - K, 1, -1
NRT = ( J2+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( L, J1T ), INCA,
\$                         AB( L+1, J1T-1 ), INCA, WORK( N+J1T ),
\$                         WORK( J1T ), KA1 )
700       CONTINUE
710    CONTINUE
*
IF( KB.GT.1 ) THEN
DO 720 J = 2, MIN( I+KB, M ) - 2*KA - 1
WORK( N+J ) = WORK( N+J+KA )
WORK( J ) = WORK( J+KA )
720       CONTINUE
END IF
*
ELSE
*
*        Transform A, working with the lower triangle
*
IF( UPDATE ) THEN
*
*           Form  inv(S(i))**T * A * inv(S(i))
*
BII = BB( 1, I )
DO 730 J = I1, I
AB( I-J+1, J ) = AB( I-J+1, J ) / BII
730       CONTINUE
DO 740 J = I, MIN( N, I+KA )
AB( J-I+1, I ) = AB( J-I+1, I ) / BII
740       CONTINUE
DO 770 K = I + 1, I + KBT
DO 750 J = K, I + KBT
AB( J-K+1, K ) = AB( J-K+1, K ) -
\$                             BB( J-I+1, I )*AB( K-I+1, I ) -
\$                             BB( K-I+1, I )*AB( J-I+1, I ) +
\$                             AB( 1, I )*BB( J-I+1, I )*
\$                             BB( K-I+1, I )
750          CONTINUE
DO 760 J = I + KBT + 1, MIN( N, I+KA )
AB( J-K+1, K ) = AB( J-K+1, K ) -
\$                             BB( K-I+1, I )*AB( J-I+1, I )
760          CONTINUE
770       CONTINUE
DO 790 J = I1, I
DO 780 K = I + 1, MIN( J+KA, I+KBT )
AB( K-J+1, J ) = AB( K-J+1, J ) -
\$                             BB( K-I+1, I )*AB( I-J+1, J )
780          CONTINUE
790       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by inv(S(i))
*
CALL DSCAL( NX, ONE / BII, X( 1, I ), 1 )
IF( KBT.GT.0 )
\$            CALL DGER( NX, KBT, -ONE, X( 1, I ), 1, BB( 2, I ), 1,
\$                       X( 1, I+1 ), LDX )
END IF
*
*           store a(i,i1) in RA1 for use in next loop over K
*
RA1 = AB( I-I1+1, I1 )
END IF
*
*        Generate and apply vectors of rotations to chase all the
*        existing bulges KA positions up toward the top of the band
*
DO 840 K = 1, KB - 1
IF( UPDATE ) THEN
*
*              Determine the rotations which would annihilate the bulge
*              which has in theory just been created
*
IF( I+K-KA1.GT.0 .AND. I+K.LT.M ) THEN
*
*                 generate rotation to annihilate a(i,i+k-ka-1)
*
CALL DLARTG( AB( KA1-K, I+K-KA ), RA1,
\$                         WORK( N+I+K-KA ), WORK( I+K-KA ), RA )
*
*                 create nonzero element a(i+k,i+k-ka-1) outside the
*                 band and store it in WORK(m-kb+i+k)
*
T = -BB( K+1, I )*RA1
WORK( M-KB+I+K ) = WORK( N+I+K-KA )*T -
\$                               WORK( I+K-KA )*AB( KA1, I+K-KA )
AB( KA1, I+K-KA ) = WORK( I+K-KA )*T +
\$                                WORK( N+I+K-KA )*AB( KA1, I+K-KA )
RA1 = RA
END IF
END IF
J2 = I + K + 1 - MAX( 1, K+I0-M+1 )*KA1
NR = ( J2+KA-1 ) / KA1
J1 = J2 - ( NR-1 )*KA1
IF( UPDATE ) THEN
J2T = MIN( J2, I-2*KA+K-1 )
ELSE
J2T = J2
END IF
NRT = ( J2T+KA-1 ) / KA1
DO 800 J = J1, J2T, KA1
*
*              create nonzero element a(j+ka,j-1) outside the band
*              and store it in WORK(j)
*
WORK( J ) = WORK( J )*AB( KA1, J-1 )
AB( KA1, J-1 ) = WORK( N+J )*AB( KA1, J-1 )
800       CONTINUE
*
*           generate rotations in 1st set to annihilate elements which
*           have been created outside the band
*
IF( NRT.GT.0 )
\$         CALL DLARGV( NRT, AB( KA1, J1 ), INCA, WORK( J1 ), KA1,
\$                      WORK( N+J1 ), KA1 )
IF( NR.GT.0 ) THEN
*
*              apply rotations in 1st set from the right
*
DO 810 L = 1, KA - 1
CALL DLARTV( NR, AB( L+1, J1 ), INCA, AB( L+2, J1-1 ),
\$                         INCA, WORK( N+J1 ), WORK( J1 ), KA1 )
810          CONTINUE
*
*              apply rotations in 1st set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( 1, J1 ), AB( 1, J1-1 ),
\$                      AB( 2, J1-1 ), INCA, WORK( N+J1 ),
\$                      WORK( J1 ), KA1 )
*
END IF
*
*           start applying rotations in 1st set from the left
*
DO 820 L = KA - 1, KB - K + 1, -1
NRT = ( J2+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J1T-KA1+L ), INCA,
\$                         AB( KA1-L, J1T-KA1+L ), INCA,
\$                         WORK( N+J1T ), WORK( J1T ), KA1 )
820       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 1st set
*
DO 830 J = J1, J2, KA1
CALL DROT( NX, X( 1, J ), 1, X( 1, J-1 ), 1,
\$                       WORK( N+J ), WORK( J ) )
830          CONTINUE
END IF
840    CONTINUE
*
IF( UPDATE ) THEN
IF( I2.GT.0 .AND. KBT.GT.0 ) THEN
*
*              create nonzero element a(i+kbt,i+kbt-ka-1) outside the
*              band and store it in WORK(m-kb+i+kbt)
*
WORK( M-KB+I+KBT ) = -BB( KBT+1, I )*RA1
END IF
END IF
*
DO 880 K = KB, 1, -1
IF( UPDATE ) THEN
J2 = I + K + 1 - MAX( 2, K+I0-M )*KA1
ELSE
J2 = I + K + 1 - MAX( 1, K+I0-M )*KA1
END IF
*
*           finish applying rotations in 2nd set from the left
*
DO 850 L = KB - K, 1, -1
NRT = ( J2+KA+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J1T+L-1 ), INCA,
\$                         AB( KA1-L, J1T+L-1 ), INCA,
\$                         WORK( N+M-KB+J1T+KA ),
\$                         WORK( M-KB+J1T+KA ), KA1 )
850       CONTINUE
NR = ( J2+KA-1 ) / KA1
J1 = J2 - ( NR-1 )*KA1
DO 860 J = J1, J2, KA1
WORK( M-KB+J ) = WORK( M-KB+J+KA )
WORK( N+M-KB+J ) = WORK( N+M-KB+J+KA )
860       CONTINUE
DO 870 J = J1, J2, KA1
*
*              create nonzero element a(j+ka,j-1) outside the band
*              and store it in WORK(m-kb+j)
*
WORK( M-KB+J ) = WORK( M-KB+J )*AB( KA1, J-1 )
AB( KA1, J-1 ) = WORK( N+M-KB+J )*AB( KA1, J-1 )
870       CONTINUE
IF( UPDATE ) THEN
IF( I+K.GT.KA1 .AND. K.LE.KBT )
\$            WORK( M-KB+I+K-KA ) = WORK( M-KB+I+K )
END IF
880    CONTINUE
*
DO 920 K = KB, 1, -1
J2 = I + K + 1 - MAX( 1, K+I0-M )*KA1
NR = ( J2+KA-1 ) / KA1
J1 = J2 - ( NR-1 )*KA1
IF( NR.GT.0 ) THEN
*
*              generate rotations in 2nd set to annihilate elements
*              which have been created outside the band
*
CALL DLARGV( NR, AB( KA1, J1 ), INCA, WORK( M-KB+J1 ),
\$                      KA1, WORK( N+M-KB+J1 ), KA1 )
*
*              apply rotations in 2nd set from the right
*
DO 890 L = 1, KA - 1
CALL DLARTV( NR, AB( L+1, J1 ), INCA, AB( L+2, J1-1 ),
\$                         INCA, WORK( N+M-KB+J1 ), WORK( M-KB+J1 ),
\$                         KA1 )
890          CONTINUE
*
*              apply rotations in 2nd set from both sides to diagonal
*              blocks
*
CALL DLAR2V( NR, AB( 1, J1 ), AB( 1, J1-1 ),
\$                      AB( 2, J1-1 ), INCA, WORK( N+M-KB+J1 ),
\$                      WORK( M-KB+J1 ), KA1 )
*
END IF
*
*           start applying rotations in 2nd set from the left
*
DO 900 L = KA - 1, KB - K + 1, -1
NRT = ( J2+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J1T-KA1+L ), INCA,
\$                         AB( KA1-L, J1T-KA1+L ), INCA,
\$                         WORK( N+M-KB+J1T ), WORK( M-KB+J1T ),
\$                         KA1 )
900       CONTINUE
*
IF( WANTX ) THEN
*
*              post-multiply X by product of rotations in 2nd set
*
DO 910 J = J1, J2, KA1
CALL DROT( NX, X( 1, J ), 1, X( 1, J-1 ), 1,
\$                       WORK( N+M-KB+J ), WORK( M-KB+J ) )
910          CONTINUE
END IF
920    CONTINUE
*
DO 940 K = 1, KB - 1
J2 = I + K + 1 - MAX( 1, K+I0-M+1 )*KA1
*
*           finish applying rotations in 1st set from the left
*
DO 930 L = KB - K, 1, -1
NRT = ( J2+L-1 ) / KA1
J1T = J2 - ( NRT-1 )*KA1
IF( NRT.GT.0 )
\$            CALL DLARTV( NRT, AB( KA1-L+1, J1T-KA1+L ), INCA,
\$                         AB( KA1-L, J1T-KA1+L ), INCA,
\$                         WORK( N+J1T ), WORK( J1T ), KA1 )
930       CONTINUE
940    CONTINUE
*
IF( KB.GT.1 ) THEN
DO 950 J = 2, MIN( I+KB, M ) - 2*KA - 1
WORK( N+J ) = WORK( N+J+KA )
WORK( J ) = WORK( J+KA )
950       CONTINUE
END IF
*
END IF
*
GO TO 490
*
*     End of DSBGST
*
END

```