      program CONS1234

c      TESTING OF THE CONSISTENT CLAUSE'.
c      CHECKING DISTRIBUTION WITH ONE BLOCK.

      print *,'===START OF CONS1234========================'
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1201
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1202
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1203
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1204
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1205
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1206
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1207
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1208
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1209
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1210
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1211
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1212
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1213
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1214
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1215
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1216
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1217
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1218
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1219
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1220
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1221
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1222
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1223
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1224
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1225
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1226
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1227
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1228
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1229
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1230
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1231
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1232
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1301
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1302
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1303
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1304
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1305
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1306
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1307
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1308
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1309
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1310
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1311
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1312
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1313
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1314
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1315
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1316
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1317
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1318
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1319
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1320
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1321
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1322
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1323
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1324
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1325
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1326
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1327
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1328
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1329
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1330
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1331
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1332
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1333
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1334
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1335
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1336
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1337
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1338
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1339
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1340
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1341
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1342
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1343
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1344
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1345
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1346
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1347
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1348
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1401
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1402
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1403
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1404
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1405
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1406
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1407
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1408
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1409
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1410
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1411
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1412
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1413
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1414
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1415
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1416
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1417
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1418
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1419
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1420
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1421
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1422
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1423
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1424
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1425
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1426
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1427
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1428
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1429
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1430
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1431
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1432
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1433
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1434
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1435
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1436
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1437
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1438
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1439
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1440
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1441
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1442
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1443
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1444
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1445
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1446
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1447
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1448
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons1449
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons1450
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons1451
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons1452
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons1453
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons1454
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons1455
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons1456
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons1457
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons1458
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons1459
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons1460
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons1461
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons1462
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons1463
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons1464
C --------------------------------------------------
C
      print *,'=== END OF CONS1234 ========================= '
      end
C ---------------------------------------------cons1201
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1201
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N),C(N))
      tname='CONS1201'
      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 ---------------------------------------------cons1202
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1202
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N),W(N),C(N))
      tname='CONS1202'
      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 ---------------------------------------------cons1203
C consistent arrays with 1 dimensions
      subroutine CONS1203
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N),W(N),C(N))
      tname='CONS1203'
      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 ---------------------------------------------cons1204
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1204
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N),C(N))
      tname='CONS1204'
      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 ---------------------------------------------cons1205
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1205
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N),C(N,N))
      tname='CONS1205'
      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 ---------------------------------------------cons1206
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1206
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1206'
      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 ---------------------------------------------cons1207
C consistent arrays with 2 dimensions
      subroutine CONS1207
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1207'
      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 ---------------------------------------------cons1208
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1208
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N),C(N,N))
      tname='CONS1208'
      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 ---------------------------------------------cons1209
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1209
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N),C(N,N,N))
      tname='CONS1209'
      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 ---------------------------------------------cons1210
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1210
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS1210'
      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 ---------------------------------------------cons1211
C consistent arrays with 3 dimensions
      subroutine CONS1211
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   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='CONS1211'
      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 ---------------------------------------------cons1212
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1212
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N),C(N,N,N))
      tname='CONS1212'
      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 ---------------------------------------------cons1213
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1213
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1213'
      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 ---------------------------------------------cons1214
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1214
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   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='CONS1214'
      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 ---------------------------------------------cons1215
C consistent arrays with 4 dimensions
      subroutine CONS1215
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   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='CONS1215'
      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 ---------------------------------------------cons1216
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1216
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1216'
      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 ---------------------------------------------cons1217
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1217
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N),C(N))
      tname='CONS1217'
      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 ---------------------------------------------cons1218
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1218
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N),W(N),C(N))
      tname='CONS1218'
      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 ---------------------------------------------cons1219
C consistent arrays with 1 dimensions
      subroutine CONS1219
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N),W(N),C(N))
      tname='CONS1219'
      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 ---------------------------------------------cons1220
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1220
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N),C(N))
      tname='CONS1220'
      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 ---------------------------------------------cons1221
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1221
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N),C(N,N))
      tname='CONS1221'
      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 ---------------------------------------------cons1222
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1222
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1222'
      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 ---------------------------------------------cons1223
C consistent arrays with 2 dimensions
      subroutine CONS1223
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),A(N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1223'
      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 ---------------------------------------------cons1224
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1224
      INTEGER,PARAMETER:: N=16, ER=10000
      integer,allocatable:: B(:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N),C(N,N))
      tname='CONS1224'
      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 ---------------------------------------------cons1225
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1225
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N),C(N,N,N))
      tname='CONS1225'
      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 ---------------------------------------------cons1226
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1226
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N),V(N,N,N),W(N,N,N),C(N,N,N))
      tname='CONS1226'
      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 ---------------------------------------------cons1227
C consistent arrays with 3 dimensions
      subroutine CONS1227
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   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='CONS1227'
      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 ---------------------------------------------cons1228
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1228
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N),C(N,N,N))
      tname='CONS1228'
      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 ---------------------------------------------cons1229
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1229
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1229'
      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 ---------------------------------------------cons1230
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1230
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   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='CONS1230'
      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 ---------------------------------------------cons1231
C consistent arrays with 4 dimensions
      subroutine CONS1231
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:),A(:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   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='CONS1231'
      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 ---------------------------------------------cons1232
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1232
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1232'
      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 ---------------------------------------------cons1301
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1301
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS1301'
      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 ---------------------------------------------cons1302
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1302
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N),W(N),C(N))
      tname='CONS1302'
      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 ---------------------------------------------cons1303
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1303
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N),W(N),C(N))
      tname='CONS1303'
      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 ---------------------------------------------cons1304
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1304
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS1304'
      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 ---------------------------------------------cons1305
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1305
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS1305'
      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 ---------------------------------------------cons1306
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1306
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1306'
      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 ---------------------------------------------cons1307
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1307
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   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='CONS1307'
      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 ---------------------------------------------cons1308
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1308
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS1308'
      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 ---------------------------------------------cons1309
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1309
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1309'
      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 ---------------------------------------------cons1310
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1310
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   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='CONS1310'
      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 ---------------------------------------------cons1311
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1311
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   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='CONS1311'
      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 ---------------------------------------------cons1312
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1312
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1312'
      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 ---------------------------------------------cons1313
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1313
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1313'
      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 ---------------------------------------------cons1314
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1314
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   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='CONS1314'
      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 ---------------------------------------------cons1315
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1315
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   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='CONS1315'
      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 ---------------------------------------------cons1316
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1316
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1316'
      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 ---------------------------------------------cons1317
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1317
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS1317'
      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 ---------------------------------------------cons1318
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1318
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N),W(N),C(N))
      tname='CONS1318'
      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 ---------------------------------------------cons1319
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1319
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N),W(N),C(N))
      tname='CONS1319'
      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 ---------------------------------------------cons1320
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1320
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS1320'
      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 ---------------------------------------------cons1321
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1321
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS1321'
      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 ---------------------------------------------cons1322
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1322
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1322'
      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 ---------------------------------------------cons1323
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1323
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   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='CONS1323'
      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 ---------------------------------------------cons1324
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1324
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS1324'
      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 ---------------------------------------------cons1325
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1325
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1325'
      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 ---------------------------------------------cons1326
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1326
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   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='CONS1326'
      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 ---------------------------------------------cons1327
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1327
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   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='CONS1327'
      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 ---------------------------------------------cons1328
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1328
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1328'
      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 ---------------------------------------------cons1329
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1329
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1329'
      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 ---------------------------------------------cons1330
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1330
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   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='CONS1330'
      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 ---------------------------------------------cons1331
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1331
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   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='CONS1331'
      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 ---------------------------------------------cons1332
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1332
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1332'
      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 ---------------------------------------------cons1333
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1333
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS1333'
      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 ---------------------------------------------cons1334
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1334
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N),W(N),C(N))
      tname='CONS1334'
      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 ---------------------------------------------cons1335
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1335
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N),W(N),C(N))
      tname='CONS1335'
      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 ---------------------------------------------cons1336
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1336
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS1336'
      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 ---------------------------------------------cons1337
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1337
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS1337'
      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 ---------------------------------------------cons1338
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1338
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1338'
      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 ---------------------------------------------cons1339
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1339
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   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='CONS1339'
      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 ---------------------------------------------cons1340
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1340
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS1340'
      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 ---------------------------------------------cons1341
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1341
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1341'
      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 ---------------------------------------------cons1342
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1342
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   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='CONS1342'
      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 ---------------------------------------------cons1343
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1343
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   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='CONS1343'
      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 ---------------------------------------------cons1344
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1344
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1344'
      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 ---------------------------------------------cons1345
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1345
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1345'
      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 ---------------------------------------------cons1346
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1346
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   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='CONS1346'
      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 ---------------------------------------------cons1347
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1347
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   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='CONS1347'
      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 ---------------------------------------------cons1348
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1348
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1348'
      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 ---------------------------------------------cons1401
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1401
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1401'
      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 ---------------------------------------------cons1402
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1402
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS1402'
      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 ---------------------------------------------cons1403
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1403
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   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='CONS1403'
      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 ---------------------------------------------cons1404
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1404
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1404'
      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 ---------------------------------------------cons1405
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1405
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1405'
      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 ---------------------------------------------cons1406
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1406
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1406'
      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 ---------------------------------------------cons1407
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1407
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   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='CONS1407'
      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 ---------------------------------------------cons1408
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1408
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1408'
      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 ---------------------------------------------cons1409
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1409
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1409'
      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 ---------------------------------------------cons1410
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1410
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   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='CONS1410'
      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 ---------------------------------------------cons1411
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1411
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   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='CONS1411'
      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 ---------------------------------------------cons1412
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1412
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1412'
      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 ---------------------------------------------cons1413
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1413
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1413'
      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 ---------------------------------------------cons1414
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1414
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   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='CONS1414'
      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 ---------------------------------------------cons1415
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1415
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   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='CONS1415'
      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 ---------------------------------------------cons1416
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1416
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1416'
      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 ---------------------------------------------cons1417
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1417
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1417'
      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 ---------------------------------------------cons1418
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1418
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS1418'
      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 ---------------------------------------------cons1419
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1419
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   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='CONS1419'
      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 ---------------------------------------------cons1420
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1420
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1420'
      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 ---------------------------------------------cons1421
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1421
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1421'
      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 ---------------------------------------------cons1422
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1422
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1422'
      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 ---------------------------------------------cons1423
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1423
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   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='CONS1423'
      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 ---------------------------------------------cons1424
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1424
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1424'
      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 ---------------------------------------------cons1425
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1425
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1425'
      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 ---------------------------------------------cons1426
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1426
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   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='CONS1426'
      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 ---------------------------------------------cons1427
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1427
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   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='CONS1427'
      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 ---------------------------------------------cons1428
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1428
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1428'
      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 ---------------------------------------------cons1429
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1429
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1429'
      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 ---------------------------------------------cons1430
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1430
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   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='CONS1430'
      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 ---------------------------------------------cons1431
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1431
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   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='CONS1431'
      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 ---------------------------------------------cons1432
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1432
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1432'
      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 ---------------------------------------------cons1433
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1433
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1433'
      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 ---------------------------------------------cons1434
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1434
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS1434'
      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 ---------------------------------------------cons1435
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1435
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   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='CONS1435'
      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 ---------------------------------------------cons1436
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1436
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1436'
      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 ---------------------------------------------cons1437
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1437
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1437'
      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 ---------------------------------------------cons1438
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1438
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1438'
      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 ---------------------------------------------cons1439
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1439
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   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='CONS1439'
      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 ---------------------------------------------cons1440
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1440
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1440'
      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 ---------------------------------------------cons1441
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1441
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1441'
      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 ---------------------------------------------cons1442
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1442
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   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='CONS1442'
      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 ---------------------------------------------cons1443
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1443
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   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='CONS1443'
      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 ---------------------------------------------cons1444
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1444
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1444'
      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 ---------------------------------------------cons1445
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1445
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1445'
      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 ---------------------------------------------cons1446
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1446
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   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='CONS1446'
      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 ---------------------------------------------cons1447
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1447
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   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='CONS1447'
      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 ---------------------------------------------cons1448
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1448
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1448'
      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 ---------------------------------------------cons1449
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS1449
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1449'
      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 ---------------------------------------------cons1450
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1450
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS1450'
      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 ---------------------------------------------cons1451
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1451
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   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='CONS1451'
      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 ---------------------------------------------cons1452
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1452
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS1452'
      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 ---------------------------------------------cons1453
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS1453
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1453'
      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 ---------------------------------------------cons1454
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1454
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS1454'
      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 ---------------------------------------------cons1455
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1455
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   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='CONS1455'
      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 ---------------------------------------------cons1456
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1456
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS1456'
      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 ---------------------------------------------cons1457
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS1457
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1457'
      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 ---------------------------------------------cons1458
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1458
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   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='CONS1458'
      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 ---------------------------------------------cons1459
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1459
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   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='CONS1459'
      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 ---------------------------------------------cons1460
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1460
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS1460'
      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 ---------------------------------------------cons1461
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS1461
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1461'
      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 ---------------------------------------------cons1462
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS1462
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   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='CONS1462'
      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 ---------------------------------------------cons1463
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS1463
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   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='CONS1463'
      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 ---------------------------------------------cons1464
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS1464
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS1464'
      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
