anchor.diff:            jE= indexU(i  )
             do j= jS, jE
               in  = itemU(j)
  -            if (in > N) cycle
  +            !COMM_HIDING! if (in > N) cycle
               X1= X(3*in-2)
               X2= X(3*in-1)
               X3= X(3*in  )
  
positive.code:     integer(kind=kint) :: N, NP
      integer(kind=kint), pointer :: indexL(:), itemL(:), indexU(:), itemU(:)
      real(kind=kreal), pointer :: AL(:), AU(:), D(:)
      integer(kind=kint) :: ireq
  
      ! added for turning >>>
      integer, parameter :: numOfBlockPerThread = 100
  
negative.code:       END_TIME = hecmw_Wtime()
        time_Ax = time_Ax + END_TIME - START_TIME
  
        !COMM_HIDING! START_TIME= HECMW_WTIME()
        !COMM_HIDING! call hecmw_update_3_R_wait (hecMESH, ireq)
        !COMM_HIDING! END_TIME= HECMW_WTIME()
        !COMM_HIDING! if (present(COMMtime)) COMMtime = COMMtime + END_TIME - START_TIME
  
        !COMM_HIDING! START_TIME = hecmw_Wtime()
  
        !COMM_HIDING! do i = 1, N
        !COMM_HIDING!   YV1= 0.d0
        !COMM_HIDING!   YV2= 0.d0
        !COMM_HIDING!   YV3= 0.d0
        !COMM_HIDING!   jS= indexU(i-1) + 1
        !COMM_HIDING!   jE= indexU(i  )
        !COMM_HIDING!   do j= jS, jE
        !COMM_HIDING!     in  = itemU(j)
        !COMM_HIDING!     if (in <= N) cycle
        !COMM_HIDING!     X1= X(3*in-2)
        !COMM_HIDING!     X2= X(3*in-1)
        !COMM_HIDING!     X3= X(3*in  )
        !COMM_HIDING!     YV1= YV1 + AU(9*j-8)*X1 + AU(9*j-7)*X2 + AU(9*j-6)*X3
        !COMM_HIDING!     YV2= YV2 + AU(9*j-5)*X1 + AU(9*j-4)*X2 + AU(9*j-3)*X3
        !COMM_HIDING!     YV3= YV3 + AU(9*j-2)*X1 + AU(9*j-1)*X2 + AU(9*j  )*X3
        !COMM_HIDING!   enddo
        !COMM_HIDING!   Y(3*i-2)= Y(3*i-2)+YV1
        !COMM_HIDING!   Y(3*i-1)= Y(3*i-1)+YV2
        !COMM_HIDING!   Y(3*i  )= Y(3*i  )+YV3
        !COMM_HIDING! enddo
  
        !COMM_HIDING! END_TIME = hecmw_Wtime()
        !COMM_HIDING! time_Ax = time_Ax + END_TIME - START_TIME
  
      ENDIF
  
  