code: def nested_pipeline_prefetch_inner(
      A: T.Buffer((16, 16, 16), "float32"),
      C: T.Buffer((16, 16, 16), "float32"),
  ):
      for tx in T.thread_binding(0, 16, thread="threadIdx.x"):
          for i in T.serial(
              0,
              16,
              annotations={
                  "software_pipeline_stage": [0, 0, 1, 1],
                  "software_pipeline_order": [0, 2, 1, 3],
              },
          ):
              with T.block():
                  T.reads(A[tx, i, 0:16])
                  T.writes(C[tx, i, 0:16])
                  A_shared = T.alloc_buffer(
                      (16, 1, 16), dtype="float32", scope="shared"
                  )
                  for j in T.serial(0, 16):
                      with T.block():
                          T.reads(A[tx, i, j])
                          T.writes(A_shared[tx, 0, j])
                          A_shared[tx, 0, j] = A[tx, i, j]
                  for j in T.serial(
                      0,
                      16,
                      annotations={
                          "software_pipeline_stage": [0, 1],
                          "software_pipeline_order": [0, 1],
                      },
                  ):
                      with T.block():
                          T.reads(A_shared[tx, 0, j])
                          T.writes(C[tx, i, j])
                          B = T.alloc_buffer(
                              (16, 1, 1),
                              dtype="float32",
                              scope="shared",
                          )
                          with T.block():
                              T.reads(A_shared[tx, i, j])
                              T.writes(B[tx, i, 0])
                              B[tx, i, 0] = A_shared[
                                  tx, 0, j
                              ] * T.float32(2)
                          with T.block():
                              T.reads(B[tx, i, 0])
                              T.writes(C[tx, i, j])
                              C[tx, i, j] = B[tx, i, 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 17 for calling a global function with example usage: nested_pipeline_prefetch_inner(A, C) without return types