code: def transformed_nested_pipeline_prefetch_inner(
      A: T.Buffer((16, 16, 16), "float32"),
      C: T.Buffer((16, 16, 16), "float32"),
  ) -> None:
      for tx in T.thread_binding(0, 16, thread="threadIdx.x"):
          with T.block():
              T.reads([A[tx, 0:16, 0:16]])
              T.writes([C[tx, 0:16, 0:16]])
              A_shared = T.alloc_buffer(
                  [2, 16, 1, 16], dtype="float32", scope="shared"
              )
              B = T.alloc_buffer(
                  [2, 16, 1, 1], dtype="float32", scope="shared"
              )
              with T.block():
                  T.reads([A[tx, 0, 0:16], A_shared[0, tx, 0, 0]])
                  T.writes([A_shared[0, tx, 0, 0:16], B[0, tx, 0, 0]])
                  with T.block():
                      T.reads([A[tx, 0, 0:16]])
                      T.writes([A_shared[0, tx, 0, 0:16]])
                      for j in T.serial(0, 16):
                          with T.block():
                              T.reads([A[tx, 0, j]])
                              T.writes([A_shared[0, tx, 0, j]])
                              A_shared[0, tx, 0, j] = A[tx, 0, j]
                  with T.block():
                      T.reads([A_shared[0, tx, 0, 0]])
                      T.writes([B[0, tx, 0, 0]])
                      B[0, tx, 0, 0] = A_shared[
                          0, tx, 0, 0
                      ] * T.float32(2)
              with T.block():
                  T.reads(
                      [
                          A[tx, 1:16, 0:16],
                          A_shared[0:2, tx, 0:16, 0:16],
                          B[0:2, tx, 0:15, 0],
                      ]
                  )
                  T.writes(
                      [
                          A_shared[0:2, tx, 0, 0:16],
                          B[0:2, tx, 0:16, 0],
                          C[tx, 0:15, 0:16],
                      ]
                  )
                  for i in T.serial(0, 15):
                      with T.block():
                          T.reads([A[tx, i + 1, 0:16]])
                          T.writes([A_shared[(i + 1) % 2, tx, 0, 0:16]])
                          for j in T.serial(0, 16):
                              with T.block():
                                  T.reads([A[tx, i + 1, j]])
                                  T.writes(
                                      [A_shared[(i + 1) % 2, tx, 0, j]]
                                  )
                                  A_shared[(i + 1) % 2, tx, 0, j] = A[
                                      tx, i + 1, j
                                  ]
                      with T.block():
                          T.reads(
                              [
                                  A_shared[i % 2, tx, i, 1:16],
                                  B[0:2, tx, i, 0],
                              ]
                          )
                          T.writes([B[0:2, tx, i, 0], C[tx, i, 0:15]])
                          for j in T.serial(0, 15):
                              with T.block():
                                  T.reads(
                                      [A_shared[i % 2, tx, i, j + 1]]
                                  )
                                  T.writes([B[(j + 1) % 2, tx, i, 0]])
                                  B[(j + 1) % 2, tx, i, 0] = A_shared[
                                      i % 2, tx, 0, j + 1
                                  ] * T.float32(2)
                              with T.block():
                                  T.reads([B[j % 2, tx, i, 0]])
                                  T.writes([C[tx, i, j]])
                                  C[tx, i, j] = B[
                                      j % 2, tx, i, 0
                                  ] + T.float32(1)
                      with T.block():
                          T.reads([A_shared[(i + 1) % 2, tx, i + 1, 0]])
                          T.writes([B[0, tx, i + 1, 0]])
                          B[0, tx, i + 1, 0] = A_shared[
                              (i + 1) % 2, tx, 0, 0
                          ] * T.float32(2)
                      with T.block():
                          T.reads([B[1, tx, i, 0]])
                          T.writes([C[tx, i, 15]])
                          C[tx, i, 15] = B[1, tx, i, 0] + T.float32(1)
              with T.block():
                  T.reads(
                      [A_shared[1, tx, 15, 1:16], B[0:2, tx, 15, 0]]
                  )
                  T.writes([B[0:2, tx, 15, 0], C[tx, 15, 0:16]])
                  with T.block():
                      T.reads(
                          [A_shared[1, tx, 15, 1:16], B[0:2, tx, 15, 0]]
                      )
                      T.writes([B[0:2, tx, 15, 0], C[tx, 15, 0:15]])
                      for j in T.serial(0, 15):
                          with T.block():
                              T.reads([A_shared[1, tx, 15, j + 1]])
                              T.writes([B[(j + 1) % 2, tx, 15, 0]])
                              B[(j + 1) % 2, tx, 15, 0] = A_shared[
                                  1, tx, 0, j + 1
                              ] * T.float32(2)
                          with T.block():
                              T.reads([B[j % 2, tx, 15, 0]])
                              T.writes([C[tx, 15, j]])
                              C[tx, 15, j] = B[
                                  j % 2, tx, 15, 0
                              ] + T.float32(1)
                  with T.block():
                      T.reads([B[1, tx, 15, 0]])
                      T.writes([C[tx, 15, 15]])
                      C[tx, 15, 15] = B[1, tx, 15, 0] + T.float32(1)
  
imports: import sys
  import numpy
  import pytest
  import tvm
  import tvm.testing
  import tvm.tir.tensor_intrin.cuda
  from tvm import TVMError, te, tir
  from tvm.meta_schedule.testing import te_workload
  from tvm.script import tir
  from tvm.testing.tir import mma_schedule
  from tvm.tir.tensor_intrin.cuda import LDMATRIX_f16_A_DYN_INTRIN, LDMATRIX_f16_B_DYN_INTRIN, MMA_f16f16f32_INTRIN, MMA_fill_16x16_f32_INTRIN, MMA_store_16x16_f32_global_INTRIN, shared_16x16_to_ldmatrix_32x8_layout
label_desc: Use image node_id 18 for calling a global function with example usage: transformed_nested_pipeline_prefetch_inner(A, C) without return types