anchor.diff:  
   CONTAINS
     ! Non-dispatched matrix-matrix multiplication using BLAS; single-precision.
  -  !DIR$ ATTRIBUTES OFFLOAD:MIC :: LIBXSMM_SBLASMM
  -  !DIR$ ATTRIBUTES INLINE :: LIBXSMM_SBLASMM
  -  PURE SUBROUTINE LIBXSMM_SBLASMM(m, n, k, a, b, c)
  +  !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sblasmm
  +  !DIR$ ATTRIBUTES INLINE :: libxsmm_sblasmm
  +  PURE SUBROUTINE libxsmm_sblasmm(m, n, k, a, b, c)
       INTEGER, INTENT(IN) :: m, n, k
       REAL(LIBXSMM_SINGLE_PRECISION), INTENT(IN) :: a($SHAPE_A), b($SHAPE_B)
       REAL(LIBXSMM_SINGLE_PRECISION), INTENT(INOUT) :: c($SHAPE_C)
  
positive.code:   END SUBROUTINE
  
    ! Query the pointer of a generated function; zero if it does not exist.
    !DIR$ ATTRIBUTES OFFLOAD:MIC :: LIBXSMM_SMM_DISPATCH
    !DIR$ ATTRIBUTES INLINE :: LIBXSMM_SMM_DISPATCH
    FUNCTION LIBXSMM_SMM_DISPATCH(m, n, k) RESULT(f)
      PROCEDURE(LIBXSMM_SMM_FUNCTION), POINTER :: f
      INTEGER, INTENT(IN) :: m, n, k
      INTERFACE
        !DIR$ ATTRIBUTES OFFLOAD:MIC :: LIBXSMM_SMM_DISPATCH_AUX
        TYPE(C_FUNPTR) PURE FUNCTION LIBXSMM_SMM_DISPATCH_AUX(m, n, k) BIND(C, NAME="libxsmm_smm_dispatch")
          USE, INTRINSIC :: ISO_C_BINDING
          INTEGER(C_INT), INTENT(IN) :: m, n, k
        END FUNCTION
      END INTERFACE
      CALL C_F_PROCPOINTER(LIBXSMM_SMM_DISPATCH_AUX(m, n, k), f)
    END FUNCTION
  
    ! Query the pointer of a generated function; zero if it does not exist.
    !DIR$ ATTRIBUTES OFFLOAD:MIC :: LIBXSMM_DMM_DISPATCH
    !DIR$ ATTRIBUTES INLINE :: LIBXSMM_DMM_DISPATCH
    FUNCTION LIBXSMM_DMM_DISPATCH(m, n, k) RESULT(f)
      PROCEDURE(LIBXSMM_DMM_FUNCTION), POINTER :: f
      INTEGER, INTENT(IN) :: m, n, k
      INTERFACE
        !DIR$ ATTRIBUTES OFFLOAD:MIC :: LIBXSMM_DMM_DISPATCH_AUX
        TYPE(C_FUNPTR) PURE FUNCTION LIBXSMM_DMM_DISPATCH_AUX(m, n, k) BIND(C, NAME="libxsmm_dmm_dispatch")
          USE, INTRINSIC :: ISO_C_BINDING
          INTEGER(C_INT), INTENT(IN) :: m, n, k
        END FUNCTION
      END INTERFACE
      CALL C_F_PROCPOINTER(LIBXSMM_DMM_DISPATCH_AUX(m, n, k), f)
    END FUNCTION
  
    ! Dispatched matrix-matrix multiplication; single-precision.
    !DIR$ ATTRIBUTES OFFLOAD:MIC :: LIBXSMM_SMM
    !DIR$ ATTRIBUTES INLINE :: LIBXSMM_SMM
    SUBROUTINE LIBXSMM_SMM(m, n, k, a, b, c)
      INTEGER, INTENT(IN) :: m, n, k
      REAL(LIBXSMM_SINGLE_PRECISION), INTENT(IN) :: a($SHAPE_A), b($SHAPE_B)
      REAL(LIBXSMM_SINGLE_PRECISION), INTENT(INOUT) :: c($SHAPE_C)
      PROCEDURE(LIBXSMM_SMM_FUNCTION), POINTER :: f
      IF (LIBXSMM_MAX_MNK.GE.(m * n * k)) THEN
        f => LIBXSMM_SMM_DISPATCH(m, n, k)
        IF (ASSOCIATED(f)) THEN
          CALL f(a, b, c)
        ELSE
          CALL LIBXSMM_SIMM(m, n, k, a, b, c)
        ENDIF
      ELSE
        CALL LIBXSMM_SBLASMM(m, n, k, a, b, c)
      ENDIF
    END SUBROUTINE
  
    ! Dispatched matrix-matrix multiplication; double-precision.
    !DIR$ ATTRIBUTES OFFLOAD:MIC :: LIBXSMM_DMM
    !DIR$ ATTRIBUTES INLINE :: LIBXSMM_DMM
    SUBROUTINE LIBXSMM_DMM(m, n, k, a, b, c)
      INTEGER, INTENT(IN) :: m, n, k
      REAL(LIBXSMM_DOUBLE_PRECISION), INTENT(IN) :: a($SHAPE_A), b($SHAPE_B)
      REAL(LIBXSMM_DOUBLE_PRECISION), INTENT(INOUT) :: c($SHAPE_C)
      PROCEDURE(LIBXSMM_DMM_FUNCTION), POINTER :: f
      IF (LIBXSMM_MAX_MNK.GE.(m * n * k)) THEN
        f => LIBXSMM_DMM_DISPATCH(m, n, k)
        IF (ASSOCIATED(f)) THEN
          CALL f(a, b, c)
        ELSE
          CALL LIBXSMM_DIMM(m, n, k, a, b, c)
        ENDIF
      ELSE
        CALL LIBXSMM_DBLASMM(m, n, k, a, b, c)
      ENDIF
    END SUBROUTINE
  END MODULE
  
negative.code:   END SUBROUTINE
  
    ! Non-dispatched matrix-matrix multiplication using inline code; single-precision.
    !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_simm
    !DIR$ ATTRIBUTES INLINE :: libxsmm_simm
    PURE SUBROUTINE libxsmm_simm(m, n, k, a, b, c)
      INTEGER, INTENT(IN) :: m, n, k
      REAL(LIBXSMM_SINGLE_PRECISION), INTENT(IN) :: a($SHAPE_A), b($SHAPE_B)
      REAL(LIBXSMM_SINGLE_PRECISION), INTENT(INOUT) :: c($SHAPE_C)
  