code: def tensorized_matmul(a: T.handle, b: T.handle, c: T.handle) -> None:
      C = T.match_buffer(
          c, [128, 128], elem_offset=0, align=64, offset_factor=1
      )
      B = T.match_buffer(
          b, [128, 128], elem_offset=0, align=64, offset_factor=1
      )
      A = T.match_buffer(
          a, [128, 128], elem_offset=0, align=64, offset_factor=1
      )
  
      for i_outer, j_outer in T.grid(8, 8):
          for i_inner_init, j_inner_init in T.grid(16, 16):
              with T.block("init"):
                  vi_init = T.axis.S(
                      128, ((i_outer * 16) + i_inner_init)
                  )
                  vj_init = T.axis.S(
                      128, ((j_outer * 16) + j_inner_init)
                  )
                  C[vi_init, vj_init] = T.float32(0)
          for k_outer in T.grid(8):
              with T.block("update"):
                  vi, vj, vk = T.axis.remap(
                      "SSR", [i_outer, j_outer, k_outer]
                  )
                  T.reads(
                      [
                          C[
                              vi * 16 : vi * 16 + 16,
                              vj * 16 : vj * 16 + 16,
                          ],
                          A[
                              vi * 16 : vi * 16 + 16,
                              vk * 16 : vk * 16 + 16,
                          ],
                          B[
                              vj * 16 : vj * 16 + 16,
                              vk * 16 : vk * 16 + 16,
                          ],
                      ]
                  )
                  T.writes(
                      C[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16]
                  )
                  A_elem_offset = T.int32()
                  B_elem_offset = T.int32()
                  C_elem_offset = T.int32()
                  A_sub = T.match_buffer(
                      A[vi * 16 : vi * 16 + 16, vk * 16 : vk * 16 + 16],
                      [16, 16],
                      elem_offset=A_elem_offset,
                  )
                  B_sub = T.match_buffer(
                      B[vj * 16 : vj * 16 + 16, vk * 16 : vk * 16 + 16],
                      [16, 16],
                      elem_offset=B_elem_offset,
                  )
                  C_sub = T.match_buffer(
                      C[vi * 16 : vi * 16 + 16, vj * 16 : vj * 16 + 16],
                      [16, 16],
                      elem_offset=C_elem_offset,
                  )
                  T.evaluate(
                      T.tvm_mma_sync(
                          C_sub.data,
                          T.floordiv(C_sub.elem_offset, 256),
                          A_sub.data,
                          T.floordiv(A_sub.elem_offset, 256),
                          B_sub.data,
                          T.floordiv(B_sub.elem_offset, 256),
                          C_sub.data,
                          T.floordiv(C_sub.elem_offset, 256),
                          dtype="handle",
                      )
                  )
  
imports: import pytest
  import tvm
  import tvm.testing
  from tvm import te, tir
  from tvm.script import tir
  from tvm.tir.schedule.testing import assert_structural_equal_ignore_global_symbol, verify_trace_roundtrip
  from tvm.tir.tensor_intrin.arm_cpu import DP4A_INTRIN, ARM_DOT_4x4_i8_NEON_INTRIN, ARM_DOT_4x4_i8_SDOT_INTRIN
  from tvm.tir.tensor_intrin.rocm import AMDGPU_SDOT4_INTRIN
  from tvm.tir.tensor_intrin.x86 import VNNI_DOT_16x4_INTRIN, AVX512_DOT_16x4_INTRIN
  from tvm.tir.tensor_intrin.hexagon import VRMPY_u8u8i32_INTRIN, VDMPY_i16i16i32_INTRIN
label_desc: Use image node_id 9 for calling a global function with example usage: tensorized_matmul(a, b, c) without return types