code: def recursive_match(a: T.handle, b: T.handle) -> None:
      A = T.match_buffer(a, (64, 64, 64))
      B = T.match_buffer(b, (64, 64, 64))
      for i, j, k in T.grid(64, 4, 4):
          with T.block():
              T.reads([])
              T.writes(
                  [
                      A[i, j * 16 : j * 16 + 16, k * 16 : k * 16 + 16],
                      B[i, j * 16 : j * 16 + 16, k * 16 : k * 16 + 16],
                  ]
              )
              As_0 = T.int32()
              As_1 = T.int32()
              sub_A = T.match_buffer(
                  A[i, j * 16 : j * 16 + 16, k * 16 : k * 16 + 16],
                  (16, 16),
                  strides=[As_0, As_1],
                  offset_factor=1,
              )
              sub_B = T.match_buffer(
                  B[i, j * 16 : j * 16 + 16, k * 16 : k * 16 + 16],
                  (16, 16),
                  offset_factor=1,
              )
              for jj, kk in T.grid(4, 4):
                  with T.block():
                      T.reads([])
                      T.writes(
                          [
                              sub_A[
                                  jj * 4 : jj * 4 + 4,
                                  kk * 4 : kk * 4 + 4,
                              ],
                              sub_B[
                                  jj * 4 : jj * 4 + 4,
                                  kk * 4 : kk * 4 + 4,
                              ],
                          ]
                      )
                      Ass_0 = T.int32()
                      Ass_1 = T.int32()
                      sub_sub_A = T.match_buffer(
                          sub_A[
                              jj * 4 : jj * 4 + 4, kk * 4 : kk * 4 + 4
                          ],
                          (4, 4),
                          strides=[Ass_0, Ass_1],
                          offset_factor=1,
                      )
                      sub_sub_B = T.match_buffer(
                          sub_B[
                              jj * 4 : jj * 4 + 4, kk * 4 : kk * 4 + 4
                          ],
                          (4, 4),
                          offset_factor=1,
                      )
                      T.evaluate(
                          intrin_test(
                              sub_sub_A.data,
                              sub_sub_A.elem_offset,
                              sub_sub_A.strides[0],
                              sub_sub_A.strides[1],
                              sub_sub_A.shape[0],
                              sub_sub_A.shape[1],
                          )
                      )
                      for jjj, kkk in T.grid(4, 4):
                          sub_sub_B[jjj, kkk] = 1
  
imports: import pytest
  import tvm
  import tvm.testing
  from tvm.script import tir
label_desc: Use image node_id 12 for calling a global function with example usage: recursive_match(a, b) without return types