def METHOD_NAME(cfg, data, kernel, stride, padding, out_dtype, output_padding):
    """Transposed 3D convolution ncdhw forward operator.
    Parameters
    ----------
    cfg: ConfigEntity
        The config for this template
    Input : tvm.te.Tensor
        5-D with shape [batch, in_channel, in_depth, in_height, in_width]
    Filter : tvm.te.Tensor
        5-D with shape [in_channel, num_filter, filter_depth, filter_height, filter_width]
    strides : int or a list/tuple of three ints
        The spatial stride along height and width
    padding : int or str
        Padding size, or ['VALID', 'SAME']
    out_dtype: str
        The output type. This is used in mixed precision
    output_padding : tuple of three ints
        Used to disambiguate output shape
    Returns
    -------
    Output : tvm.te.Tensor
        5-D with shape [batch, out_channel, out_depth, out_height, out_width]
    """
    batch, inp_channels, inp_depth, inp_height, inp_width = get_const_tuple(data.shape)
    _, out_channels, kernel_depth, kernel_height, kernel_width = get_const_tuple(kernel.shape)
    stride_depth, stride_height, stride_width = stride
    outpad_depth, outpad_height, outpad_width = output_padding
    assert (
        outpad_height < stride_height
        and outpad_width < stride_width
        and outpad_depth < stride_depth
    )
    cfg.stride = stride
    pad_front, pad_top, pad_left, pad_back, pad_bottom, pad_right = nn.get_pad_tuple3d(
        padding, (kernel_depth, kernel_height, kernel_width)
    )
    out_depth = (inp_depth - 1) * stride_depth + kernel_depth - pad_front - pad_back + outpad_depth
    pad_front = kernel_depth - 1 - pad_front
    pad_back = kernel_depth - 1 - pad_back
    dilated_depth = stride_depth * (inp_depth - 1) + 1
    out_width = (inp_width - 1) * stride_width + kernel_width - pad_left - pad_right + outpad_width
    pad_left = kernel_width - 1 - pad_left
    pad_right = kernel_width - 1 - pad_right
    dilated_width = stride_width * (inp_width - 1) + 1
    out_height = (
        (inp_height - 1) * stride_height + kernel_height - pad_top - pad_bottom + outpad_height
    )
    pad_top = kernel_height - 1 - pad_top
    pad_bottom = kernel_height - 1 - pad_bottom
    dilated_height = stride_height * (inp_height - 1) + 1
    # compute pad
    data = te.compute(
        (
            batch,
            inp_channels,
            pad_front + dilated_depth + pad_back,
            pad_top + dilated_height + pad_bottom,
            pad_left + dilated_width + pad_right,
        ),
        lambda n, c, d, y, x: tvm.tir.if_then_else(
            tvm.tir.all(
                x >= pad_left,
                x < pad_left + dilated_width,
                tvm.tir.indexmod(x - pad_left, stride_width).equal(0),
                y >= pad_top,
                y < pad_top + dilated_height,
                tvm.tir.indexmod(y - pad_top, stride_height).equal(0),
                d >= pad_front,
                d < pad_front + dilated_depth,
                tvm.tir.indexmod(d - pad_front, stride_depth).equal(0),
            ),
            data[
                n,
                c,
                tvm.tir.indexdiv(d - pad_front, stride_depth),
                tvm.tir.indexdiv(y - pad_top, stride_height),
                tvm.tir.indexdiv(x - pad_left, stride_width),
            ],
            tvm.tir.const(0.0, "float32"),
        ),
        name="data_pad",
    )
    # compute transposed conv
    dc = te.reduce_axis((0, inp_channels), name="dc")
    dd = te.reduce_axis((0, kernel_depth), name="dd")
    dh = te.reduce_axis((0, kernel_height), name="dh")
    dw = te.reduce_axis((0, kernel_width), name="dw")
    data_out = te.compute(
        (batch, out_channels, out_depth, out_height, out_width),
        lambda b, c, d, h, w: te.sum(
            data[b, dc, d + dd, h + dh, w + dw].astype(out_dtype)
            * kernel[
                dc, c, kernel_depth - 1 - dd, kernel_height - 1 - dh, kernel_width - 1 - dw
            ].astype(out_dtype),
            axis=[dc, dd, dh, dw],
        ),
        tag="conv3d_transpose_ncdhw",
    )
    return data_out