      program CONS01234

c     TESTING OF THE CONSISTENT CLAUSE'.
c     CHECKING DISTRIBUTION WITH NO BLOCKS.

      print *,'===START OF CONS01234========================'
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons0101
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons0102
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons0103
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons0104
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons0105
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons0106
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons0107
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons0108
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons0109
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons0110
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons0111
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons0112
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons0113
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons0114
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons0115
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons0116
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons0201
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons0202
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons0203
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons0204
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons0205
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons0206
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons0207
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons0208
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons0209
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons0210
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons0211
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons0212
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons0213
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons0214
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons0215
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons0216
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons0301
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons0302
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons0303
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons0304
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons0305
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons0306
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons0307
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons0308
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons0309
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons0310
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons0311
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons0312
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons0313
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons0314
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons0315
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons0316
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons0401
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons0402
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons0403
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons0404
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons0405
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons0406
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons0407
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons0408
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons0409
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons0410
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons0411
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons0412
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons0413
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons0414
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons0415
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons0416
C --------------------------------------------------
C
      print *,'=== END OF CONS01234 ========================= '
      end
C ---------------------------------------------cons0101
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS0101
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N),C(N))
      tname='CONS0101'
      DO I = 1, N
            C(I)  = I
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
            B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0102
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0102
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),V(N),W(N),C(N))
      tname='CONS0102'
      DO I = 1, N
            C(I)  = I
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I)
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = B(I)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
      IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0103
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0103
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),A(:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   DISTRIBUTE     ( * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),A(N),V(N),W(N),C(N))
      tname='CONS0103'
      DO I = 1, N
            C(I)  = I
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL    (I)   ON   A(I)
      DO I = 1, N
                  A(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I)
      ENDDO
!DVM$   PARALLEL  (I)   ON  A(I), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = A(I)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
      IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0104
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0104
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N),C(N))
      tname='CONS0104'
      DO I = 1, N
            C(I)  = I
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0105
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS0105
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N,N),C(N,N))
      tname='CONS0105'
      DO J = 1, N
      DO I = 1, N
                  C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
            B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J), CONSISTENT(V(I,:))
      DO I = 1, N
      DO J = 1, N
                  V(I,J) = B(I) + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J) .NE. C(I,J)) THEN
                              IERR = C(I,J)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0106
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0106
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),V(N,N),W(N,N),C(N,N))
      tname='CONS0106'
      DO J = 1, N
      DO I = 1, N
                  C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J), CONSISTENT(V(I,:))
      DO I = 1, N
      DO J = 1, N
                  V(I,J) = B(I) + (N - 1) * J
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J), CONSISTENT(W(I,:))
      DO I = 1, N
      DO J = 1, N
                  W(I,J) = B(I) + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J) .NE. C(I,J)) THEN
                              IERR = C(I,J)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
                  IF(W(I,J) .NE. C(I,J)) THEN
                              IERR = C(I,J)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0107
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0107
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),A(:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   DISTRIBUTE     ( * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),A(N),V(N,N),W(N,N),C(N,N))
      tname='CONS0107'
      DO J = 1, N
      DO I = 1, N
                  C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL    (I)   ON   A(I)
      DO I = 1, N
                  A(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J), CONSISTENT(V(I,:))
      DO I = 1, N
      DO J = 1, N
                  V(I,J) = B(I) + (N - 1) * J
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  A(I), private(J), CONSISTENT(W(I,:))
      DO I = 1, N
      DO J = 1, N
                  W(I,J) = A(I) + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J) .NE. C(I,J)) THEN
                              IERR = C(I,J)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
                  IF(W(I,J) .NE. C(I,J)) THEN
                              IERR = C(I,J)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0108
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0108
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N,N),C(N,N))
      tname='CONS0108'
      DO J = 1, N
      DO I = 1, N
                  C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J), CONSISTENT(V(I,:))
      DO I = 1, N
      DO J = 1, N
                  V(I,J) = B(I) + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J) .NE. C(I,J)) THEN
                              IERR = C(I,J)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0109
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS0109
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N,N,N),C(N,N,N))
      tname='CONS0109'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
            B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K), CONSISTENT(V(I,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
            V(I,J,K) = B(I) + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K) .NE. C(I,J,K)) THEN
                              IERR = C(I,J,K)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0110
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0110
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0110'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K), CONSISTENT(V(I,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
            V(I,J,K) = B(I) + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K), CONSISTENT(W(I,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
            W(I,J,K) = B(I) + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K) .NE. C(I,J,K)) THEN
                              IERR = C(I,J,K)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(W(I,J,K) .NE. C(I,J,K)) THEN
                              IERR = C(I,J,K)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0111
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0111
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),A(:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   DISTRIBUTE     ( * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),A(N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0111'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL    (I)   ON   A(I)
      DO I = 1, N
                  A(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K), CONSISTENT(V(I,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
            V(I,J,K) = B(I) + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  A(I), private(J,K), CONSISTENT(W(I,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
            W(I,J,K) = A(I) + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K) .NE. C(I,J,K)) THEN
                              IERR = C(I,J,K)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(W(I,J,K) .NE. C(I,J,K)) THEN
                              IERR = C(I,J,K)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0112
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0112
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N,N,N),C(N,N,N))
      tname='CONS0112'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K), CONSISTENT(V(I,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
            V(I,J,K) = B(I) + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K) .NE. C(I,J,K)) THEN
                              IERR = C(I,J,K)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0113
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS0113
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0113'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
            B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K,L), CONSISTENT(V(I,:,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I)+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                              IERR = C(I,J,K,L)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0114
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0114
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0114'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K,L), CONSISTENT(V(I,:,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I)+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K,L), CONSISTENT(W(I,:,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
      DO L = 1, N
            W(I,J,K,L)=B(I)+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                              IERR = C(I,J,K,L)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                              IERR = C(I,J,K,L)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0115
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0115
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:),A(:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   DISTRIBUTE     ( * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N),A(N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0115'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL    (I)   ON   A(I)
      DO I = 1, N
                  A(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K,L), CONSISTENT(V(I,:,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I)+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  A(I), private(J,K,L), CONSISTENT(W(I,:,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
      DO L = 1, N
            W(I,J,K,L)=A(I)+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                              IERR = C(I,J,K,L)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                              IERR = C(I,J,K,L)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0116
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0116
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0116'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (I)   ON   B(I)
      DO I = 1, N
                  B(I) = I
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I), private(J,K,L), CONSISTENT(V(I,:,:,:))
      DO I = 1, N
      DO J = 1, N
      DO K = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I)+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
                  IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                              IERR = C(I,J,K,L)
                              EXIT
                  ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (I)   ON  B(I), REDUCTION(MIN(ERROR))
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0201
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS0201
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N),C(N))
      tname='CONS0201'
      DO I = 1, N
            C(I)  = I + (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0202
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0202
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N),W(N),C(N))
      tname='CONS0202'
      DO I = 1, N
            C(I)  = I + (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1)
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = B(I,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
            IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0203
C consistent arrays with 1 dimensions
      subroutine CONS0203
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N),W(N),C(N))
      tname='CONS0203'
      DO I = 1, N
            C(I)  = I + (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL    (J,I)   ON   A(I,J)
      DO J = 1, N
      DO I = 1, N
            A(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1)
      ENDDO
!DVM$ PARALLEL (I) ON A(I,1), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = A(I,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
            IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0204
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0204
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N),C(N))
      tname='CONS0204'
      DO I = 1, N
            C(I)  = I + (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0205
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS0205
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N),C(N,N))
      tname='CONS0205'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0206
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0206
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS0206'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J)
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), CONSISTENT(W(I,J))
      DO J = 1, N
      DO I = 1, N
            W(I,J) = B(I,J)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0207
C consistent arrays with 2 dimensions
      subroutine CONS0207
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS0207'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL    (J,I)   ON   A(I,J)
      DO J = 1, N
      DO I = 1, N
            A(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J)
      ENDDO
      ENDDO
!DVM$ PARALLEL (J,I) ON A(I,J), CONSISTENT(W(I,J))
      DO J = 1, N
      DO I = 1, N
            W(I,J) = A(I,J)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0208
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0208
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N),C(N,N))
      tname='CONS0208'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0209
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS0209
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N),C(N,N,N))
      tname='CONS0209'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K), CONSISTENT(V(I,J,:))
      DO J = 1, N
      DO I = 1, N
      DO K = 1, N
            V(I,J,K) = B(I,J) + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0210
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0210
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0210'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K), CONSISTENT(V(I,J,:))
      DO J = 1, N
      DO I = 1, N
      DO K = 1, N
            V(I,J,K) = B(I,J) + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K), CONSISTENT(W(I,J,:))
      DO J = 1, N
      DO I = 1, N
      DO K = 1, N
            W(I,J,K) = B(I,J) + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0211
C consistent arrays with 3 dimensions
      subroutine CONS0211
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0211'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL    (J,I)   ON   A(I,J)
      DO J = 1, N
      DO I = 1, N
            A(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K), CONSISTENT(V(I,J,:))
      DO J = 1, N
      DO I = 1, N
      DO K = 1, N
            V(I,J,K) = B(I,J) + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!DVM$ PARALLEL (J,I) ON A(I,J), private(K), CONSISTENT(W(I,J,:))
      DO J = 1, N
      DO I = 1, N
      DO K = 1, N
            W(I,J,K) = A(I,J) + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0212
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0212
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N),C(N,N,N))
      tname='CONS0212'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K), CONSISTENT(V(I,J,:))
      DO J = 1, N
      DO I = 1, N
      DO K = 1, N
            V(I,J,K) = B(I,J) + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0213
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS0213
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0213'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K,L), CONSISTENT(V(I,J,:,:))
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
      DO K = 1, N
            V(I,J,K,L)=B(I,J)+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0214
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0214
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0214'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K,L), CONSISTENT(V(I,J,:,:))
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
      DO K = 1, N
            V(I,J,K,L)=B(I,J)+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K,L), CONSISTENT(W(I,J,:,:))
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
      DO K = 1, N
            W(I,J,K,L)=B(I,J)+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0215
C consistent arrays with 4 dimensions
      subroutine CONS0215
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0215'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL    (J,I)   ON   A(I,J)
      DO J = 1, N
      DO I = 1, N
            A(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K,L), CONSISTENT(V(I,J,:,:))
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
      DO K = 1, N
            V(I,J,K,L)=B(I,J)+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$ PARALLEL (J,I) ON A(I,J), private(K,L), CONSISTENT(W(I,J,:,:))
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
      DO K = 1, N
            W(I,J,K,L)=A(I,J)+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0216
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0216
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0216'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (J,I)   ON   B(I,J)
      DO J = 1, N
      DO I = 1, N
            B(I,J) = I+(N-1)*J
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J), private(K,L), CONSISTENT(V(I,J,:,:))
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
      DO K = 1, N
            V(I,J,K,L)=B(I,J)+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (J,I)   ON  B(I,J), REDUCTION(MIN(ERROR))
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0301
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS0301
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS0301'
      DO I = 1, N
            C(I)  = I + (N - 1) + (N - 1) * (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0302
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0302
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N),W(N),C(N))
      tname='CONS0302'
      DO I = 1, N
            C(I)  = I + (N - 1) + (N - 1) * (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1)
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1,1), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = B(I,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
            IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0303
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0303
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N),W(N),C(N))
      tname='CONS0303'
      DO I = 1, N
            C(I)  = I + (N - 1) + (N - 1) * (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (K,J,I)   ON   A(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1)
      ENDDO
!DVM$   PARALLEL (I) ON A(I,1,1), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = A(I,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
            IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0304
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0304
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS0304'
      DO I = 1, N
            C(I)  = I + (N - 1) + (N - 1) * (N - 1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (I) ON B(I,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0305
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS0305
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS0305'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J + (N - 1) * (N - 1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0306
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0306
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS0306'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J + (N - 1) * (N - 1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1)
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J,1), CONSISTENT(W(I,J))
      DO J = 1, N
      DO I = 1, N
            W(I,J) = B(I,J,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0307
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0307
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS0307'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J + (N - 1) * (N - 1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (K,J,I)   ON   A(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1)
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON A(I,J,1), CONSISTENT(W(I,J))
      DO J = 1, N
      DO I = 1, N
            W(I,J) = A(I,J,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0308
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0308
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS0308'
      DO J = 1, N
      DO I = 1, N
            C(I,J)  = I + (N - 1) * J + (N - 1) * (N - 1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (J,I) ON B(I,J,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0309
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS0309
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS0309'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0310
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0310
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0310'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K)
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), CONSISTENT(W(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            W(I,J,K) = B(I,J,K)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0311
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0311
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0311'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (K,J,I)   ON   A(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K)
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON A(I,J,K), CONSISTENT(W(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            W(I,J,K) = A(I,J,K)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0312
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0312
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS0312'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)  = I + (N - 1) * J + (N - 1) * (N - 1) * K
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0313
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS0313
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0313'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), private(L), CONSISTENT(V(I,J,K,:))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I,J,K)+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0314
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0314
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0314'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), private(L), CONSISTENT(V(I,J,K,:))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I,J,K)+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), private(L), CONSISTENT(W(I,J,K,:))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
            W(I,J,K,L)=B(I,J,K)+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0315
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0315
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0315'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (K,J,I)   ON   A(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), private(L), CONSISTENT(V(I,J,K,:))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I,J,K)+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON A(I,J,K), private(L), CONSISTENT(W(I,J,K,:))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
            W(I,J,K,L)=A(I,J,K)+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0316
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0316
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0316'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (K,J,I)   ON   B(I,J,K)
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K) = I+(N-1)*J+(N-1)*(N-1)*K
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL (K,J,I) ON B(I,J,K), private(L), CONSISTENT(V(I,J,K,:))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
      DO L = 1, N
            V(I,J,K,L)=B(I,J,K)+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (K,J,I)   ON  B(I,J,K), REDUCTION(MIN(ERROR))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0401
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS0401
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS0401'
      DO I = 1, N
            C(I)=I+(N-1)+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I,1,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0402
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0402
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS0402'
      DO I = 1, N
            C(I)=I+(N-1)+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I,1,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1,1)
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I,1,1,1), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = B(I,1,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
            IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0403
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0403
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),A(N,N,N,N),V(N),W(N),C(N))
      tname='CONS0403'
      DO I = 1, N
            C(I)=I+(N-1)+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (L,K,J,I)   ON   A(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I,1,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1,1)
      ENDDO
!DVM$   PARALLEL  (I)   ON  A(I,1,1,1), CONSISTENT(W(I))
      DO I = 1, N
            W(I) = A(I,1,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      DO I = 1, N
            IF(W(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0404
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0404
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS0404'
      DO I = 1, N
            C(I)=I+(N-1)+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (I)   ON  B(I,1,1,1), CONSISTENT(V(I))
      DO I = 1, N
            V(I) = B(I,1,1,1)
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO I = 1, N
            IF(V(I) .NE. C(I)) THEN
                  IERR = C(I)
                  EXIT
            ENDIF
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0405
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS0405
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS0405'
      DO J = 1, N
      DO I = 1, N
            C(I,J)=I+(N-1)*J+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (J,I)   ON  B(I,J,1,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0406
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0406
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS0406'
      DO J = 1, N
      DO I = 1, N
            C(I,J)=I+(N-1)*J+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (J,I)   ON  B(I,J,1,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1,1)
      ENDDO
      ENDDO
!DVM$   PARALLEL  (J,I)   ON  B(I,J,1,1), CONSISTENT(W(I,J))
      DO J = 1, N
      DO I = 1, N
            W(I,J) = B(I,J,1,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0407
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0407
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),A(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS0407'
      DO J = 1, N
      DO I = 1, N
            C(I,J)=I+(N-1)*J+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (L,K,J,I)   ON   A(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (J,I)   ON  B(I,J,1,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1,1)
      ENDDO
      ENDDO
!DVM$   PARALLEL  (J,I)   ON  A(I,J,1,1), CONSISTENT(W(I,J))
      DO J = 1, N
      DO I = 1, N
            W(I,J) = A(I,J,1,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0408
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0408
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS0408'
      DO J = 1, N
      DO I = 1, N
            C(I,J)=I+(N-1)*J+(N-1)*(N-1)+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (J,I)   ON  B(I,J,1,1), CONSISTENT(V(I,J))
      DO J = 1, N
      DO I = 1, N
            V(I,J) = B(I,J,1,1)
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J) .NE. C(I,J)) THEN
                  IERR = C(I,J)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0409
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS0409
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS0409'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (K,J,I)   ON  B(I,J,K,1), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K,1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0410
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0410
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0410'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (K,J,I)   ON  B(I,J,K,1), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K,1)
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (K,J,I)   ON  B(I,J,K,1), CONSISTENT(W(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            W(I,J,K) = B(I,J,K,1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0411
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0411
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),A(N,N,N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS0411'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (L,K,J,I)   ON   A(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (K,J,I)   ON  B(I,J,K,1), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K,1)
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (K,J,I)   ON  A(I,J,K,1), CONSISTENT(W(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            W(I,J,K) = A(I,J,K,1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0412
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0412
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS0412'
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (K,J,I)   ON  B(I,J,K,1), CONSISTENT(V(I,J,K))
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K) = B(I,J,K,1)
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K) .NE. C(I,J,K)) THEN
                  IERR = C(I,J,K)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0413
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS0413
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0413'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), CONSISTENT(V(I,J,K,L))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K,L)=B(I,J,K,L)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END
C ---------------------------------------------cons0414
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS0414
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0414'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), CONSISTENT(V(I,J,K,L))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K,L)=B(I,J,K,L)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), CONSISTENT(W(I,J,K,L))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            W(I,J,K,L)=B(I,J,K,L)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, W, C)
      END
C ---------------------------------------------cons0415
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS0415
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),A(N,N,N,N),V(N,N,N,N),W(N,N,N,N),C(N,N,N,N))
      tname='CONS0415'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL    (L,K,J,I)   ON   A(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            A(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), CONSISTENT(V(I,J,K,L))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K,L)=B(I,J,K,L)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (L,K,J,I)   ON  A(I,J,K,L), CONSISTENT(W(I,J,K,L))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            W(I,J,K,L)=A(I,J,K,L)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V, W)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(W(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, A, V, W, C)
      END
C ---------------------------------------------cons0416
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS0416
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS0416'
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            C(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ region
!DVM$   PARALLEL    (L,K,J,I)   ON   B(I,J,K,L)
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            B(I,J,K,L)=I+(N-1)*J+(N-1)*(N-1)*K+(N-1)*(N-1)*(N-1)*L
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!DVM$   PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), CONSISTENT(V(I,J,K,L))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            V(I,J,K,L)=B(I,J,K,L)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
!dvm$ end region
!dvm$ get_actual (V)
      IERR = ER
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            IF(V(I,J,K,L) .NE. C(I,J,K,L)) THEN
                  IERR = C(I,J,K,L)
                  EXIT
            ENDIF
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      ERROR = ER
!DVM$  PARALLEL  (L,K,J,I)   ON  B(I,J,K,L), REDUCTION(MIN(ERROR))
      DO L = 1, N
      DO K = 1, N
      DO J = 1, N
      DO I = 1, N
            ERROR = MIN(ERROR,IERR)
      ENDDO
      ENDDO
      ENDDO
      ENDDO
      IF(ERROR .EQ. ER) THEN
            call ansyes(tname)
      ELSE
            call ansno(tname)
      ENDIF
      deallocate (B, V, C)
      END

C --------------------------------------------------
      subroutine ansyes(name)
      character*8 name
      print *,name,'  -  complete'
      end
      subroutine ansno(name)
      character*8 name
      print *,name,'  -  ***error'
      end
