      program CONS234

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

      print *,'===START OF CONS234========================'
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2301
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2302
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2303
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2304
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2305
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2306
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2307
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2308
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2309
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2310
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2311
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2312
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2313
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2314
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2315
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2316
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2317
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2318
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2319
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2320
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2321
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2322
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2323
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2324
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2325
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2326
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2327
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2328
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2329
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2330
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2331
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2332
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2333
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2334
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2335
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2336
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2337
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2338
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2339
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2340
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2341
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2342
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2343
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2344
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2345
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2346
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2347
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2348
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2401
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2402
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2403
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2404
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2405
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2406
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2407
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2408
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2409
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2410
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2411
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2412
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2413
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2414
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2415
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2416
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2417
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2418
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2419
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2420
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2421
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2422
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2423
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2424
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2425
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2426
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2427
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2428
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2429
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2430
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2431
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2432
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2433
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2434
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2435
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2436
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2437
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2438
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2439
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2440
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2441
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2442
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2443
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2444
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2445
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2446
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2447
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2448
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2449
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2450
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2451
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2452
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2453
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2454
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2455
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2456
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2457
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2458
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2459
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2460
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2461
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2462
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2463
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2464
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2465
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2466
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2467
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2468
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2469
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2470
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2471
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2472
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2473
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2474
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2475
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2476
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2477
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2478
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2479
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2480
C --------------------------------------------------

C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      call cons2481
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      call cons2482
C --------------------------------------------------
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      call cons2483
C --------------------------------------------------
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      call cons2484
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      call cons2485
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      call cons2486
C --------------------------------------------------
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      call cons2487
C --------------------------------------------------
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      call cons2488
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      call cons2489
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      call cons2490
C --------------------------------------------------
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      call cons2491
C --------------------------------------------------
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      call cons2492
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      call cons2493
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      call cons2494
C --------------------------------------------------
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      call cons2495
C --------------------------------------------------
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      call cons2496
C --------------------------------------------------
C
      print *,'=== END OF CONS234 ========================= '
      end
C ---------------------------------------------cons2301
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2301
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS2301'
      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 ---------------------------------------------cons2302
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2302
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N),W(N),C(N))
      tname='CONS2302'
      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 ---------------------------------------------cons2303
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2303
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N),W(N),C(N))
      tname='CONS2303'
      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 ---------------------------------------------cons2304
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2304
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS2304'
      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 ---------------------------------------------cons2305
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2305
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS2305'
      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 ---------------------------------------------cons2306
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2306
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2306'
      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 ---------------------------------------------cons2307
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2307
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2307'
      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 ---------------------------------------------cons2308
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2308
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS2308'
      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 ---------------------------------------------cons2309
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2309
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2309'
      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 ---------------------------------------------cons2310
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2310
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2310'
      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 ---------------------------------------------cons2311
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2311
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2311'
      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 ---------------------------------------------cons2312
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2312
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2312'
      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 ---------------------------------------------cons2313
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2313
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2313'
      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 ---------------------------------------------cons2314
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2314
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2314'
      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 ---------------------------------------------cons2315
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2315
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2315'
      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 ---------------------------------------------cons2316
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2316
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2316'
      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 ---------------------------------------------cons2317
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2317
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS2317'
      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 ---------------------------------------------cons2318
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2318
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N),W(N),C(N))
      tname='CONS2318'
      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 ---------------------------------------------cons2319
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2319
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N),W(N),C(N))
      tname='CONS2319'
      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 ---------------------------------------------cons2320
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2320
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS2320'
      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 ---------------------------------------------cons2321
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2321
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS2321'
      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 ---------------------------------------------cons2322
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2322
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2322'
      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 ---------------------------------------------cons2323
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2323
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2323'
      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 ---------------------------------------------cons2324
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2324
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS2324'
      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 ---------------------------------------------cons2325
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2325
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2325'
      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 ---------------------------------------------cons2326
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2326
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2326'
      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 ---------------------------------------------cons2327
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2327
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2327'
      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 ---------------------------------------------cons2328
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2328
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2328'
      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 ---------------------------------------------cons2329
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2329
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2329'
      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 ---------------------------------------------cons2330
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2330
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2330'
      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 ---------------------------------------------cons2331
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2331
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2331'
      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 ---------------------------------------------cons2332
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2332
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2332'
      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 ---------------------------------------------cons2333
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2333
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS2333'
      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 ---------------------------------------------cons2334
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2334
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N),W(N),C(N))
      tname='CONS2334'
      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 ---------------------------------------------cons2335
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2335
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   A
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),A(N,N,N),V(N),W(N),C(N))
      tname='CONS2335'
      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 ---------------------------------------------cons2336
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2336
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N),C(N))
      tname='CONS2336'
      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 ---------------------------------------------cons2337
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2337
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS2337'
      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 ---------------------------------------------cons2338
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2338
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2338'
      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 ---------------------------------------------cons2339
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2339
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2339'
      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 ---------------------------------------------cons2340
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2340
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N),C(N,N))
      tname='CONS2340'
      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 ---------------------------------------------cons2341
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2341
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2341'
      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 ---------------------------------------------cons2342
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2342
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2342'
      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 ---------------------------------------------cons2343
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2343
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2343'
      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 ---------------------------------------------cons2344
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2344
      INTEGER,PARAMETER:: N=16, ER=100000
      integer,allocatable:: B(:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2344'
      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 ---------------------------------------------cons2345
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2345
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2345'
      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 ---------------------------------------------cons2346
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2346
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2346'
      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 ---------------------------------------------cons2347
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2347
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:),A(:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2347'
      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 ---------------------------------------------cons2348
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2348
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2348'
      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 ---------------------------------------------cons2401
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2401
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2401'
      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 ---------------------------------------------cons2402
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2402
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS2402'
      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 ---------------------------------------------cons2403
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2403
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, 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='CONS2403'
      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 ---------------------------------------------cons2404
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2404
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2404'
      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 ---------------------------------------------cons2405
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2405
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2405'
      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 ---------------------------------------------cons2406
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2406
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2406'
      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 ---------------------------------------------cons2407
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2407
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, 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='CONS2407'
      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 ---------------------------------------------cons2408
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2408
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2408'
      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 ---------------------------------------------cons2409
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2409
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2409'
      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 ---------------------------------------------cons2410
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2410
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, 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='CONS2410'
      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 ---------------------------------------------cons2411
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2411
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, 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='CONS2411'
      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 ---------------------------------------------cons2412
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2412
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2412'
      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 ---------------------------------------------cons2413
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2413
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2413'
      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 ---------------------------------------------cons2414
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2414
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, 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='CONS2414'
      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 ---------------------------------------------cons2415
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2415
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, *, BLOCK, 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='CONS2415'
      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 ---------------------------------------------cons2416
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2416
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, *, BLOCK, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2416'
      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 ---------------------------------------------cons2417
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2417
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2417'
      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 ---------------------------------------------cons2418
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2418
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS2418'
      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 ---------------------------------------------cons2419
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2419
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, 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='CONS2419'
      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 ---------------------------------------------cons2420
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2420
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2420'
      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 ---------------------------------------------cons2421
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2421
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2421'
      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 ---------------------------------------------cons2422
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2422
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2422'
      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 ---------------------------------------------cons2423
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2423
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, 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='CONS2423'
      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 ---------------------------------------------cons2424
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2424
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2424'
      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 ---------------------------------------------cons2425
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2425
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2425'
      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 ---------------------------------------------cons2426
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2426
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, 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='CONS2426'
      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 ---------------------------------------------cons2427
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2427
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, 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='CONS2427'
      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 ---------------------------------------------cons2428
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2428
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2428'
      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 ---------------------------------------------cons2429
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2429
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2429'
      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 ---------------------------------------------cons2430
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2430
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, 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='CONS2430'
      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 ---------------------------------------------cons2431
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2431
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, *, 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='CONS2431'
      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 ---------------------------------------------cons2432
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2432
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2432'
      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 ---------------------------------------------cons2433
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2433
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2433'
      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 ---------------------------------------------cons2434
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2434
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS2434'
      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 ---------------------------------------------cons2435
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2435
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2435'
      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 ---------------------------------------------cons2436
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2436
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2436'
      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 ---------------------------------------------cons2437
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2437
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2437'
      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 ---------------------------------------------cons2438
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2438
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2438'
      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 ---------------------------------------------cons2439
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2439
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2439'
      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 ---------------------------------------------cons2440
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2440
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2440'
      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 ---------------------------------------------cons2441
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2441
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2441'
      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 ---------------------------------------------cons2442
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2442
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2442'
      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 ---------------------------------------------cons2443
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2443
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2443'
      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 ---------------------------------------------cons2444
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2444
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2444'
      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 ---------------------------------------------cons2445
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2445
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2445'
      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 ---------------------------------------------cons2446
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2446
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2446'
      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 ---------------------------------------------cons2447
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2447
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( *, BLOCK, 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='CONS2447'
      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 ---------------------------------------------cons2448
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2448
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( *, BLOCK, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2448'
      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 ---------------------------------------------cons2449
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2449
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2449'
      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 ---------------------------------------------cons2450
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2450
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS2450'
      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 ---------------------------------------------cons2451
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2451
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, 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='CONS2451'
      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 ---------------------------------------------cons2452
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2452
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2452'
      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 ---------------------------------------------cons2453
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2453
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2453'
      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 ---------------------------------------------cons2454
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2454
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2454'
      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 ---------------------------------------------cons2455
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2455
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, 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='CONS2455'
      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 ---------------------------------------------cons2456
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2456
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2456'
      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 ---------------------------------------------cons2457
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2457
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2457'
      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 ---------------------------------------------cons2458
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2458
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, 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='CONS2458'
      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 ---------------------------------------------cons2459
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2459
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, 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='CONS2459'
      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 ---------------------------------------------cons2460
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2460
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2460'
      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 ---------------------------------------------cons2461
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2461
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2461'
      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 ---------------------------------------------cons2462
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2462
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, 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='CONS2462'
      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 ---------------------------------------------cons2463
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2463
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, *, 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='CONS2463'
      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 ---------------------------------------------cons2464
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2464
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, *, BLOCK )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2464'
      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 ---------------------------------------------cons2465
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2465
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2465'
      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 ---------------------------------------------cons2466
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2466
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS2466'
      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 ---------------------------------------------cons2467
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2467
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2467'
      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 ---------------------------------------------cons2468
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2468
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2468'
      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 ---------------------------------------------cons2469
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2469
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2469'
      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 ---------------------------------------------cons2470
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2470
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2470'
      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 ---------------------------------------------cons2471
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2471
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2471'
      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 ---------------------------------------------cons2472
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2472
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2472'
      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 ---------------------------------------------cons2473
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2473
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2473'
      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 ---------------------------------------------cons2474
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2474
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2474'
      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 ---------------------------------------------cons2475
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2475
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2475'
      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 ---------------------------------------------cons2476
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2476
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2476'
      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 ---------------------------------------------cons2477
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2477
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2477'
      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 ---------------------------------------------cons2478
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2478
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2478'
      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 ---------------------------------------------cons2479
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2479
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, *, 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='CONS2479'
      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 ---------------------------------------------cons2480
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2480
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, *, BLOCK, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2480'
      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 ---------------------------------------------cons2481
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
      subroutine CONS2481
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2481'
      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 ---------------------------------------------cons2482
C consistent arrays with 1 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2482
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:),W(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N),W(N),C(N))
      tname='CONS2482'
      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 ---------------------------------------------cons2483
C consistent arrays with 1 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2483
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:),W(:)
     *,C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2483'
      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 ---------------------------------------------cons2484
C consistent arrays with 1 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2484
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:),C(:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N),C(N))
      tname='CONS2484'
      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 ---------------------------------------------cons2485
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
      subroutine CONS2485
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2485'
      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 ---------------------------------------------cons2486
C consistent arrays with 2 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2486
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:),W(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
!DVM$   CONSISTENT W
      allocate (B(N,N,N,N),V(N,N),W(N,N),C(N,N))
      tname='CONS2486'
      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 ---------------------------------------------cons2487
C consistent arrays with 2 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2487
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:),W(:,:)
     *,C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2487'
      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 ---------------------------------------------cons2488
C consistent arrays with 2 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2488
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:),C(:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N),C(N,N))
      tname='CONS2488'
      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 ---------------------------------------------cons2489
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
      subroutine CONS2489
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2489'
      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 ---------------------------------------------cons2490
C consistent arrays with 3 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2490
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),W(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2490'
      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 ---------------------------------------------cons2491
C consistent arrays with 3 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2491
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:),W(:,:,:)
     *,C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2491'
      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 ---------------------------------------------cons2492
C consistent arrays with 3 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2492
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:),C(:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N),C(N,N,N))
      tname='CONS2492'
      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 ---------------------------------------------cons2493
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
      subroutine CONS2493
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2493'
      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 ---------------------------------------------cons2494
C consistent arrays with 4 dimensions
C two consistent arrays and one distributed array
      subroutine CONS2494
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),W(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2494'
      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 ---------------------------------------------cons2495
C consistent arrays with 4 dimensions
C two consistent arrays and two distributed arrays
      subroutine CONS2495
      INTEGER,PARAMETER:: N=8, ER=10000
      integer,allocatable::B(:,:,:,:),A(:,:,:,:),V(:,:,:,:),W(:,:,:,:)
     *,C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   DISTRIBUTE     ( BLOCK, 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='CONS2495'
      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 ---------------------------------------------cons2496
C consistent arrays with 4 dimensions
C one consistent array and one distributed array
C big data
      subroutine CONS2496
      INTEGER,PARAMETER:: N=16, ER=1000000
      integer,allocatable:: B(:,:,:,:),V(:,:,:,:),C(:,:,:,:)
      character*8 tname
      INTEGER ERROR,IERR
!DVM$   DISTRIBUTE     ( BLOCK, BLOCK, *, * )   ::   B
!DVM$   CONSISTENT V
      allocate (B(N,N,N,N),V(N,N,N,N),C(N,N,N,N))
      tname='CONS2496'
      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
