code: def main(
      inputs: T.Buffer((1, 4, 4, 512), "float32"),
      weight: T.Buffer((4, 4, 512, 256), "float32"),
      conv2d_transpose_nhwc: T.Buffer((1, 8, 8, 256), "float32"),
  ) -> None:
      # function attr dict
      T.func_attr({"global_symbol": "main", "tir.noalias": True})
      inputs_flat = T.Buffer([8192], dtype="float32", data=inputs.data)
      weight_flat = T.Buffer(
          [2097152], dtype="float32", data=weight.data
      )
      conv2d_transpose_nhwc_flat = T.Buffer(
          [16384], dtype="float32", data=conv2d_transpose_nhwc.data
      )
      # var definition
      threadIdx_x = T.env_thread("threadIdx.x")
      blockIdx_x = T.env_thread("blockIdx.x")
      # body
      T.launch_thread(blockIdx_x, 64)
      conv2d_transpose_nhwc_local = T.decl_buffer(
          [8], "float32", scope="local"
      )
      PadInput_shared = T.decl_buffer([768], "float32", scope="shared")
      weight_shared = T.decl_buffer([4096], "float32", scope="shared")
      T.launch_thread(threadIdx_x, 32)
      for i2_3_init, i1_4_init, i2_4_init in T.grid(2, 2, 2):
          conv2d_transpose_nhwc_local[
              i1_4_init * 4 + i2_3_init * 2 + i2_4_init
          ] = T.float32(0)
      for i6_0 in T.serial(16):
          for ax0_ax1_ax2_ax3_fused_0 in T.serial(24):
              PadInput_shared[
                  ax0_ax1_ax2_ax3_fused_0 * 32 + threadIdx_x
              ] = T.if_then_else(
                  1
                  <= (ax0_ax1_ax2_ax3_fused_0 + threadIdx_x // 32) // 4
                  and (ax0_ax1_ax2_ax3_fused_0 + threadIdx_x // 32)
                  // 20
                  < 1
                  and 1
                  <= blockIdx_x // 32 * 2
                  + (ax0_ax1_ax2_ax3_fused_0 + threadIdx_x // 32) % 4
                  and (
                      blockIdx_x // 32 * 2
                      + (ax0_ax1_ax2_ax3_fused_0 + threadIdx_x // 32)
                      % 4
                  )
                  // 5
                  < 1,
                  inputs_flat[
                      blockIdx_x // 32 * 1024
                      + ax0_ax1_ax2_ax3_fused_0 * 512
                      + i6_0 * 32
                      + threadIdx_x
                      - 2560
                  ],
                  T.float32(0),
                  dtype="float32",
              )
          for ax0_ax1_ax2_ax3_fused_0 in T.serial(32):
              weight_shared[
                  T.ramp(
                      ax0_ax1_ax2_ax3_fused_0 * 128 + threadIdx_x * 4,
                      1,
                      4,
                  )
              ] = weight_flat[
                  T.ramp(
                      (ax0_ax1_ax2_ax3_fused_0 + threadIdx_x * 4 // 128)
                      // 2
                      * 131072
                      + i6_0 * 8192
                      + (
                          ax0_ax1_ax2_ax3_fused_0 * 16
                          + threadIdx_x * 4 // 8
                      )
                      % 32
                      * 256
                      + blockIdx_x % 32 * 8
                      + threadIdx_x % 2 * 4,
                      1,
                      4,
                  )
              ]
          for i6_1, i2_3, i4_2, i5_2, i6_2, i1_4, i2_4 in T.grid(
              4, 2, 4, 4, 8, 2, 2
          ):
              conv2d_transpose_nhwc_local[
                  i1_4 * 4 + i2_3 * 2 + i2_4
              ] = (
                  conv2d_transpose_nhwc_local[
                      i1_4 * 4 + i2_3 * 2 + i2_4
                  ]
                  + T.if_then_else(
                      (i1_4 + i4_2) % 2 == 0 and (i2_4 + i5_2) % 2 == 0,
                      PadInput_shared[
                          threadIdx_x // 8 * 128
                          + (i1_4 + i4_2) // 2 * 128
                          + (i2_4 + i5_2) // 2 * 32
                          + i2_3 * 32
                          + i6_1 * 8
                          + i6_2
                      ],
                      T.float32(0),
                      dtype="float32",
                  )
                  * weight_shared[
                      i6_1 * 64
                      + i6_2 * 8
                      + threadIdx_x % 8
                      + 3840
                      - i5_2 * 256
                      - i4_2 * 1024
                  ]
              )
      for ax1, ax2 in T.grid(2, 4):
          conv2d_transpose_nhwc_flat[
              threadIdx_x // 8 * 4096
              + ax1 * 2048
              + blockIdx_x // 32 * 1024
              + ax2 * 256
              + blockIdx_x % 32 * 8
              + threadIdx_x % 8
          ] = conv2d_transpose_nhwc_local[ax1 * 4 + ax2]
  
file_path: tvm/tests/python/tir-transform/test_tir_transform_renormalize_split_pattern.py
imports: import tvm
  import tvm.testing
  from tvm.script import tir
label_desc: Use image node_id 1 for calling the After obj's underlying member method code with example usage: obj.main(inputs, weight, conv2d_transpose_nhwc) without return types