anchor.diff:            TYPE(C_PTR), INTENT(IN), VALUE :: pa, pb, pc
             CALL fn%fn1(a, b, c, pa, pb, pc)
           END SUBROUTINE
  +
           !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dcall_prf
           PURE SUBROUTINE libxsmm_dcall_prf(fn, a, b, c, pa, pb, pc)
             TYPE(LIBXSMM_DMM_FUNCTION), INTENT(IN) :: fn
  
positive.code: 
          ! Non-dispatched matrix multiplication using BLAS (double-precision).
          !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dblasmm
          SUBROUTINE libxsmm_dblasmm(flags, m, n, k, a, b, c, alpha, beta)
            INTEGER(LIBXSMM_INT_KIND), PARAMETER :: T = LIBXSMM_FLD_KIND
            INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags, m, n, k
            REAL(T), INTENT(IN) :: a(:,:), b(:,:)
            REAL(T), INTENT(INOUT) :: c(:,:)
            REAL(T), INTENT(IN), OPTIONAL :: alpha, beta
            !DIR$ ATTRIBUTES OFFLOAD:MIC :: dgemm
            INTERFACE
              SUBROUTINE dgemm(transa, transb, m, n, k,                   &
  
negative.code:               REAL(LIBXSMM_FLD_KIND), INTENT(INOUT) :: c(ldc,*)
              END SUBROUTINE
            END INTERFACE
            f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
            IF (0.NE.LIBXSMM_COL_MAJOR) THEN
              CALL dgemm(                                                 &
       &        MERGE('N', 'T',                                           &
       &            0.EQ.IAND(LIBXSMM_GEMM_FLAG_TRANS_A, f)),             &
       &        MERGE('N', 'T',                                           &
       &            0.EQ.IAND(LIBXSMM_GEMM_FLAG_TRANS_B, f)),             &
       &        m, n, k,                                                  &
       &        MERGE(REAL(LIBXSMM_ALPHA, T), alpha, .NOT.PRESENT(alpha)),&
       &        a, MAX(SIZE(a, 1), m), b, MAX(SIZE(b, 1), k),             &
  