code: def acc_32x32_int32_sapphirerapids(LDC):
      """
      Store the accumulated tile register in scope amx.tmm to global memory.
      (tmm0, tmm1, tmm2, tmm3 --> global 4 tiles)
  
      Args:
          LDC (int): the stride of the matrix C, which is int32 type and use it to
                      determine memory strides.
  
      Returns
      -------
      intrin : TensorIntrin
          The Sapphirerapids AMX-TMUL int8 tilestored64 TensorIntrin that can be used
          in tensorizing schedule
      """
      A = te.placeholder((32, 32), name="A", dtype="int32")
      bufA = tvm.tir.decl_buffer(
          A.shape,
          A.dtype,
          scope="amx.tmm",
          name="a_buffer",
          offset_factor=1,
          strides=[te.var("ldw"), 1],
      )
  
      C = te.compute((32, 32), lambda i, j: A[i, j], name="C")
      bufC = tvm.tir.decl_buffer(
          C.shape,
          C.dtype,
          scope="global",
          name="c_buffer",
          offset_factor=1,
          strides=[te.var("ldw"), 1],
      )
  
      assert LDC
      _strides_C = tvm.tir.const(4 * LDC, dtype="uint64")
  
      def intrin_func(ins, outs):  # pylint: disable=unused-variable
          ib = tvm.tir.ir_builder.create()
          bufA = ins[0]
          bufC = outs[0]
          for n_acc in range(2):  # broadcast data blocks
              for m_acc in range(2):  # loaded data blocks
                  ib.emit(
                      tvm.tir.call_llvm_intrin(
                          "int32",
                          "llvm.x86.tilestored64",
                          tvm.tir.const(3, "uint8"),
                          tvm.tir.const(
                              m_acc * 2 + n_acc, dtype="uint8"
                          ),
                          bufC.access_ptr(
                              "w",
                              offset=n_acc * 16
                              + m_acc * 16 * _strides_C / 4,
                          ),
                          _strides_C,
                      )
                  )
  
          return ib.get()
  
      return te.decl_tensor_intrin(
          C.op, intrin_func, binds={A: bufA, C: bufC}
      )
  
file_path: tvm/python/tvm/topi/x86/tensor_intrin.py
imports: import tvm
  from tvm import te
  import tvm.target.codegen
  from tvm.target.x86 import target_has_features, get_simd_32bit_lanes
label_desc: Use image node_id 6 for calling a global function with example usage: acc_32x32_int32_sapphirerapids(LDC) and returns: te, ib