@staticmethod
@triton.jit
def forward(input_ptr: tl.tensor, weight_ptr: tl.tensor, bias_ptr: tl.
    tensor, m_size: tl.int32, n_size: tl.int32, k_size: tl.int32,
    input_m_stride: tl.int32, input_k_stride: tl.int32, weight_n_stride: tl
    .int32, weight_k_stride: tl.int32, m_offset: tl.int32, n_offset: tl.
    int32, use_accelerator: tl.constexpr, m_block_size: tl.constexpr,
    n_block_size: tl.constexpr, k_block_size: tl.constexpr, dtype: tl.constexpr
    ):
    input_block_ptr = tl.make_block_ptr(input_ptr, shape=(m_size, k_size),
        strides=(input_m_stride, input_k_stride), offsets=(m_offset, 0),
        block_shape=(m_block_size, k_block_size), order=(1, 0))
    weight_block_ptr = tl.make_block_ptr(weight_ptr, shape=(k_size, n_size),
        strides=(weight_k_stride, weight_n_stride), offsets=(0, n_offset),
        block_shape=(k_block_size, n_block_size), order=(0, 1))
    output = tl.zeros((m_block_size, n_block_size), dtype)
    for k_offset in range(0, k_size, k_block_size):
        input = tl.load(input_block_ptr, boundary_check=(0, 1),
            padding_option='zero')
        weight = tl.load(weight_block_ptr, boundary_check=(0, 1),
            padding_option='zero')
        output += tl.dot(input, weight, use_accelerator).to(dtype)
        input_block_ptr = tl.advance(input_block_ptr, (0, k_block_size))
        weight_block_ptr = tl.advance(weight_block_ptr, (k_block_size, 0))
    if bias_ptr is not None:
        bias_block_ptr = tl.make_block_ptr(bias_ptr, shape=(n_size,),
            strides=(1,), offsets=(n_offset,), block_shape=(n_block_size,),
            order=(0,))
        bias = tl.load(bias_block_ptr, boundary_check=(0,), padding_option=
            'zero')
        output += bias
    return output
