anchor.diff:          END SUBROUTINE
   
           ! Non-dispatched matrix multiplication using BLAS (single-precision).
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dblasmm_ab
  -        SUBROUTINE libxsmm_dblasmm_ab(                                  &
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dblasmm_abf
  +        SUBROUTINE libxsmm_dblasmm_abf(                                 &
        &  m, n, k, a, b, c, dalpha, dbeta, flags)
             INTEGER(LIBXSMM_INT_KIND), PARAMETER :: T = LIBXSMM_FLD_KIND
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  
positive.code:           REAL(LIBXSMM_FLS_KIND), INTENT(IN) :: a(:,:), b(:,:)
            REAL(LIBXSMM_FLS_KIND), INTENT(INOUT) :: c(:,:)
            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
  
negative.code:           TYPE(C_PTR), INTENT(IN), VALUE, OPTIONAL :: pa, pb, pc
            INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
            REAL(T), INTENT(IN), OPTIONAL :: alpha, beta
            TYPE(LIBXSMM_SMM_FUNCTION) :: function
            INTEGER(LIBXSMM_INT_KIND) :: f
            f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
            IF (LIBXSMM_MAX_MNK.GE.(m * n * k)) THEN
              IF (PRESENT(pa).OR.PRESENT(pb).OR.PRESENT(pc)) THEN
                function = libxsmm_sfunction1(                            &
       &          f, m, n, k, 0, 0, 0, alpha, beta,                       &
       &          MERGE(LIBXSMM_PREFETCH, LIBXSMM_PREFETCH_SIGNATURE,     &
       &              LIBXSMM_PREFETCH_NONE.NE.LIBXSMM_PREFETCH))
                IF (ASSOCIATED(function%fn1)) THEN
                  CALL libxsmm_scall_prf(function, a, b, c, pa, pb, pc)
                ELSE
                  CALL libxsmm_sblasmm(m, n, k, a, b, c, f, alpha, beta)
                END IF
              ELSE
                function = libxsmm_sfunction0(                            &
       &          f, m, n, k, 0, 0, 0, alpha, beta)
                IF (ASSOCIATED(function%fn0)) THEN
                  CALL libxsmm_scall_abc(function, a, b, c)
                ELSE
                  CALL libxsmm_sblasmm(m, n, k, a, b, c, f, alpha, beta)
                END IF
              END IF
            ELSE
              CALL libxsmm_sblasmm(m, n, k, a, b, c, f, alpha, beta)
            END IF
          END SUBROUTINE
  
          ! Dispatched matrix multiplication (double-precision).
  