@triton.jit
def triton_normalization_backward_kernel_1(grad_input_ptr, grad_output_ptr,
    grad_weight_partial_ptr, grad_bias_partial_ptr, output_ptr, weight_ptr,
    bias_ptr, inv_var_ptr, n_cols, n_rows, has_bias: tl.constexpr,
    zero_centered: tl.constexpr, block_size: tl.constexpr, block_size_row:
    tl.constexpr):
    rows = tl.program_id(0) * block_size_row + tl.arange(0, block_size_row)[
        :, None]
    row_mask = rows < n_rows
    cols = tl.arange(0, block_size)[None, :]
    col_mask = cols < n_cols
    mask = col_mask & row_mask
    offsets = rows * n_cols + cols
    output = tl.load(output_ptr + offsets, mask=mask, other=0).to(tl.float32)
    grad_output = tl.load(grad_output_ptr + offsets, mask=mask, other=0).to(tl
        .float32)
    weight = tl.load(weight_ptr + cols, mask=col_mask).to(tl.float32)
    if zero_centered:
        weight += 1
    inv_var = tl.load(inv_var_ptr + rows, mask=row_mask)
    if has_bias:
        bias = tl.load(bias_ptr + cols, mask=col_mask).to(tl.float32)
        output = output - bias
    input_normalized = tl.where(mask, output / weight, 0.0)
    weight_grad_output = tl.where(mask, weight * grad_output * inv_var, 0.0)
    grad_input = weight_grad_output - input_normalized * (tl.sum(
        input_normalized * weight_grad_output, axis=1)[:, None] / n_cols)
    if has_bias:
        grad_input = grad_input - tl.sum(weight_grad_output, axis=1)[:, None
            ] / n_cols
    tl.store(grad_input_ptr + offsets, grad_input, mask=mask)
    parameter_offsets = tl.program_id(0) * n_cols + cols
    grad_weight_partial_ptr = grad_weight_partial_ptr + parameter_offsets
    grad_weight_partial = (grad_output * input_normalized).to(weight.dtype)
    grad_weight_partial = tl.sum(grad_weight_partial, axis=0)[None, :]
    if has_bias:
        grad_bias_partial_ptr = grad_bias_partial_ptr + parameter_offsets
        grad_bias_partial = tl.sum(grad_output.to(weight.dtype), axis=0)[
            None, :]
    tl.store(grad_weight_partial_ptr, grad_weight_partial, mask=col_mask)
    if has_bias:
        tl.store(grad_bias_partial_ptr, grad_bias_partial, mask=col_mask)
