Fix Compile error with ifort -warn all - Contributed by Orion Poplawski

Compiling current lapack svn trunk with ifort -warn all results in
errors like:

ifort -O3 -fp-model strict -warn all -c sorcsd2by1.f -o sorcsd2by1.o
sorcsd2by1.f(350): error #6633: The type of the actual argument differs
from
the type of the dummy argument.   [0]
           CALL SORBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
------------------------------------------------------------------^
sorcsd2by1.f(350): error #6633: The type of the actual argument differs
from
the type of the dummy argument.   [0]
           CALL SORBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
---------------------------------------------------------------------^
sorcsd2by1.f(351): error #6633: The type of the actual argument differs
from
the type of the dummy argument.   [0]
    $                    0, 0, WORK, -1, CHILDINFO )
--------------------------^
sorcsd2by1.f(351): error #6633: The type of the actual argument differs
from
the type of the dummy argument.   [0]
    $                    0, 0, WORK, -1, CHILDINFO )
-----------------------------^

ifort -O3 -fp-model strict -warn all -c cgesdd.f -o cgesdd.o
cgesdd.f(343): error #6633: The type of the actual argument differs
from the
type of the dummy argument.   [CDUM]
           CALL CGEBRD( M, N, CDUM(1), M, CDUM(1), DUM(1), CDUM(1),
-------------------------------------------^

6 files changed, 222 insertions, 181 deletions

diff --git a/SRC/cgesdd.f b/SRC/cgesdd.f
index 370acd94..323f606a 100644
--- a/SRC/cgesdd.f
+++ b/SRC/cgesdd.f
@@ -340,11 +340,11 @@
 *           not including e, RU, and RVT matrices.
 *
 *           Compute space preferred for each routine
-            CALL CGEBRD( M, N, CDUM(1), M, CDUM(1), DUM(1), CDUM(1),
+            CALL CGEBRD( M, N, CDUM(1), M, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_CGEBRD_MN = INT( CDUM(1) )
 *
-            CALL CGEBRD( N, N, CDUM(1), N, CDUM(1), DUM(1), CDUM(1),
+            CALL CGEBRD( N, N, CDUM(1), N, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_CGEBRD_NN = INT( CDUM(1) )
 *
@@ -481,11 +481,11 @@
 *           not including e, RU, and RVT matrices.
 *
 *           Compute space preferred for each routine
-            CALL CGEBRD( M, N, CDUM(1), M, CDUM(1), DUM(1), CDUM(1),
+            CALL CGEBRD( M, N, CDUM(1), M, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_CGEBRD_MN = INT( CDUM(1) )
 *
-            CALL CGEBRD( M, M, CDUM(1), M, CDUM(1), DUM(1), CDUM(1),
+            CALL CGEBRD( M, M, CDUM(1), M, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_CGEBRD_MM = INT( CDUM(1) )
 *
diff --git a/SRC/cuncsd2by1.f b/SRC/cuncsd2by1.f
index f431b337..96af777f 100644
--- a/SRC/cuncsd2by1.f
+++ b/SRC/cuncsd2by1.f
@@ -288,6 +288,10 @@
      $                   LWORKMIN, LWORKOPT, R
       LOGICAL            LQUERY, WANTU1, WANTU2, WANTV1T
 *     ..
+*     .. Local Arrays ..
+      REAL               DUM( 1 )
+      COMPLEX            CDUM( 1 )
+*     ..
 *     .. External Subroutines ..
       EXTERNAL           CBBCSD, CCOPY, CLACPY, CLAPMR, CLAPMT, CUNBDB1,
      $                   CUNBDB2, CUNBDB3, CUNBDB4, CUNGLQ, CUNGQR,
@@ -385,110 +389,114 @@
          LORGLQMIN = 1
          LORGLQOPT = 1
          IF( R .EQ. Q ) THEN
-            CALL CUNBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK, -1, CHILDINFO )
+            CALL CUNBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, CDUM, CDUM, CDUM, WORK, -1,
+     $                    CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL CUNGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL CUNGQR( P, P, Q, U1, LDU1, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             ENDIF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL CUNGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
+               CALL CUNGQR( M-P, M-P, Q, U2, LDU2, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
                CALL CUNGLQ( Q-1, Q-1, Q-1, V1T, LDV1T,
-     $                      0, WORK(1), -1, CHILDINFO )
+     $                      CDUM, WORK(1), -1, CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q-1 )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL CBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                   0, U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, RWORK(1), -1, CHILDINFO )
+     $                   DUM(1), U1, LDU1, U2, LDU2, V1T, LDV1T, CDUM,
+     $                   1, DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          ELSE IF( R .EQ. P ) THEN
-            CALL CUNBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL CUNBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA, DUM,
+     $                    CDUM, CDUM, CDUM, WORK(1), -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL CUNGQR( P-1, P-1, P-1, U1(2,2), LDU1, 0, WORK(1),
+               CALL CUNGQR( P-1, P-1, P-1, U1(2,2), LDU1, CDUM, WORK(1),
      $                      -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL CUNGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
+               CALL CUNGQR( M-P, M-P, Q, U2, LDU2, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL CUNGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL CUNGLQ( Q, Q, R, V1T, LDV1T, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL CBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                   0, V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, RWORK(1), -1, CHILDINFO )
+     $                   DUM, V1T, LDV1T, CDUM, 1, U1, LDU1, U2, LDU2,
+     $                   DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          ELSE IF( R .EQ. M-P ) THEN
-            CALL CUNBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL CUNBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA, DUM,
+     $                    CDUM, CDUM, CDUM, WORK(1), -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL CUNGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL CUNGQR( P, P, Q, U1, LDU1, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL CUNGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2, 0,
+               CALL CUNGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2, CDUM,
      $                      WORK(1), -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL CUNGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL CUNGLQ( Q, Q, R, V1T, LDV1T, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL CBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                   THETA, 0, 0, 1, V1T, LDV1T, U2, LDU2, U1, LDU1,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, RWORK(1), -1,
-     $                   CHILDINFO )
+     $                   THETA, DUM, CDUM, 1, V1T, LDV1T, U2, LDU2, U1,
+     $                   LDU1, DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          ELSE
-            CALL CUNBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, 0, WORK(1), -1, CHILDINFO )
+            CALL CUNBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA, DUM,
+     $                    CDUM, CDUM, CDUM, CDUM, WORK(1), -1, CHILDINFO
+     $                  )
             LORBDB = M + INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL CUNGQR( P, P, M-Q, U1, LDU1, 0, WORK(1), -1,
+               CALL CUNGQR( P, P, M-Q, U1, LDU1, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL CUNGQR( M-P, M-P, M-Q, U2, LDU2, 0, WORK(1), -1,
+               CALL CUNGQR( M-P, M-P, M-Q, U2, LDU2, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL CUNGLQ( Q, Q, Q, V1T, LDV1T, 0, WORK(1), -1,
+               CALL CUNGLQ( Q, Q, Q, V1T, LDV1T, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL CBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                   THETA, 0, U2, LDU2, U1, LDU1, 0, 1, V1T, LDV1T,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, RWORK(1), -1,
-     $                   CHILDINFO )
+     $                   THETA, DUM, U2, LDU2, U1, LDU1, CDUM, 1, V1T,
+     $                   LDV1T, DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          END IF
          LRWORKMIN = IBBCSD+LBBCSD-1
@@ -554,8 +562,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL CBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                RWORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1,
-     $                RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
+     $                RWORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T, CDUM,
+     $                1, RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
      $                RWORK(IB12E), RWORK(IB21D), RWORK(IB21E),
      $                RWORK(IB22D), RWORK(IB22E), RWORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
@@ -608,8 +616,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL CBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                RWORK(IPHI), V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2,
-     $                RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
+     $                RWORK(IPHI), V1T, LDV1T, CDUM, 1, U1, LDU1, U2,
+     $                LDU2, RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
      $                RWORK(IB12E), RWORK(IB21D), RWORK(IB21E),
      $                RWORK(IB22D), RWORK(IB22E), RWORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
@@ -663,7 +671,7 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL CBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                THETA, RWORK(IPHI), 0, 1, V1T, LDV1T, U2, LDU2,
+     $                THETA, RWORK(IPHI), CDUM, 1, V1T, LDV1T, U2, LDU2,
      $                U1, LDU1, RWORK(IB11D), RWORK(IB11E),
      $                RWORK(IB12D), RWORK(IB12E), RWORK(IB21D),
      $                RWORK(IB21E), RWORK(IB22D), RWORK(IB22E),
@@ -732,11 +740,11 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL CBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                THETA, RWORK(IPHI), U2, LDU2, U1, LDU1, 0, 1, V1T,
-     $                LDV1T, RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
-     $                RWORK(IB12E), RWORK(IB21D), RWORK(IB21E),
-     $                RWORK(IB22D), RWORK(IB22E), RWORK(IBBCSD), LBBCSD,
-     $                CHILDINFO )
+     $                THETA, RWORK(IPHI), U2, LDU2, U1, LDU1, CDUM, 1,
+     $                V1T, LDV1T, RWORK(IB11D), RWORK(IB11E),
+     $                RWORK(IB12D), RWORK(IB12E), RWORK(IB21D),
+     $                RWORK(IB21E), RWORK(IB22D), RWORK(IB22E),
+     $                RWORK(IBBCSD), LBBCSD, CHILDINFO )
 *   
 *        Permute rows and columns to place identity submatrices in
 *        preferred positions
diff --git a/SRC/dorcsd2by1.f b/SRC/dorcsd2by1.f
index 33a9b16d..809997d0 100644
--- a/SRC/dorcsd2by1.f
+++ b/SRC/dorcsd2by1.f
@@ -266,6 +266,9 @@
      $                   LWORKMIN, LWORKOPT, R
       LOGICAL            LQUERY, WANTU1, WANTU2, WANTV1T
 *     ..
+*     .. Local Arrays ..
+      DOUBLE PRECISION   DUM( 1 )
+*     ..
 *     .. External Subroutines ..
       EXTERNAL           DBBCSD, DCOPY, DLACPY, DLAPMR, DLAPMT, DORBDB1,
      $                   DORBDB2, DORBDB3, DORBDB4, DORGLQ, DORGQR,
@@ -349,110 +352,120 @@
          LORGLQMIN = 1
          LORGLQOPT = 1
          IF( R .EQ. Q ) THEN
-            CALL DORBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK, -1, CHILDINFO )
+            CALL DORBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM, WORK,
+     $                    -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL DORGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL DORGQR( P, P, Q, U1, LDU1, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             ENDIF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL DORGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
-     $                      CHILDINFO )
+               CALL DORGQR( M-P, M-P, Q, U2, LDU2, DUM, WORK(1),
+     $                      -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
                CALL DORGLQ( Q-1, Q-1, Q-1, V1T, LDV1T,
-     $                      0, WORK(1), -1, CHILDINFO )
+     $                      DUM, WORK(1), -1, CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q-1 )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL DBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                   0, U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, WORK(1), -1, CHILDINFO )
+     $                   DUM, U1, LDU1, U2, LDU2, V1T, LDV1T,
+     $                   DUM, 1, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, DUM,
+     $                   DUM, WORK(1), -1, CHILDINFO )
             LBBCSD = INT( WORK(1) )
          ELSE IF( R .EQ. P ) THEN
-            CALL DORBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL DORBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM,
+     $                    WORK(1), -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL DORGQR( P-1, P-1, P-1, U1(2,2), LDU1, 0, WORK(1),
-     $                      -1, CHILDINFO )
+               CALL DORGQR( P-1, P-1, P-1, U1(2,2), LDU1, DUM,
+     $                      WORK(1), -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL DORGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
-     $                      CHILDINFO )
+               CALL DORGQR( M-P, M-P, Q, U2, LDU2, DUM, WORK(1),
+     $                      -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL DORGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL DORGLQ( Q, Q, R, V1T, LDV1T, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL DBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                   0, V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, WORK(1), -1, CHILDINFO )
+     $                   DUM, V1T, LDV1T, DUM, 1, U1, LDU1,
+     $                   U2, LDU2, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, DUM,
+     $                   DUM, WORK(1), -1, CHILDINFO )
             LBBCSD = INT( WORK(1) )
          ELSE IF( R .EQ. M-P ) THEN
-            CALL DORBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL DORBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM,
+     $                    WORK(1), -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL DORGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL DORGQR( P, P, Q, U1, LDU1, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL DORGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2, 0,
-     $                      WORK(1), -1, CHILDINFO )
+               CALL DORGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2,
+     $                      DUM, WORK(1), -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL DORGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL DORGLQ( Q, Q, R, V1T, LDV1T, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL DBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                   THETA, 0, 0, 1, V1T, LDV1T, U2, LDU2, U1, LDU1,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, WORK(1), -1,
-     $                   CHILDINFO )
+     $                   THETA, DUM, DUM, 1, V1T, LDV1T, U2,
+     $                   LDU2, U1, LDU1, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, DUM,
+     $                   DUM, WORK(1), -1, CHILDINFO )
             LBBCSD = INT( WORK(1) )
          ELSE
-            CALL DORBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, 0, WORK(1), -1, CHILDINFO )
+            CALL DORBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM,
+     $                    DUM, WORK(1), -1, CHILDINFO )
             LORBDB = M + INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL DORGQR( P, P, M-Q, U1, LDU1, 0, WORK(1), -1,
+               CALL DORGQR( P, P, M-Q, U1, LDU1, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL DORGQR( M-P, M-P, M-Q, U2, LDU2, 0, WORK(1), -1,
-     $                      CHILDINFO )
+               CALL DORGQR( M-P, M-P, M-Q, U2, LDU2, DUM, WORK(1),
+     $                      -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL DORGLQ( Q, Q, Q, V1T, LDV1T, 0, WORK(1), -1,
+               CALL DORGLQ( Q, Q, Q, V1T, LDV1T, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL DBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                   THETA, 0, U2, LDU2, U1, LDU1, 0, 1, V1T, LDV1T,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, WORK(1), -1,
-     $                   CHILDINFO )
+     $                   THETA, DUM, U2, LDU2, U1, LDU1, DUM,
+     $                   1, V1T, LDV1T, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, DUM,
+     $                   DUM, WORK(1), -1, CHILDINFO )
             LBBCSD = INT( WORK(1) )
          END IF
          LWORKMIN = MAX( IORBDB+LORBDB-1,
@@ -517,11 +530,11 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL DBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                WORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1,
-     $                WORK(IB11D), WORK(IB11E), WORK(IB12D),
-     $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
-     $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
-     $                CHILDINFO )
+     $                WORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T,
+     $                DUM, 1, WORK(IB11D), WORK(IB11E),
+     $                WORK(IB12D), WORK(IB12E), WORK(IB21D),
+     $                WORK(IB21E), WORK(IB22D), WORK(IB22E),
+     $                WORK(IBBCSD), LBBCSD, CHILDINFO )
 *   
 *        Permute rows and columns to place zero submatrices in
 *        preferred positions
@@ -571,8 +584,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL DBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                WORK(IPHI), V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2,
-     $                WORK(IB11D), WORK(IB11E), WORK(IB12D),
+     $                WORK(IPHI), V1T, LDV1T, DUM, 1, U1, LDU1, U2,
+     $                LDU2, WORK(IB11D), WORK(IB11E), WORK(IB12D),
      $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
      $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
@@ -626,11 +639,11 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL DBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                THETA, WORK(IPHI), 0, 1, V1T, LDV1T, U2, LDU2, U1,
-     $                LDU1, WORK(IB11D), WORK(IB11E), WORK(IB12D),
-     $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
-     $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
-     $                CHILDINFO )
+     $                THETA, WORK(IPHI), DUM, 1, V1T, LDV1T, U2,
+     $                LDU2, U1, LDU1, WORK(IB11D), WORK(IB11E),
+     $                WORK(IB12D), WORK(IB12E), WORK(IB21D),
+     $                WORK(IB21E), WORK(IB22D), WORK(IB22E),
+     $                WORK(IBBCSD), LBBCSD, CHILDINFO )
 *   
 *        Permute rows and columns to place identity submatrices in
 *        preferred positions
@@ -695,11 +708,11 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL DBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                THETA, WORK(IPHI), U2, LDU2, U1, LDU1, 0, 1, V1T,
-     $                LDV1T, WORK(IB11D), WORK(IB11E), WORK(IB12D),
-     $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
-     $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
-     $                CHILDINFO )
+     $                THETA, WORK(IPHI), U2, LDU2, U1, LDU1, DUM,
+     $                1, V1T, LDV1T, WORK(IB11D), WORK(IB11E),
+     $                WORK(IB12D), WORK(IB12E), WORK(IB21D),
+     $                WORK(IB21E), WORK(IB22D), WORK(IB22E),
+     $                WORK(IBBCSD), LBBCSD, CHILDINFO )
 *   
 *        Permute rows and columns to place identity submatrices in
 *        preferred positions
diff --git a/SRC/sorcsd2by1.f b/SRC/sorcsd2by1.f
index 1bc71cda..71b547d7 100644
--- a/SRC/sorcsd2by1.f
+++ b/SRC/sorcsd2by1.f
@@ -264,6 +264,9 @@
      $                   LWORKMIN, LWORKOPT, R
       LOGICAL            LQUERY, WANTU1, WANTU2, WANTV1T
 *     ..
+*     .. Local Arrays ..
+      REAL               DUM( 1 )
+*     ..
 *     .. External Subroutines ..
       EXTERNAL           SBBCSD, SCOPY, SLACPY, SLAPMR, SLAPMT, SORBDB1,
      $                   SORBDB2, SORBDB3, SORBDB4, SORGLQ, SORGQR,
@@ -347,109 +350,119 @@
          LORGLQMIN = 1
          LORGLQOPT = 1
          IF( R .EQ. Q ) THEN
-            CALL SORBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK, -1, CHILDINFO )
+            CALL SORBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM, WORK, -1,
+     $                    CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL SORGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL SORGQR( P, P, Q, U1, LDU1, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             ENDIF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL SORGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
+               CALL SORGQR( M-P, M-P, Q, U2, LDU2, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
                CALL SORGLQ( Q-1, Q-1, Q-1, V1T, LDV1T,
-     $                      0, WORK(1), -1, CHILDINFO )
+     $                      DUM, WORK(1), -1, CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q-1 )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL SBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                   0, U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, WORK(1), -1, CHILDINFO )
+     $                   DUM, U1, LDU1, U2, LDU2, V1T, LDV1T, DUM,
+     $                   1, DUM, DUM, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, WORK(1), -1, CHILDINFO
+     $                 )
             LBBCSD = INT( WORK(1) )
          ELSE IF( R .EQ. P ) THEN
-            CALL SORBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL SORBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM, WORK(1), -1,
+     $                    CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL SORGQR( P-1, P-1, P-1, U1(2,2), LDU1, 0, WORK(1),
-     $                      -1, CHILDINFO )
+               CALL SORGQR( P-1, P-1, P-1, U1(2,2), LDU1, DUM,
+     $                      WORK(1), -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL SORGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
+               CALL SORGQR( M-P, M-P, Q, U2, LDU2, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL SORGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL SORGLQ( Q, Q, R, V1T, LDV1T, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL SBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                   0, V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, WORK(1), -1, CHILDINFO )
+     $                   DUM, V1T, LDV1T, DUM, 1, U1, LDU1, U2,
+     $                   LDU2, DUM, DUM, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, WORK(1), -1, CHILDINFO
+     $                 )
             LBBCSD = INT( WORK(1) )
          ELSE IF( R .EQ. M-P ) THEN
-            CALL SORBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL SORBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM, WORK(1), -1,
+     $                    CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL SORGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL SORGQR( P, P, Q, U1, LDU1, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL SORGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2, 0,
+               CALL SORGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2, DUM,
      $                      WORK(1), -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL SORGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL SORGLQ( Q, Q, R, V1T, LDV1T, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL SBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                   THETA, 0, 0, 1, V1T, LDV1T, U2, LDU2, U1, LDU1,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, WORK(1), -1,
+     $                   THETA, DUM, DUM, 1, V1T, LDV1T, U2, LDU2,
+     $                   U1, LDU1, DUM, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, DUM, WORK(1), -1,
      $                   CHILDINFO )
             LBBCSD = INT( WORK(1) )
          ELSE
-            CALL SORBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, 0, WORK(1), -1, CHILDINFO )
+            CALL SORBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA,
+     $                    DUM, DUM, DUM, DUM, DUM,
+     $                    WORK(1), -1, CHILDINFO )
             LORBDB = M + INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL SORGQR( P, P, M-Q, U1, LDU1, 0, WORK(1), -1,
+               CALL SORGQR( P, P, M-Q, U1, LDU1, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL SORGQR( M-P, M-P, M-Q, U2, LDU2, 0, WORK(1), -1,
-     $                      CHILDINFO )
+               CALL SORGQR( M-P, M-P, M-Q, U2, LDU2, DUM, WORK(1),
+     $                      -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL SORGLQ( Q, Q, Q, V1T, LDV1T, 0, WORK(1), -1,
+               CALL SORGLQ( Q, Q, Q, V1T, LDV1T, DUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL SBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                   THETA, 0, U2, LDU2, U1, LDU1, 0, 1, V1T, LDV1T,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, WORK(1), -1,
+     $                   THETA, DUM, U2, LDU2, U1, LDU1, DUM, 1,
+     $                   V1T, LDV1T, DUM, DUM, DUM, DUM,
+     $                   DUM, DUM, DUM, DUM, WORK(1), -1,
      $                   CHILDINFO )
             LBBCSD = INT( WORK(1) )
          END IF
@@ -515,8 +528,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL SBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                WORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1,
-     $                WORK(IB11D), WORK(IB11E), WORK(IB12D),
+     $                WORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T,
+     $                DUM, 1, WORK(IB11D), WORK(IB11E), WORK(IB12D),
      $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
      $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
@@ -569,8 +582,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL SBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                WORK(IPHI), V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2,
-     $                WORK(IB11D), WORK(IB11E), WORK(IB12D),
+     $                WORK(IPHI), V1T, LDV1T, DUM, 1, U1, LDU1, U2,
+     $                LDU2, WORK(IB11D), WORK(IB11E), WORK(IB12D),
      $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
      $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
@@ -624,11 +637,11 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL SBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                THETA, WORK(IPHI), 0, 1, V1T, LDV1T, U2, LDU2, U1,
-     $                LDU1, WORK(IB11D), WORK(IB11E), WORK(IB12D),
-     $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
-     $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
-     $                CHILDINFO )
+     $                THETA, WORK(IPHI), DUM, 1, V1T, LDV1T, U2,
+     $                LDU2, U1, LDU1, WORK(IB11D), WORK(IB11E),
+     $                WORK(IB12D), WORK(IB12E), WORK(IB21D),
+     $                WORK(IB21E), WORK(IB22D), WORK(IB22E),
+     $                WORK(IBBCSD), LBBCSD, CHILDINFO )
 *   
 *        Permute rows and columns to place identity submatrices in
 *        preferred positions
@@ -693,8 +706,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL SBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                THETA, WORK(IPHI), U2, LDU2, U1, LDU1, 0, 1, V1T,
-     $                LDV1T, WORK(IB11D), WORK(IB11E), WORK(IB12D),
+     $                THETA, WORK(IPHI), U2, LDU2, U1, LDU1, DUM, 1,
+     $                V1T, LDV1T, WORK(IB11D), WORK(IB11E), WORK(IB12D),
      $                WORK(IB12E), WORK(IB21D), WORK(IB21E),
      $                WORK(IB22D), WORK(IB22E), WORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
diff --git a/SRC/zgesdd.f b/SRC/zgesdd.f
index 5e086a2a..0acbcba7 100644
--- a/SRC/zgesdd.f
+++ b/SRC/zgesdd.f
@@ -341,11 +341,11 @@
 *           not including e, RU, and RVT matrices.
 *
 *           Compute space preferred for each routine
-            CALL ZGEBRD( M, N, CDUM(1), M, CDUM(1), DUM(1), CDUM(1),
+            CALL ZGEBRD( M, N, CDUM(1), M, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_ZGEBRD_MN = INT( CDUM(1) )
 *
-            CALL ZGEBRD( N, N, CDUM(1), N, CDUM(1), DUM(1), CDUM(1),
+            CALL ZGEBRD( N, N, CDUM(1), N, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_ZGEBRD_NN = INT( CDUM(1) )
 *
@@ -482,11 +482,11 @@
 *           not including e, RU, and RVT matrices.
 *
 *           Compute space preferred for each routine
-            CALL ZGEBRD( M, N, CDUM(1), M, CDUM(1), DUM(1), CDUM(1),
+            CALL ZGEBRD( M, N, CDUM(1), M, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_ZGEBRD_MN = INT( CDUM(1) )
 *
-            CALL ZGEBRD( M, M, CDUM(1), M, CDUM(1), DUM(1), CDUM(1),
+            CALL ZGEBRD( M, M, CDUM(1), M, DUM(1), DUM(1), CDUM(1),
      $                   CDUM(1), CDUM(1), -1, IERR )
             LWORK_ZGEBRD_MM = INT( CDUM(1) )
 *
diff --git a/SRC/zuncsd2by1.f b/SRC/zuncsd2by1.f
index dc0be07a..8c0a2c07 100644
--- a/SRC/zuncsd2by1.f
+++ b/SRC/zuncsd2by1.f
@@ -287,6 +287,10 @@
      $                   LWORKMIN, LWORKOPT, R
       LOGICAL            LQUERY, WANTU1, WANTU2, WANTV1T
 *     ..
+*     .. Local Arrays ..
+      DOUBLE PRECISION   DUM( 1 )
+      COMPLEX*16         CDUM( 1 )
+*     ..
 *     .. External Subroutines ..
       EXTERNAL           ZBBCSD, ZCOPY, ZLACPY, ZLAPMR, ZLAPMT, ZUNBDB1,
      $                   ZUNBDB2, ZUNBDB3, ZUNBDB4, ZUNGLQ, ZUNGQR,
@@ -384,110 +388,113 @@
          LORGLQMIN = 1
          LORGLQOPT = 1
          IF( R .EQ. Q ) THEN
-            CALL ZUNBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK, -1, CHILDINFO )
+            CALL ZUNBDB1( M, P, Q, X11, LDX11, X21, LDX21, THETA, DUM,
+     $                    CDUM, CDUM, CDUM, WORK, -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL ZUNGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL ZUNGQR( P, P, Q, U1, LDU1, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             ENDIF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL ZUNGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
+               CALL ZUNGQR( M-P, M-P, Q, U2, LDU2, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
                CALL ZUNGLQ( Q-1, Q-1, Q-1, V1T, LDV1T,
-     $                      0, WORK(1), -1, CHILDINFO )
+     $                      CDUM, WORK(1), -1, CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q-1 )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL ZBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                   0, U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, RWORK(1), -1, CHILDINFO )
+     $                   DUM, U1, LDU1, U2, LDU2, V1T, LDV1T, CDUM, 1,
+     $                   DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          ELSE IF( R .EQ. P ) THEN
-            CALL ZUNBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL ZUNBDB2( M, P, Q, X11, LDX11, X21, LDX21, THETA, DUM,
+     $                    CDUM, CDUM, CDUM, WORK(1), -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL ZUNGQR( P-1, P-1, P-1, U1(2,2), LDU1, 0, WORK(1),
+               CALL ZUNGQR( P-1, P-1, P-1, U1(2,2), LDU1, CDUM, WORK(1),
      $                      -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL ZUNGQR( M-P, M-P, Q, U2, LDU2, 0, WORK(1), -1,
+               CALL ZUNGQR( M-P, M-P, Q, U2, LDU2, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL ZUNGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL ZUNGLQ( Q, Q, R, V1T, LDV1T, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL ZBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                   0, V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2, 0, 0,
-     $                   0, 0, 0, 0, 0, 0, RWORK(1), -1, CHILDINFO )
+     $                   DUM, V1T, LDV1T, CDUM, 1, U1, LDU1, U2, LDU2,
+     $                   DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          ELSE IF( R .EQ. M-P ) THEN
-            CALL ZUNBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, WORK(1), -1, CHILDINFO )
+            CALL ZUNBDB3( M, P, Q, X11, LDX11, X21, LDX21, THETA, DUM,
+     $                    CDUM, CDUM, CDUM, WORK(1), -1, CHILDINFO )
             LORBDB = INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL ZUNGQR( P, P, Q, U1, LDU1, 0, WORK(1), -1,
+               CALL ZUNGQR( P, P, Q, U1, LDU1, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL ZUNGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2, 0,
+               CALL ZUNGQR( M-P-1, M-P-1, M-P-1, U2(2,2), LDU2, CDUM,
      $                      WORK(1), -1, CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P-1 )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL ZUNGLQ( Q, Q, R, V1T, LDV1T, 0, WORK(1), -1,
+               CALL ZUNGLQ( Q, Q, R, V1T, LDV1T, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL ZBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                   THETA, 0, 0, 1, V1T, LDV1T, U2, LDU2, U1, LDU1,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, RWORK(1), -1,
-     $                   CHILDINFO )
+     $                   THETA, DUM, CDUM, 1, V1T, LDV1T, U2, LDU2, U1,
+     $                   LDU1, DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          ELSE
-            CALL ZUNBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA, 0, 0,
-     $                    0, 0, 0, WORK(1), -1, CHILDINFO )
+            CALL ZUNBDB4( M, P, Q, X11, LDX11, X21, LDX21, THETA, DUM,
+     $                    CDUM, CDUM, CDUM, CDUM, WORK(1), -1, CHILDINFO
+     $                  )
             LORBDB = M + INT( WORK(1) )
             IF( WANTU1 .AND. P .GT. 0 ) THEN
-               CALL ZUNGQR( P, P, M-Q, U1, LDU1, 0, WORK(1), -1,
+               CALL ZUNGQR( P, P, M-Q, U1, LDU1, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTU2 .AND. M-P .GT. 0 ) THEN
-               CALL ZUNGQR( M-P, M-P, M-Q, U2, LDU2, 0, WORK(1), -1,
+               CALL ZUNGQR( M-P, M-P, M-Q, U2, LDU2, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGQRMIN = MAX( LORGQRMIN, M-P )
                LORGQROPT = MAX( LORGQROPT, INT( WORK(1) ) )
             END IF
             IF( WANTV1T .AND. Q .GT. 0 ) THEN
-               CALL ZUNGLQ( Q, Q, Q, V1T, LDV1T, 0, WORK(1), -1,
+               CALL ZUNGLQ( Q, Q, Q, V1T, LDV1T, CDUM, WORK(1), -1,
      $                      CHILDINFO )
                LORGLQMIN = MAX( LORGLQMIN, Q )
                LORGLQOPT = MAX( LORGLQOPT, INT( WORK(1) ) )
             END IF
             CALL ZBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                   THETA, 0, U2, LDU2, U1, LDU1, 0, 1, V1T, LDV1T,
-     $                   0, 0, 0, 0, 0, 0, 0, 0, RWORK(1), -1,
-     $                   CHILDINFO )
+     $                   THETA, DUM, U2, LDU2, U1, LDU1, CDUM, 1, V1T,
+     $                   LDV1T, DUM, DUM, DUM, DUM, DUM, DUM, DUM, DUM,
+     $                   RWORK(1), -1, CHILDINFO )
             LBBCSD = INT( RWORK(1) )
          END IF
          LRWORKMIN = IBBCSD+LBBCSD-1
@@ -553,8 +560,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL ZBBCSD( JOBU1, JOBU2, JOBV1T, 'N', 'N', M, P, Q, THETA,
-     $                RWORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T, 0, 1,
-     $                RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
+     $                RWORK(IPHI), U1, LDU1, U2, LDU2, V1T, LDV1T, CDUM,
+     $                1, RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
      $                RWORK(IB12E), RWORK(IB21D), RWORK(IB21E),
      $                RWORK(IB22D), RWORK(IB22E), RWORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
@@ -607,8 +614,8 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL ZBBCSD( JOBV1T, 'N', JOBU1, JOBU2, 'T', M, Q, P, THETA,
-     $                RWORK(IPHI), V1T, LDV1T, 0, 1, U1, LDU1, U2, LDU2,
-     $                RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
+     $                RWORK(IPHI), V1T, LDV1T, CDUM, 1, U1, LDU1, U2,
+     $                LDU2, RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
      $                RWORK(IB12E), RWORK(IB21D), RWORK(IB21E),
      $                RWORK(IB22D), RWORK(IB22E), RWORK(IBBCSD), LBBCSD,
      $                CHILDINFO )
@@ -662,7 +669,7 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL ZBBCSD( 'N', JOBV1T, JOBU2, JOBU1, 'T', M, M-Q, M-P,
-     $                THETA, RWORK(IPHI), 0, 1, V1T, LDV1T, U2, LDU2,
+     $                THETA, RWORK(IPHI), CDUM, 1, V1T, LDV1T, U2, LDU2,
      $                U1, LDU1, RWORK(IB11D), RWORK(IB11E),
      $                RWORK(IB12D), RWORK(IB12E), RWORK(IB21D),
      $                RWORK(IB21E), RWORK(IB22D), RWORK(IB22E),
@@ -731,11 +738,11 @@
 *        Simultaneously diagonalize X11 and X21.
 *   
          CALL ZBBCSD( JOBU2, JOBU1, 'N', JOBV1T, 'N', M, M-P, M-Q,
-     $                THETA, RWORK(IPHI), U2, LDU2, U1, LDU1, 0, 1, V1T,
-     $                LDV1T, RWORK(IB11D), RWORK(IB11E), RWORK(IB12D),
-     $                RWORK(IB12E), RWORK(IB21D), RWORK(IB21E),
-     $                RWORK(IB22D), RWORK(IB22E), RWORK(IBBCSD), LBBCSD,
-     $                CHILDINFO )
+     $                THETA, RWORK(IPHI), U2, LDU2, U1, LDU1, CDUM, 1,
+     $                V1T, LDV1T, RWORK(IB11D), RWORK(IB11E),
+     $                RWORK(IB12D), RWORK(IB12E), RWORK(IB21D),
+     $                RWORK(IB21E), RWORK(IB22D), RWORK(IB22E),
+     $                RWORK(IBBCSD), LBBCSD, CHILDINFO )
 *   
 *        Permute rows and columns to place identity submatrices in
 *        preferred positions