anchor.diff:          END INTERFACE$MNK_INTERFACE_LIST
   
         CONTAINS
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction_mnk
  -        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction_mnk(      &
  -     &  m, n, k, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          REAL(LIBXSMM_FLS_KIND), POINTER :: rnull => NULL()
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction0
  +        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction0(         &
  +     &  flags, m, n, k, lda, ldb, ldc, alpha, beta)
  +          INTEGER(LIBXSMM_INT_KIND), PARAMETER :: T = LIBXSMM_FLS_KIND
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags, m, n, k
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: lda
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: ldb
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: ldc
  +          REAL(T), INTENT(IN), OPTIONAL :: alpha, beta
             PROCEDURE(LIBXSMM_SFUNCTION), POINTER :: fn0
  -          TYPE(C_FUNPTR) :: fn
  -          fn = libxsmm_sdispatch0(                                      &
  -     &      MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags)),           &
  -     &      m, n, k, 0, 0, 0, rnull, rnull)
  -          CALL C_F_PROCPOINTER(fn, fn0)
  -          libxsmm_sfunction_mnk%fn0 => fn0
  +          CALL C_F_PROCPOINTER(libxsmm_sdispatch0(                      &
  +     &      flags, m, n, k, lda, ldb, ldc, alpha, beta), fn0)
  +          libxsmm_sfunction0%fn0 => fn0
  +          libxsmm_sfunction0%fn1 => NULL()
           END FUNCTION
   
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction_mnk
  -        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction_mnk(      &
  -     &  m, n, k, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          REAL(LIBXSMM_FLD_KIND), POINTER :: rnull => NULL()
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction0
  +        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction0(         &
  +     &  flags, m, n, k, lda, ldb, ldc, alpha, beta)
  +          INTEGER(LIBXSMM_INT_KIND), PARAMETER :: T = LIBXSMM_FLD_KIND
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags, m, n, k
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: lda
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: ldb
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: ldc
  +          REAL(T), INTENT(IN), OPTIONAL :: alpha, beta
             PROCEDURE(LIBXSMM_DFUNCTION), POINTER :: fn0
  -          TYPE(C_FUNPTR) :: fn
  -          fn = libxsmm_ddispatch0(                                      &
  -     &      MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags)),           &
  -     &      m, n, k, 0, 0, 0, rnull, rnull)
  -          CALL C_F_PROCPOINTER(fn, fn0)
  -          libxsmm_dfunction_mnk%fn0 => fn0
  +          CALL C_F_PROCPOINTER(libxsmm_ddispatch0(                      &
  +     &      flags, m, n, k, lda, ldb, ldc, alpha, beta), fn0)
  +          libxsmm_dfunction0%fn0 => fn0
  +          libxsmm_dfunction0%fn1 => NULL()
           END FUNCTION
   
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction_ldx
  -        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction_ldx(      &
  -     &  m, n, k, lda, ldb, ldc, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction1
  +        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction1(         &
  +     &  flags, m, n, k, lda, ldb, ldc, alpha, beta, prefetch)
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags, m, n, k
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: lda, ldb, ldc
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          REAL(LIBXSMM_FLS_KIND), POINTER :: rnull => NULL()
  -          PROCEDURE(LIBXSMM_SFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          fn = libxsmm_sdispatch0(f, m, n, k, 0, 0, 0, rnull, rnull)
  -          CALL C_F_PROCPOINTER(fn, fn0)
  -          libxsmm_sfunction_ldx%fn0 => fn0
  -        END FUNCTION
  -
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction_ldx
  -        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction_ldx(      &
  -     &  m, n, k, lda, ldb, ldc, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: lda, ldb, ldc
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          REAL(LIBXSMM_FLD_KIND), POINTER :: rnull => NULL()
  -          PROCEDURE(LIBXSMM_DFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          fn = libxsmm_ddispatch0(f, m, n, k, 0, 0, 0, rnull, rnull)
  -          CALL C_F_PROCPOINTER(fn, fn0)
  -          libxsmm_dfunction_ldx%fn0 => fn0
  -        END FUNCTION
  -
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction_prf
  -        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction_prf(      &
  -     &  m, n, k, prefetch, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  +          REAL(LIBXSMM_FLS_KIND), INTENT(IN) :: alpha, beta
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: prefetch
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags
  -          REAL(LIBXSMM_FLS_KIND), POINTER :: rnull => NULL()
             PROCEDURE(LIBXSMM_SXFUNCTION), POINTER :: fn1
             PROCEDURE(LIBXSMM_SFUNCTION), POINTER :: fn0
  -          TYPE(C_FUNPTR) :: fn
             IF (LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_sdispatch1(flags, m, n, k, 0, 0, 0,            &
  -     &        rnull, rnull, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_sfunction_prf%fn1 => fn1
  +            CALL C_F_PROCPOINTER(libxsmm_sdispatch1(                    &
  +     &        flags, m, n, k, lda, ldb, ldc, alpha, beta, prefetch),    &
  +     &        fn1)
  +            libxsmm_sfunction1%fn1 => fn1
  +            libxsmm_sfunction1%fn0 => NULL()
             ELSE
  -            fn = libxsmm_sdispatch0(flags, m, n, k, 0, 0, 0,            &
  -     &        rnull, rnull)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_sfunction_prf%fn0 => fn0
  -          ENDIF
  +            CALL C_F_PROCPOINTER(libxsmm_sdispatch0(                    &
  +     &        flags, m, n, k, lda, ldb, ldc, alpha, beta),              &
  +     &        fn0)
  +            libxsmm_sfunction1%fn0 => fn0
  +            libxsmm_sfunction1%fn1 => NULL()
  +          END IF
           END FUNCTION
   
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction_prf
  -        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction_prf(      &
  -     &  m, n, k, prefetch, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction1
  +        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction1(         &
  +     &  flags, m, n, k, lda, ldb, ldc, alpha, beta, prefetch)
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags, m, n, k
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: lda, ldb, ldc
  +          REAL(LIBXSMM_FLD_KIND), INTENT(IN) :: alpha, beta
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: prefetch
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags
  -          REAL(LIBXSMM_FLD_KIND), POINTER :: rnull => NULL()
             PROCEDURE(LIBXSMM_DXFUNCTION), POINTER :: fn1
             PROCEDURE(LIBXSMM_DFUNCTION), POINTER :: fn0
  -          TYPE(C_FUNPTR) :: fn
             IF (LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_ddispatch1(flags, m, n, k, 0, 0, 0,            &
  -     &        rnull, rnull, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_dfunction_prf%fn1 => fn1
  +            CALL C_F_PROCPOINTER(libxsmm_ddispatch1(                    &
  +     &        flags, m, n, k, lda, ldb, ldc, alpha, beta, prefetch),    &
  +     &        fn1)
  +            libxsmm_dfunction1%fn1 => fn1
  +            libxsmm_dfunction1%fn0 => NULL()
             ELSE
  -            fn = libxsmm_ddispatch0(flags, m, n, k, 0, 0, 0,            &
  -     &        rnull, rnull)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_dfunction_prf%fn0 => fn0
  -          ENDIF
  +            CALL C_F_PROCPOINTER(libxsmm_ddispatch0(                    &
  +     &        flags, m, n, k, lda, ldb, ldc, alpha, beta),              &
  +     &        fn0)
  +            libxsmm_dfunction1%fn0 => fn0
  +            libxsmm_dfunction1%fn1 => NULL()
  +          END IF
           END FUNCTION
   
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction_ldp
  -        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction_ldp(      &
  -     &  m, n, k, lda, ldb, ldc, prefetch, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sdispatch_mnk
  +        SUBROUTINE libxsmm_sdispatch_mnk(function,                      &
  +     &  m, n, k, alpha, beta, flags)
  +          TYPE(LIBXSMM_SMM_FUNCTION), INTENT(OUT) :: function
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  +          REAL(LIBXSMM_FLS_KIND), INTENT(IN), OPTIONAL :: alpha, beta
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  +          function = libxsmm_sfunction0(                                &
  +     &      MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags)), m, n, k,  &
  +     &      alpha = alpha, beta = beta)
  +        END SUBROUTINE
  +
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_ddispatch_mnk
  +        SUBROUTINE libxsmm_ddispatch_mnk(function,                      &
  +     &  m, n, k, alpha, beta, flags)
  +          TYPE(LIBXSMM_DMM_FUNCTION), INTENT(OUT) :: function
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  +          REAL(LIBXSMM_FLD_KIND), INTENT(IN), OPTIONAL :: alpha, beta
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  +          function = libxsmm_dfunction0(                                &
  +     &      MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags)), m, n, k,  &
  +     &      alpha = alpha, beta = beta)
  +        END SUBROUTINE
  +
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sdispatch_all
  +        SUBROUTINE libxsmm_sdispatch_all(function,                      &
  +     &  flags, m, n, k, lda, ldb, ldc, alpha, beta, prefetch)
  +          TYPE(LIBXSMM_SMM_FUNCTION), INTENT(OUT) :: function
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags, m, n, k
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: lda, ldb, ldc
  +          REAL(LIBXSMM_FLS_KIND), INTENT(IN), OPTIONAL :: alpha, beta
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: prefetch
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          REAL(LIBXSMM_FLS_KIND), POINTER :: rnull => NULL()
  -          PROCEDURE(LIBXSMM_SXFUNCTION), POINTER :: fn1
  -          PROCEDURE(LIBXSMM_SFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          IF (PRESENT(prefetch).AND.                                    &
  -     &    LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_sdispatch1(f, m, n, k, lda, ldb, ldc,          &
  -     &        rnull, rnull, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_sfunction_ldp%fn1 => fn1
  -          ELSE
  -            fn = libxsmm_sdispatch0(f, m, n, k, lda, ldb, ldc,          &
  -     &        rnull, rnull)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_sfunction_ldp%fn0 => fn0
  -          ENDIF
  -        END FUNCTION
  -
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction_ldp
  -        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction_ldp(      &
  -     &  m, n, k, lda, ldb, ldc, prefetch, flags)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  +        END SUBROUTINE
  +
  +        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_ddispatch_all
  +        SUBROUTINE libxsmm_ddispatch_all(function,                      &
  +     &  flags, m, n, k, lda, ldb, ldc, alpha, beta, prefetch)
  +          TYPE(LIBXSMM_DMM_FUNCTION), INTENT(OUT) :: function
  +          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: flags, m, n, k
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: lda, ldb, ldc
  +          REAL(LIBXSMM_FLD_KIND), INTENT(IN), OPTIONAL :: alpha, beta
             INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: prefetch
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          REAL(LIBXSMM_FLD_KIND), POINTER :: rnull => NULL()
  -          PROCEDURE(LIBXSMM_DXFUNCTION), POINTER :: fn1
  -          PROCEDURE(LIBXSMM_DFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          IF (PRESENT(prefetch).AND.                                    &
  -     &    LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_ddispatch1(f, m, n, k, lda, ldb, ldc,          &
  -     &        rnull, rnull, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_dfunction_ldp%fn1 => fn1
  -          ELSE
  -            fn = libxsmm_ddispatch0(f, m, n, k, lda, ldb, ldc,          &
  -     &        rnull, rnull)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_dfunction_ldp%fn0 => fn0
  -          ENDIF
  -        END FUNCTION
  -
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction_abf
  -        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction_abf(      &
  -     &  m, n, k, alpha, beta, flags, prefetch)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  -          REAL(LIBXSMM_FLS_KIND), INTENT(IN) :: alpha, beta
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: prefetch
  -          PROCEDURE(LIBXSMM_SXFUNCTION), POINTER :: fn1
  -          PROCEDURE(LIBXSMM_SFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          IF (PRESENT(prefetch).AND.                                    &
  -     &    LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_sdispatch1(                                    &
  -     &        f, m, n, k, 0, 0, 0, alpha, beta, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_sfunction_abf%fn1 => fn1
  -          ELSE
  -            fn = libxsmm_sdispatch0(f, m, n, k, 0, 0, 0, alpha, beta)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_sfunction_abf%fn0 => fn0
  -          ENDIF
  -        END FUNCTION
  -
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction_abf
  -        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction_abf(      &
  -     &  m, n, k, alpha, beta, flags, prefetch)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  -          REAL(LIBXSMM_FLD_KIND), INTENT(IN) :: alpha, beta
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: prefetch
  -          PROCEDURE(LIBXSMM_DXFUNCTION), POINTER :: fn1
  -          PROCEDURE(LIBXSMM_DFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          IF (PRESENT(prefetch).AND.                                    &
  -     &    LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_ddispatch1(                                    &
  -     &        f, m, n, k, 0, 0, 0, alpha, beta, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_dfunction_abf%fn1 => fn1
  -          ELSE
  -            fn = libxsmm_ddispatch0(f, m, n, k, 0, 0, 0, alpha, beta)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_dfunction_abf%fn0 => fn0
  -          ENDIF
  -        END FUNCTION
  -
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_sfunction_all
  -        TYPE(LIBXSMM_SMM_FUNCTION) FUNCTION libxsmm_sfunction_all(      &
  -     &  m, n, k, lda, ldb, ldc, alpha, beta, flags, prefetch)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: lda, ldb, ldc
  -          REAL(LIBXSMM_FLS_KIND), INTENT(IN) :: alpha, beta
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: prefetch
  -          PROCEDURE(LIBXSMM_SXFUNCTION), POINTER :: fn1
  -          PROCEDURE(LIBXSMM_SFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          IF (PRESENT(prefetch).AND.                                    &
  -     &    LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_sdispatch1(                                    &
  -     &        f, m, n, k, lda, ldb, ldc, alpha, beta, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_sfunction_all%fn1 => fn1
  -          ELSE
  -            fn = libxsmm_sdispatch0(                                    &
  -     &        f, m, n, k, lda, ldb, ldc, alpha, beta)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_sfunction_all%fn0 => fn0
  -          ENDIF
  -        END FUNCTION
  -
  -        !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_dfunction_all
  -        TYPE(LIBXSMM_DMM_FUNCTION) FUNCTION libxsmm_dfunction_all(      &
  -     &  m, n, k, lda, ldb, ldc, alpha, beta, flags, prefetch)
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: m, n, k
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN) :: lda, ldb, ldc
  -          REAL(LIBXSMM_FLD_KIND), INTENT(IN) :: alpha, beta
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: flags
  -          INTEGER(LIBXSMM_INT_KIND), INTENT(IN), OPTIONAL :: prefetch
  -          PROCEDURE(LIBXSMM_DXFUNCTION), POINTER :: fn1
  -          PROCEDURE(LIBXSMM_DFUNCTION), POINTER :: fn0
  -          INTEGER(LIBXSMM_INT_KIND) :: f
  -          TYPE(C_FUNPTR) :: fn
  -          f = MERGE(LIBXSMM_FLAGS, flags, .NOT.PRESENT(flags))
  -          IF (PRESENT(prefetch).AND.                                    &
  -     &    LIBXSMM_PREFETCH_NONE.NE.prefetch) THEN
  -            fn = libxsmm_ddispatch1(                                    &
  -     &        f, m, n, k, lda, ldb, ldc, alpha, beta, prefetch)
  -            CALL C_F_PROCPOINTER(fn, fn1)
  -            libxsmm_dfunction_all%fn1 => fn1
  -          ELSE
  -            fn = libxsmm_ddispatch0(                                    &
  -     &        f, m, n, k, lda, ldb, ldc, alpha, beta)
  -            CALL C_F_PROCPOINTER(fn, fn0)
  -            libxsmm_dfunction_all%fn0 => fn0
  -          ENDIF
  -        END FUNCTION
  +        END SUBROUTINE
   
           !DIR$ ATTRIBUTES OFFLOAD:MIC :: libxsmm_savailable
           LOGICAL PURE FUNCTION libxsmm_savailable(fn)
  
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:         END SUBROUTINE
  
          ! Non-dispatched matrix multiplication using BLAS (single-precision).
          !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
  