import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice
from collections import OrderedDict
import torch.nn as nn
import torch.nn.functional as F
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
reinterpret_tensor = torch._C._dynamo.guards._reinterpret_tensor


@triton.jit
def triton_poi_fused_0(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK: tl.
    constexpr, XBLOCK: tl.constexpr):
    ynumel = 768
    xnumel = 49
    yoffset = tl.program_id(1) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    ymask = yindex < ynumel
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    x2 = xindex
    y3 = yindex
    y0 = yindex % 3
    y1 = yindex // 3
    tmp0 = tl.load(in_ptr0 + (x2 + 49 * y3), xmask & ymask, eviction_policy
        ='evict_last')
    tl.store(out_ptr0 + (y0 + 3 * x2 + 147 * y1), tmp0, xmask & ymask)


@triton.jit
def triton_poi_fused_1(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK: tl.
    constexpr, XBLOCK: tl.constexpr):
    ynumel = 12
    yoffset = tl.program_id(1) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    ymask = yindex < ynumel
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, YBLOCK], True, tl.int1)
    x2 = xindex
    y3 = yindex
    y0 = yindex % 3
    y1 = yindex // 3
    tmp0 = tl.load(in_ptr0 + (x2 + 4096 * y3), ymask, eviction_policy=
        'evict_last')
    tl.store(out_ptr0 + (y0 + 3 * x2 + 12288 * y1), tmp0, ymask)


@triton.jit
def triton_poi_fused_2(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK: tl.
    constexpr, XBLOCK: tl.constexpr):
    xnumel = 9
    yoffset = (tl.program_id(1) + tl.program_id(2) * tl.num_programs(1)
        ) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    tl.full([XBLOCK, YBLOCK], True, tl.int1)
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    x2 = xindex
    y3 = yindex
    y0 = yindex % 256
    y1 = yindex // 256
    tmp0 = tl.load(in_ptr0 + (x2 + 9 * y3), xmask, eviction_policy='evict_last'
        )
    tl.store(out_ptr0 + (y0 + 256 * x2 + 2304 * y1), tmp0, xmask)


@triton.jit
def triton_poi_fused_3(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK: tl.
    constexpr, XBLOCK: tl.constexpr):
    xnumel = 9
    yoffset = (tl.program_id(1) + tl.program_id(2) * tl.num_programs(1)
        ) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    tl.full([XBLOCK, YBLOCK], True, tl.int1)
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    x2 = xindex
    y3 = yindex
    y0 = yindex % 512
    y1 = yindex // 512
    tmp0 = tl.load(in_ptr0 + (x2 + 9 * y3), xmask, eviction_policy='evict_last'
        )
    tl.store(out_ptr0 + (y0 + 512 * x2 + 4608 * y1), tmp0, xmask)


@triton.jit
def triton_poi_fused_4(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK: tl.
    constexpr, XBLOCK: tl.constexpr):
    xnumel = 9
    yoffset = (tl.program_id(1) + tl.program_id(2) * tl.num_programs(1)
        ) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    tl.full([XBLOCK, YBLOCK], True, tl.int1)
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    x2 = xindex
    y3 = yindex
    y0 = yindex % 1024
    y1 = yindex // 1024
    tmp0 = tl.load(in_ptr0 + (x2 + 9 * y3), xmask, eviction_policy='evict_last'
        )
    tl.store(out_ptr0 + (y0 + 1024 * x2 + 9216 * y1), tmp0, xmask)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_5(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr):
    xnumel = 256
    rnumel = 147
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rindex = tl.arange(0, RBLOCK)[None, :]
    rmask = rindex < rnumel
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 147 * x0), rmask & xmask, other=0.0)
    tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
    tl.where(rmask & xmask, tmp1, 0)
    tmp4 = tl.broadcast_to(tmp1, [XBLOCK, RBLOCK])
    tmp6 = tl.where(rmask & xmask, tmp4, 0)
    tmp7 = tl.sum(tmp6, 1)[:, None]
    tmp8 = tl.full([XBLOCK, 1], 147, tl.int32)
    tmp9 = tmp8.to(tl.float32)
    tmp10 = tmp7 / tmp9
    tmp11 = tmp1 - tmp10
    tmp12 = tmp11 * tmp11
    tmp13 = tl.broadcast_to(tmp12, [XBLOCK, RBLOCK])
    tmp15 = tl.where(rmask & xmask, tmp13, 0)
    tmp16 = tl.sum(tmp15, 1)[:, None]
    tmp17 = 147.0
    tmp18 = tmp16 / tmp17
    tmp19 = 1e-05
    tmp20 = tmp18 + tmp19
    tmp21 = libdevice.sqrt(tmp20)
    tmp22 = tmp0 - tmp10
    tmp23 = tmp22 / tmp21
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp21, xmask)
    tl.store(out_ptr1 + (r1 + 147 * x0), tmp23, rmask & xmask)


@triton.jit
def triton_red_fused_native_group_norm_6(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 8192
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 32
    x1 = xindex // 32
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    x4 = xindex
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex % 8
        r3 = rindex // 8
        tmp0 = tl.load(in_ptr0 + (r2 + 8 * x0 + 256 * r3 + 262144 * x1), 
            rmask & xmask, eviction_policy='evict_first', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp2, xmask)
    tl.store(out_ptr1 + x4, tmp3, xmask)
    tmp5 = 8192.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_7(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 256
    x2 = xindex // 262144
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 8), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 8), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 8192.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-06
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp14 = tl.full([1], 0, tl.int32)
    tmp15 = triton_helpers.maximum(tmp14, tmp13)
    tl.store(out_ptr0 + x3, tmp15, None)


@triton.jit
def triton_poi_fused_max_pool2d_with_indices_8(in_ptr0, out_ptr0, out_ptr1,
    xnumel, XBLOCK: tl.constexpr):
    xnumel = 230400
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex % 256
    x1 = xindex // 256 % 15
    x2 = xindex // 3840 % 15
    x3 = xindex // 57600
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + 512 * x1 + 16384 * x2 + 262144 * x3), xmask)
    tmp1 = tl.load(in_ptr0 + (256 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp3 = tl.load(in_ptr0 + (512 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp5 = tl.load(in_ptr0 + (8192 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp7 = tl.load(in_ptr0 + (8448 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp9 = tl.load(in_ptr0 + (8704 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp11 = tl.load(in_ptr0 + (16384 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp13 = tl.load(in_ptr0 + (16640 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp15 = tl.load(in_ptr0 + (16896 + x0 + 512 * x1 + 16384 * x2 + 262144 *
        x3), xmask)
    tmp2 = triton_helpers.maximum(tmp1, tmp0)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp6 = triton_helpers.maximum(tmp5, tmp4)
    tmp8 = triton_helpers.maximum(tmp7, tmp6)
    tmp10 = triton_helpers.maximum(tmp9, tmp8)
    tmp12 = triton_helpers.maximum(tmp11, tmp10)
    tmp14 = triton_helpers.maximum(tmp13, tmp12)
    tmp16 = triton_helpers.maximum(tmp15, tmp14)
    tmp17 = tmp1 > tmp0
    tmp18 = tl.full([1], 1, tl.int8)
    tmp19 = tl.full([1], 0, tl.int8)
    tmp20 = tl.where(tmp17, tmp18, tmp19)
    tmp21 = tmp3 > tmp2
    tmp22 = tl.full([1], 2, tl.int8)
    tmp23 = tl.where(tmp21, tmp22, tmp20)
    tmp24 = tmp5 > tmp4
    tmp25 = tl.full([1], 3, tl.int8)
    tmp26 = tl.where(tmp24, tmp25, tmp23)
    tmp27 = tmp7 > tmp6
    tmp28 = tl.full([1], 4, tl.int8)
    tmp29 = tl.where(tmp27, tmp28, tmp26)
    tmp30 = tmp9 > tmp8
    tmp31 = tl.full([1], 5, tl.int8)
    tmp32 = tl.where(tmp30, tmp31, tmp29)
    tmp33 = tmp11 > tmp10
    tmp34 = tl.full([1], 6, tl.int8)
    tmp35 = tl.where(tmp33, tmp34, tmp32)
    tmp36 = tmp13 > tmp12
    tmp37 = tl.full([1], 7, tl.int8)
    tmp38 = tl.where(tmp36, tmp37, tmp35)
    tmp39 = tmp15 > tmp14
    tmp40 = tl.full([1], 8, tl.int8)
    tmp41 = tl.where(tmp39, tmp40, tmp38)
    tl.store(out_ptr0 + x4, tmp16, xmask)
    tl.store(out_ptr1 + x4, tmp41, xmask)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_9(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 256 * x0), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 256, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 256.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.sqrt(tmp17)
    tmp19 = tmp0 - tmp8
    tmp20 = tmp19 / tmp18
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp18, None)
    tl.store(out_ptr1 + (r1 + 256 * x0), tmp20, None)


@triton.jit
def triton_per_fused_native_group_norm_10(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr):
    rnumel = 225
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[None, :]
    rmask = rindex < rnumel
    r2 = rindex
    x0 = xindex % 1024
    x1 = xindex // 1024
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + 1024 * r2 + 230400 * x1), rmask, other=0.0)
    tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
    tl.where(rmask, tmp1, 0)
    tmp4 = tl.broadcast_to(tmp1, [XBLOCK, RBLOCK])
    tmp6 = tl.where(rmask, tmp4, 0)
    tmp7 = tl.sum(tmp6, 1)[:, None]
    tmp8 = tl.full([XBLOCK, 1], 225, tl.int32)
    tmp9 = tmp8.to(tl.float32)
    tmp10 = tmp7 / tmp9
    tmp11 = tmp1 - tmp10
    tmp12 = tmp11 * tmp11
    tmp13 = tl.broadcast_to(tmp12, [XBLOCK, RBLOCK])
    tmp15 = tl.where(rmask, tmp13, 0)
    tmp16 = tl.sum(tmp15, 1)[:, None]
    tmp17 = 225.0
    tmp18 = tmp16 / tmp17
    tmp19 = 1e-05
    tmp20 = tmp18 + tmp19
    tmp21 = libdevice.rsqrt(tmp20)
    tl.store(out_ptr2 + x3, tmp21, None)
    tl.store(out_ptr0 + x3, tmp10, None)
    tl.store(out_ptr1 + x3, tmp16, None)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_11(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 256 * x0), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 256, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 256.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.sqrt(tmp17)
    tmp19 = tmp0 - tmp8
    tmp20 = tmp19 / tmp18
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp18, None)
    tl.store(out_ptr1 + (r1 + 256 * x0), tmp20, None)


@triton.jit
def triton_red_fused_native_group_norm_12(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 1800
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 32
    x1 = xindex // 32
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    x4 = xindex
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex % 8
        r3 = rindex // 8
        tmp0 = tl.load(in_ptr0 + (r2 + 8 * x0 + 256 * r3 + 57600 * x1), 
            rmask & xmask, eviction_policy='evict_first', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp2, xmask)
    tl.store(out_ptr1 + x4, tmp3, xmask)
    tmp5 = 1800.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_13(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 230400
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x3 = xindex
    x0 = xindex % 256
    x2 = xindex // 57600
    tmp0 = tl.load(in_ptr0 + x3, xmask)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 8), xmask, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 8), xmask, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, xmask, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 1800.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-06
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp14 = tl.full([1], 0, tl.int32)
    tmp15 = triton_helpers.maximum(tmp14, tmp13)
    tl.store(out_ptr0 + x3, tmp15, xmask)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_14(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 256
    rnumel = 2304
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp0 = tl.load(in_ptr0 + (r1 + 2304 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tmp5 = 2304.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.sqrt(tmp8)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp9, xmask)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp10 = tl.load(in_ptr0 + (r1 + 2304 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 2304 * x0), tmp12, rmask & xmask)


@triton.jit
def triton_red_fused_native_group_norm_15(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 7200
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 32
    x1 = xindex // 32
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    x4 = xindex
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex % 32
        r3 = rindex // 32
        tmp0 = tl.load(in_ptr0 + (r2 + 32 * x0 + 1024 * r3 + 230400 * x1), 
            rmask & xmask, eviction_policy='evict_first', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp2, xmask)
    tl.store(out_ptr1 + x4, tmp3, xmask)
    tmp5 = 7200.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_add_native_group_norm_relu_16(in_out_ptr0, in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, in_ptr8,
    in_ptr9, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 1024
    x2 = xindex // 230400
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (x0 + 1024 * x2), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (x0 + 1024 * x2), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp14 = tl.load(in_ptr5 + x3, None)
    tmp15 = tl.load(in_ptr6 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp17 = tl.load(in_ptr7 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp24 = tl.load(in_ptr8 + x0, None, eviction_policy='evict_last')
    tmp26 = tl.load(in_ptr9 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 225.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp16 = tmp14 - tmp15
    tmp18 = 7200.0
    tmp19 = tmp17 / tmp18
    tmp20 = 1e-06
    tmp21 = tmp19 + tmp20
    tmp22 = libdevice.rsqrt(tmp21)
    tmp23 = tmp16 * tmp22
    tmp25 = tmp23 * tmp24
    tmp27 = tmp25 + tmp26
    tmp28 = tmp13 + tmp27
    tmp29 = tl.full([1], 0, tl.int32)
    tmp30 = triton_helpers.maximum(tmp29, tmp28)
    tl.store(in_out_ptr0 + x3, tmp30, None)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_17(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 1024 * x0), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 1024, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 1024.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.sqrt(tmp17)
    tmp19 = tmp0 - tmp8
    tmp20 = tmp19 / tmp18
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp18, None)
    tl.store(out_ptr1 + (r1 + 1024 * x0), tmp20, None)


@triton.jit
def triton_poi_fused_add_native_group_norm_relu_18(in_ptr0, in_ptr1,
    in_ptr2, in_ptr3, in_ptr4, in_ptr5, out_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 1024
    x2 = xindex // 230400
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x3, None)
    tmp2 = tl.load(in_ptr2 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp4 = tl.load(in_ptr3 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp11 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp13 = tl.load(in_ptr5 + x0, None, eviction_policy='evict_last')
    tmp3 = tmp1 - tmp2
    tmp5 = 7200.0
    tmp6 = tmp4 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tmp10 = tmp3 * tmp9
    tmp12 = tmp10 * tmp11
    tmp14 = tmp12 + tmp13
    tmp15 = tmp0 + tmp14
    tmp16 = tl.full([1], 0, tl.int32)
    tmp17 = triton_helpers.maximum(tmp16, tmp15)
    tl.store(out_ptr0 + x3, tmp17, None)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_19(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 1024 * x0), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 1024, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 1024.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.sqrt(tmp17)
    tmp19 = tmp0 - tmp8
    tmp20 = tmp19 / tmp18
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp18, None)
    tl.store(out_ptr1 + (r1 + 1024 * x0), tmp20, None)


@triton.jit
def triton_per_fused_native_group_norm_20(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr):
    RBLOCK: tl.constexpr = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[None, :]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    r2 = rindex
    x0 = xindex % 2048
    x1 = xindex // 2048
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + 2048 * r2 + 131072 * x1), None)
    tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [XBLOCK, RBLOCK])
    tmp5 = tl.sum(tmp3, 1)[:, None]
    tmp6 = tl.full([XBLOCK, 1], 64, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [XBLOCK, RBLOCK])
    tmp13 = tl.sum(tmp11, 1)[:, None]
    tmp14 = 64.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.rsqrt(tmp17)
    tl.store(out_ptr2 + x3, tmp18, None)
    tl.store(out_ptr0 + x3, tmp8, None)
    tl.store(out_ptr1 + x3, tmp13, None)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_21(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 1024 * x0), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 1024, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 1024.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.sqrt(tmp17)
    tmp19 = tmp0 - tmp8
    tmp20 = tmp19 / tmp18
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp18, None)
    tl.store(out_ptr1 + (r1 + 1024 * x0), tmp20, None)


@triton.jit
def triton_red_fused_native_group_norm_22(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 3600
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 32
    x1 = xindex // 32
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    x4 = xindex
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex % 16
        r3 = rindex // 16
        tmp0 = tl.load(in_ptr0 + (r2 + 16 * x0 + 512 * r3 + 115200 * x1), 
            rmask & xmask, eviction_policy='evict_first', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp2, xmask)
    tl.store(out_ptr1 + x4, tmp3, xmask)
    tmp5 = 3600.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_23(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 512
    x2 = xindex // 115200
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 16), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 16), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 3600.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-06
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp14 = tl.full([1], 0, tl.int32)
    tmp15 = triton_helpers.maximum(tmp14, tmp13)
    tl.store(out_ptr0 + x3, tmp15, None)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_24(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 512
    rnumel = 4608
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp0 = tl.load(in_ptr0 + (r1 + 4608 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tmp5 = 4608.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.sqrt(tmp8)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp9, xmask)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp10 = tl.load(in_ptr0 + (r1 + 4608 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 4608 * x0), tmp12, rmask & xmask)


@triton.jit
def triton_per_fused_native_group_norm_25(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r2 = rindex % 16
    r3 = rindex // 16
    x0 = xindex % 32
    x1 = xindex // 32
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + 16 * x0 + 512 * r3 + 32768 * x1), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 1024, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 1024.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-06
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.rsqrt(tmp17)
    tl.store(out_ptr2 + x4, tmp18, None)
    tl.store(out_ptr0 + x4, tmp8, None)
    tl.store(out_ptr1 + x4, tmp13, None)


@triton.jit
def triton_poi_fused_native_group_norm_relu_26(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 512
    x2 = xindex // 32768
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 16), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 16), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 1024.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-06
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp14 = tl.full([1], 0, tl.int32)
    tmp15 = triton_helpers.maximum(tmp14, tmp13)
    tl.store(out_ptr0 + x3, tmp15, None)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_27(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 512 * x0), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 512, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 512.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.sqrt(tmp17)
    tmp19 = tmp0 - tmp8
    tmp20 = tmp19 / tmp18
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp18, None)
    tl.store(out_ptr1 + (r1 + 512 * x0), tmp20, None)


@triton.jit
def triton_red_fused_native_group_norm_28(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 4096
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 32
    x1 = xindex // 32
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    x4 = xindex
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex % 64
        r3 = rindex // 64
        tmp0 = tl.load(in_ptr0 + (r2 + 64 * x0 + 2048 * r3 + 131072 * x1), 
            rmask & xmask, eviction_policy='evict_first', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp2, xmask)
    tl.store(out_ptr1 + x4, tmp3, xmask)
    tmp5 = 4096.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_add_native_group_norm_relu_29(in_out_ptr0, in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, in_ptr8,
    in_ptr9, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 2048
    x2 = xindex // 131072
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (x0 + 2048 * x2), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (x0 + 2048 * x2), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp14 = tl.load(in_ptr5 + x3, None)
    tmp15 = tl.load(in_ptr6 + (32 * x2 + x0 // 64), None, eviction_policy=
        'evict_last')
    tmp17 = tl.load(in_ptr7 + (32 * x2 + x0 // 64), None, eviction_policy=
        'evict_last')
    tmp24 = tl.load(in_ptr8 + x0, None, eviction_policy='evict_last')
    tmp26 = tl.load(in_ptr9 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 64.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp16 = tmp14 - tmp15
    tmp18 = 4096.0
    tmp19 = tmp17 / tmp18
    tmp20 = 1e-06
    tmp21 = tmp19 + tmp20
    tmp22 = libdevice.rsqrt(tmp21)
    tmp23 = tmp16 * tmp22
    tmp25 = tmp23 * tmp24
    tmp27 = tmp25 + tmp26
    tmp28 = tmp13 + tmp27
    tmp29 = tl.full([1], 0, tl.int32)
    tmp30 = triton_helpers.maximum(tmp29, tmp28)
    tl.store(in_out_ptr0 + x3, tmp30, None)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_30(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 512
    rnumel = 2048
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp0 = tl.load(in_ptr0 + (r1 + 2048 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.sqrt(tmp8)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp9, xmask)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp10 = tl.load(in_ptr0 + (r1 + 2048 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 2048 * x0), tmp12, rmask & xmask)


@triton.jit
def triton_poi_fused_add_native_group_norm_relu_31(in_ptr0, in_ptr1,
    in_ptr2, in_ptr3, in_ptr4, in_ptr5, out_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 2048
    x2 = xindex // 131072
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x3, None)
    tmp2 = tl.load(in_ptr2 + (32 * x2 + x0 // 64), None, eviction_policy=
        'evict_last')
    tmp4 = tl.load(in_ptr3 + (32 * x2 + x0 // 64), None, eviction_policy=
        'evict_last')
    tmp11 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp13 = tl.load(in_ptr5 + x0, None, eviction_policy='evict_last')
    tmp3 = tmp1 - tmp2
    tmp5 = 4096.0
    tmp6 = tmp4 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tmp10 = tmp3 * tmp9
    tmp12 = tmp10 * tmp11
    tmp14 = tmp12 + tmp13
    tmp15 = tmp0 + tmp14
    tmp16 = tl.full([1], 0, tl.int32)
    tmp17 = triton_helpers.maximum(tmp16, tmp15)
    tl.store(out_ptr0 + x3, tmp17, None)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_32(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    rnumel = 2048
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp0 = tl.load(in_ptr0 + (r1 + 2048 * x0), rmask, eviction_policy=
            'evict_last', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.sqrt(tmp8)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp9, None)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp10 = tl.load(in_ptr0 + (r1 + 2048 * x0), rmask, eviction_policy=
            'evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 2048 * x0), tmp12, rmask)


@triton.jit
def triton_per_fused_native_group_norm_33(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr):
    RBLOCK: tl.constexpr = 16
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[None, :]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    r2 = rindex
    x0 = xindex % 4096
    x1 = xindex // 4096
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + 4096 * r2 + 65536 * x1), None)
    tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [XBLOCK, RBLOCK])
    tmp5 = tl.sum(tmp3, 1)[:, None]
    tmp6 = tl.full([XBLOCK, 1], 16, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [XBLOCK, RBLOCK])
    tmp13 = tl.sum(tmp11, 1)[:, None]
    tmp14 = 16.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.rsqrt(tmp17)
    tl.store(out_ptr2 + x3, tmp18, None)
    tl.store(out_ptr0 + x3, tmp8, None)
    tl.store(out_ptr1 + x3, tmp13, None)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_34(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 1024
    rnumel = 2048
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp0 = tl.load(in_ptr0 + (r1 + 2048 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.sqrt(tmp8)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp9, xmask)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp10 = tl.load(in_ptr0 + (r1 + 2048 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 2048 * x0), tmp12, rmask & xmask)


@triton.jit
def triton_red_fused_native_group_norm_35(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 2048
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 32
    x1 = xindex // 32
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    x4 = xindex
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex % 32
        r3 = rindex // 32
        tmp0 = tl.load(in_ptr0 + (r2 + 32 * x0 + 1024 * r3 + 65536 * x1), 
            rmask & xmask, eviction_policy='evict_first', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp2, xmask)
    tl.store(out_ptr1 + x4, tmp3, xmask)
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_36(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 1024
    x2 = xindex // 65536
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 2048.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-06
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp14 = tl.full([1], 0, tl.int32)
    tmp15 = triton_helpers.maximum(tmp14, tmp13)
    tl.store(out_ptr0 + x3, tmp15, None)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_37(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 1024
    rnumel = 9216
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp0 = tl.load(in_ptr0 + (r1 + 9216 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tmp5 = 9216.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.sqrt(tmp8)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp9, xmask)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp10 = tl.load(in_ptr0 + (r1 + 9216 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 9216 * x0), tmp12, rmask & xmask)


@triton.jit
def triton_per_fused_native_group_norm_38(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r2 = rindex % 32
    r3 = rindex // 32
    x0 = xindex % 32
    x1 = xindex // 32
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + 32 * x0 + 1024 * r3 + 16384 * x1), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 512, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 512.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-06
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.rsqrt(tmp17)
    tl.store(out_ptr2 + x4, tmp18, None)
    tl.store(out_ptr0 + x4, tmp8, None)
    tl.store(out_ptr1 + x4, tmp13, None)


@triton.jit
def triton_poi_fused_native_group_norm_relu_39(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 1024
    x2 = xindex // 16384
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 32), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 512.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-06
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp14 = tl.full([1], 0, tl.int32)
    tmp15 = triton_helpers.maximum(tmp14, tmp13)
    tl.store(out_ptr0 + x3, tmp15, None)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_40(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 1024 * x0), None)
    tmp1 = tl.broadcast_to(tmp0, [RBLOCK])
    tmp3 = tl.broadcast_to(tmp1, [RBLOCK])
    tmp5 = triton_helpers.promote_to_tensor(tl.sum(tmp3, 0))
    tmp6 = tl.full([1], 1024, tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 / tmp7
    tmp9 = tmp1 - tmp8
    tmp10 = tmp9 * tmp9
    tmp11 = tl.broadcast_to(tmp10, [RBLOCK])
    tmp13 = triton_helpers.promote_to_tensor(tl.sum(tmp11, 0))
    tmp14 = 1024.0
    tmp15 = tmp13 / tmp14
    tmp16 = 1e-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.sqrt(tmp17)
    tmp19 = tmp0 - tmp8
    tmp20 = tmp19 / tmp18
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp18, None)
    tl.store(out_ptr1 + (r1 + 1024 * x0), tmp20, None)


@triton.jit
def triton_red_fused_native_group_norm_41(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 2048
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 32
    x1 = xindex // 32
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    x4 = xindex
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex % 128
        r3 = rindex // 128
        tmp0 = tl.load(in_ptr0 + (r2 + 128 * x0 + 4096 * r3 + 65536 * x1), 
            rmask & xmask, eviction_policy='evict_first', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp2, xmask)
    tl.store(out_ptr1 + x4, tmp3, xmask)
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_add_native_group_norm_relu_42(in_out_ptr0, in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, in_ptr8,
    in_ptr9, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 4096
    x2 = xindex // 65536
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (x0 + 4096 * x2), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (x0 + 4096 * x2), None, eviction_policy=
        'evict_last')
    tmp10 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp14 = tl.load(in_ptr5 + x3, None)
    tmp15 = tl.load(in_ptr6 + (32 * x2 + x0 // 128), None, eviction_policy=
        'evict_last')
    tmp17 = tl.load(in_ptr7 + (32 * x2 + x0 // 128), None, eviction_policy=
        'evict_last')
    tmp24 = tl.load(in_ptr8 + x0, None, eviction_policy='evict_last')
    tmp26 = tl.load(in_ptr9 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = 16.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    tmp7 = tmp5 + tmp6
    tmp8 = libdevice.rsqrt(tmp7)
    tmp9 = tmp2 * tmp8
    tmp11 = tmp9 * tmp10
    tmp13 = tmp11 + tmp12
    tmp16 = tmp14 - tmp15
    tmp18 = 2048.0
    tmp19 = tmp17 / tmp18
    tmp20 = 1e-06
    tmp21 = tmp19 + tmp20
    tmp22 = libdevice.rsqrt(tmp21)
    tmp23 = tmp16 * tmp22
    tmp25 = tmp23 * tmp24
    tmp27 = tmp25 + tmp26
    tmp28 = tmp13 + tmp27
    tmp29 = tl.full([1], 0, tl.int32)
    tmp30 = triton_helpers.maximum(tmp29, tmp28)
    tl.store(in_out_ptr0 + x3, tmp30, None)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_43(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 1024
    rnumel = 4096
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp2_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp2_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp0 = tl.load(in_ptr0 + (r1 + 4096 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp1 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
        tmp2_mean_next, tmp2_m2_next, tmp2_weight_next = (triton_helpers.
            welford_reduce(tmp1, tmp2_mean, tmp2_m2, tmp2_weight, roffset == 0)
            )
        tmp2_mean = tl.where(rmask & xmask, tmp2_mean_next, tmp2_mean)
        tmp2_m2 = tl.where(rmask & xmask, tmp2_m2_next, tmp2_m2)
        tmp2_weight = tl.where(rmask & xmask, tmp2_weight_next, tmp2_weight)
    tmp2_tmp, tmp3_tmp, tmp4_tmp = triton_helpers.welford(tmp2_mean,
        tmp2_m2, tmp2_weight, 1)
    tmp2 = tmp2_tmp[:, None]
    tmp3 = tmp3_tmp[:, None]
    tmp4_tmp[:, None]
    tmp5 = 4096.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.sqrt(tmp8)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp9, xmask)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r1 = rindex
        tmp10 = tl.load(in_ptr0 + (r1 + 4096 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 4096 * x0), tmp12, rmask & xmask)


@triton.jit
def triton_poi_fused_add_native_group_norm_relu_44(in_ptr0, in_ptr1,
    in_ptr2, in_ptr3, in_ptr4, in_ptr5, out_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 4096
    x2 = xindex // 65536
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x3, None)
    tmp2 = tl.load(in_ptr2 + (32 * x2 + x0 // 128), None, eviction_policy=
        'evict_last')
    tmp4 = tl.load(in_ptr3 + (32 * x2 + x0 // 128), None, eviction_policy=
        'evict_last')
    tmp11 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp13 = tl.load(in_ptr5 + x0, None, eviction_policy='evict_last')
    tmp3 = tmp1 - tmp2
    tmp5 = 2048.0
    tmp6 = tmp4 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tmp10 = tmp3 * tmp9
    tmp12 = tmp10 * tmp11
    tmp14 = tmp12 + tmp13
    tmp15 = tmp0 + tmp14
    tmp16 = tl.full([1], 0, tl.int32)
    tmp17 = triton_helpers.maximum(tmp16, tmp15)
    tl.store(out_ptr0 + x3, tmp17, None)


@triton.jit
def triton_poi_fused_add_native_group_norm_relu_45(in_ptr0, in_ptr1,
    in_ptr2, in_ptr3, in_ptr4, in_ptr5, out_ptr0, ynumel, xnumel, YBLOCK:
    tl.constexpr, XBLOCK: tl.constexpr):
    ynumel = 64
    yoffset = tl.program_id(1) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    ymask = yindex < ynumel
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, YBLOCK], True, tl.int1)
    x2 = xindex
    y3 = yindex
    y1 = yindex // 16
    y0 = yindex % 16
    tmp0 = tl.load(in_ptr0 + (x2 + 4096 * y3), ymask, eviction_policy=
        'evict_last')
    tmp1 = tl.load(in_ptr1 + (x2 + 4096 * y3), ymask, eviction_policy=
        'evict_last')
    tmp2 = tl.load(in_ptr2 + (32 * y1 + x2 // 128), ymask, eviction_policy=
        'evict_last')
    tmp4 = tl.load(in_ptr3 + (32 * y1 + x2 // 128), ymask, eviction_policy=
        'evict_last')
    tmp11 = tl.load(in_ptr4 + x2, None, eviction_policy='evict_last')
    tmp13 = tl.load(in_ptr5 + x2, None, eviction_policy='evict_last')
    tmp3 = tmp1 - tmp2
    tmp5 = 2048.0
    tmp6 = tmp4 / tmp5
    tmp7 = 1e-06
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tmp10 = tmp3 * tmp9
    tmp12 = tmp10 * tmp11
    tmp14 = tmp12 + tmp13
    tmp15 = tmp0 + tmp14
    tmp16 = tl.full([1, 1], 0, tl.int32)
    tmp17 = triton_helpers.maximum(tmp16, tmp15)
    tl.store(out_ptr0 + (y0 + 16 * x2 + 65536 * y1), tmp17, ymask)


@triton.jit
def triton_poi_fused_threshold_backward_46(in_ptr0, out_ptr0, ynumel,
    xnumel, YBLOCK: tl.constexpr, XBLOCK: tl.constexpr):
    xnumel = 16
    yoffset = tl.program_id(1) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    tl.full([XBLOCK, YBLOCK], True, tl.int1)
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    x2 = xindex
    y3 = yindex
    y0 = yindex % 4096
    y1 = yindex // 4096
    tmp0 = tl.load(in_ptr0 + (x2 + 16 * y3), xmask, eviction_policy=
        'evict_last')
    tmp1 = 0.0
    tmp2 = tmp0 <= tmp1
    tl.store(out_ptr0 + (y0 + 4096 * x2 + 65536 * y1), tmp2, xmask)


def call(args):
    (primals_1, primals_2, primals_3, primals_4, primals_5, primals_6,
        primals_7, primals_8, primals_9, primals_10, primals_11, primals_12,
        primals_13, primals_14, primals_15, primals_16, primals_17,
        primals_18, primals_19, primals_20, primals_21, primals_22,
        primals_23, primals_24, primals_25, primals_26, primals_27,
        primals_28, primals_29, primals_30, primals_31, primals_32,
        primals_33, primals_34, primals_35, primals_36, primals_37,
        primals_38, primals_39, primals_40, primals_41, primals_42,
        primals_43, primals_44, primals_45, primals_46, primals_47,
        primals_48, primals_49, primals_50, primals_51, primals_52,
        primals_53, primals_54, primals_55, primals_56, primals_57,
        primals_58, primals_59, primals_60, primals_61, primals_62,
        primals_63, primals_64, primals_65, primals_66, primals_67,
        primals_68, primals_69, primals_70, primals_71, primals_72,
        primals_73, primals_74, primals_75, primals_76, primals_77,
        primals_78, primals_79, primals_80, primals_81, primals_82,
        primals_83, primals_84, primals_85, primals_86, primals_87,
        primals_88, primals_89, primals_90, primals_91, primals_92,
        primals_93, primals_94, primals_95, primals_96, primals_97,
        primals_98, primals_99, primals_100, primals_101, primals_102,
        primals_103, primals_104, primals_105, primals_106, primals_107,
        primals_108, primals_109, primals_110, primals_111, primals_112,
        primals_113, primals_114, primals_115, primals_116, primals_117,
        primals_118, primals_119, primals_120, primals_121) = args
    args.clear()
    assert_size_stride(primals_1, (256, 3, 7, 7), (147, 49, 7, 1))
    assert_size_stride(primals_2, (4, 3, 64, 64), (12288, 4096, 64, 1))
    assert_size_stride(primals_3, (256,), (1,))
    assert_size_stride(primals_4, (256,), (1,))
    assert_size_stride(primals_5, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_6, (1024,), (1,))
    assert_size_stride(primals_7, (1024,), (1,))
    assert_size_stride(primals_8, (256, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_9, (256,), (1,))
    assert_size_stride(primals_10, (256,), (1,))
    assert_size_stride(primals_11, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_12, (256,), (1,))
    assert_size_stride(primals_13, (256,), (1,))
    assert_size_stride(primals_14, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_15, (1024,), (1,))
    assert_size_stride(primals_16, (1024,), (1,))
    assert_size_stride(primals_17, (256, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_18, (256,), (1,))
    assert_size_stride(primals_19, (256,), (1,))
    assert_size_stride(primals_20, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_21, (256,), (1,))
    assert_size_stride(primals_22, (256,), (1,))
    assert_size_stride(primals_23, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_24, (1024,), (1,))
    assert_size_stride(primals_25, (1024,), (1,))
    assert_size_stride(primals_26, (256, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_27, (256,), (1,))
    assert_size_stride(primals_28, (256,), (1,))
    assert_size_stride(primals_29, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_30, (256,), (1,))
    assert_size_stride(primals_31, (256,), (1,))
    assert_size_stride(primals_32, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_33, (1024,), (1,))
    assert_size_stride(primals_34, (1024,), (1,))
    assert_size_stride(primals_35, (256, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_36, (256,), (1,))
    assert_size_stride(primals_37, (256,), (1,))
    assert_size_stride(primals_38, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_39, (256,), (1,))
    assert_size_stride(primals_40, (256,), (1,))
    assert_size_stride(primals_41, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_42, (1024,), (1,))
    assert_size_stride(primals_43, (1024,), (1,))
    assert_size_stride(primals_44, (2048, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_45, (2048,), (1,))
    assert_size_stride(primals_46, (2048,), (1,))
    assert_size_stride(primals_47, (512, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_48, (512,), (1,))
    assert_size_stride(primals_49, (512,), (1,))
    assert_size_stride(primals_50, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_51, (512,), (1,))
    assert_size_stride(primals_52, (512,), (1,))
    assert_size_stride(primals_53, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_54, (2048,), (1,))
    assert_size_stride(primals_55, (2048,), (1,))
    assert_size_stride(primals_56, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_57, (512,), (1,))
    assert_size_stride(primals_58, (512,), (1,))
    assert_size_stride(primals_59, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_60, (512,), (1,))
    assert_size_stride(primals_61, (512,), (1,))
    assert_size_stride(primals_62, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_63, (2048,), (1,))
    assert_size_stride(primals_64, (2048,), (1,))
    assert_size_stride(primals_65, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_66, (512,), (1,))
    assert_size_stride(primals_67, (512,), (1,))
    assert_size_stride(primals_68, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_69, (512,), (1,))
    assert_size_stride(primals_70, (512,), (1,))
    assert_size_stride(primals_71, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_72, (2048,), (1,))
    assert_size_stride(primals_73, (2048,), (1,))
    assert_size_stride(primals_74, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_75, (512,), (1,))
    assert_size_stride(primals_76, (512,), (1,))
    assert_size_stride(primals_77, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_78, (512,), (1,))
    assert_size_stride(primals_79, (512,), (1,))
    assert_size_stride(primals_80, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_81, (2048,), (1,))
    assert_size_stride(primals_82, (2048,), (1,))
    assert_size_stride(primals_83, (4096, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_84, (4096,), (1,))
    assert_size_stride(primals_85, (4096,), (1,))
    assert_size_stride(primals_86, (1024, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_87, (1024,), (1,))
    assert_size_stride(primals_88, (1024,), (1,))
    assert_size_stride(primals_89, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_90, (1024,), (1,))
    assert_size_stride(primals_91, (1024,), (1,))
    assert_size_stride(primals_92, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_93, (4096,), (1,))
    assert_size_stride(primals_94, (4096,), (1,))
    assert_size_stride(primals_95, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_96, (1024,), (1,))
    assert_size_stride(primals_97, (1024,), (1,))
    assert_size_stride(primals_98, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_99, (1024,), (1,))
    assert_size_stride(primals_100, (1024,), (1,))
    assert_size_stride(primals_101, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_102, (4096,), (1,))
    assert_size_stride(primals_103, (4096,), (1,))
    assert_size_stride(primals_104, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_105, (1024,), (1,))
    assert_size_stride(primals_106, (1024,), (1,))
    assert_size_stride(primals_107, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_108, (1024,), (1,))
    assert_size_stride(primals_109, (1024,), (1,))
    assert_size_stride(primals_110, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_111, (4096,), (1,))
    assert_size_stride(primals_112, (4096,), (1,))
    assert_size_stride(primals_113, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_114, (1024,), (1,))
    assert_size_stride(primals_115, (1024,), (1,))
    assert_size_stride(primals_116, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_117, (1024,), (1,))
    assert_size_stride(primals_118, (1024,), (1,))
    assert_size_stride(primals_119, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_120, (4096,), (1,))
    assert_size_stride(primals_121, (4096,), (1,))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((256, 3, 7, 7), (147, 1, 21, 3), torch.
            float32)
        get_raw_stream(0)
        triton_poi_fused_0[grid(768, 49)](primals_1, buf0, 768, 49, XBLOCK=
            32, YBLOCK=32, num_warps=4, num_stages=1)
        del primals_1
        buf1 = empty_strided_cuda((4, 3, 64, 64), (12288, 1, 192, 3), torch
            .float32)
        triton_poi_fused_1[grid(12, 4096)](primals_2, buf1, 12, 4096,
            XBLOCK=64, YBLOCK=16, num_warps=4, num_stages=1)
        del primals_2
        buf2 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_poi_fused_2[grid(65536, 9)](primals_11, buf2, 65536, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_11
        buf3 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_poi_fused_2[grid(65536, 9)](primals_20, buf3, 65536, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_20
        buf4 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_poi_fused_2[grid(65536, 9)](primals_29, buf4, 65536, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_29
        buf5 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_poi_fused_2[grid(65536, 9)](primals_38, buf5, 65536, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_38
        buf6 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_poi_fused_3[grid(262144, 9)](primals_50, buf6, 262144, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_50
        buf7 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_poi_fused_3[grid(262144, 9)](primals_59, buf7, 262144, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_59
        buf8 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_poi_fused_3[grid(262144, 9)](primals_68, buf8, 262144, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_68
        buf9 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_poi_fused_3[grid(262144, 9)](primals_77, buf9, 262144, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_77
        buf10 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_89, buf10, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_89
        buf11 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_98, buf11, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_98
        buf12 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_107, buf12, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_107
        buf13 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_116, buf13, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_116
        buf15 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf17 = reinterpret_tensor(buf15, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf15
        buf18 = empty_strided_cuda((256, 3, 7, 7), (147, 1, 21, 3), torch.
            float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_5[grid(256)](buf17, buf0,
            buf18, 256, 147, XBLOCK=1, num_warps=2, num_stages=1)
        buf19 = extern_kernels.convolution(buf1, buf18, stride=(2, 2),
            padding=(3, 3), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf19, (4, 256, 32, 32), (262144, 1, 8192, 256))
        buf20 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf21 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf23 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_6[grid(128)](buf19, buf20, buf21,
            buf23, 128, 8192, XBLOCK=1, RBLOCK=2048, num_warps=16, num_stages=1
            )
        buf24 = empty_strided_cuda((4, 256, 32, 32), (262144, 1, 8192, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_7[grid(1048576)](buf19,
            buf20, buf21, primals_3, primals_4, buf24, 1048576, XBLOCK=512,
            num_warps=8, num_stages=1)
        del primals_4
        buf25 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        buf26 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.int8)
        triton_poi_fused_max_pool2d_with_indices_8[grid(230400)](buf24,
            buf25, buf26, 230400, XBLOCK=512, num_warps=8, num_stages=1)
        buf28 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf30 = reinterpret_tensor(buf28, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf28
        buf31 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_9[grid(1024)](buf30,
            primals_5, buf31, 1024, 256, num_warps=2, num_stages=1)
        buf32 = extern_kernels.convolution(buf25, buf31, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf32, (4, 1024, 15, 15), (230400, 1, 15360, 1024))
        buf33 = empty_strided_cuda((4, 1024, 1, 1), (1024, 1, 4096, 4096),
            torch.float32)
        buf34 = empty_strided_cuda((4, 1024, 1, 1), (1024, 1, 4096, 4096),
            torch.float32)
        buf36 = empty_strided_cuda((4, 1024, 1, 1), (1024, 1, 4096, 4096),
            torch.float32)
        triton_per_fused_native_group_norm_10[grid(4096)](buf32, buf33,
            buf34, buf36, 4096, 225, XBLOCK=1, num_warps=2, num_stages=1)
        buf38 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf40 = reinterpret_tensor(buf38, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf38
        buf41 = empty_strided_cuda((256, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_11[grid(256)](buf40,
            primals_8, buf41, 256, 256, num_warps=2, num_stages=1)
        buf42 = extern_kernels.convolution(buf25, buf41, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf42, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf43 = buf21
        del buf21
        buf44 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf46 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf42, buf43,
            buf44, buf46, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf47 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf42,
            buf43, buf44, primals_9, primals_10, buf47, 230400, XBLOCK=1024,
            num_warps=4, num_stages=1)
        del primals_10
        buf49 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf51 = reinterpret_tensor(buf49, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf49
        buf52 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_14[grid(256)](buf51,
            buf2, buf52, 256, 2304, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf53 = extern_kernels.convolution(buf47, buf52, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf53, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf54 = buf44
        del buf44
        buf55 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf57 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf53, buf54,
            buf55, buf57, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf58 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf53,
            buf54, buf55, primals_12, primals_13, buf58, 230400, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_13
        buf60 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf62 = reinterpret_tensor(buf60, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf60
        buf63 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_9[grid(1024)](buf62,
            primals_14, buf63, 1024, 256, num_warps=2, num_stages=1)
        buf64 = extern_kernels.convolution(buf58, buf63, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf64, (4, 1024, 15, 15), (230400, 1, 15360, 1024))
        buf65 = buf55
        del buf55
        buf66 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf68 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf64, buf65,
            buf66, buf68, 128, 7200, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf69 = empty_strided_cuda((4, 1024, 15, 15), (230400, 1, 15360, 
            1024), torch.float32)
        buf70 = buf69
        del buf69
        triton_poi_fused_add_native_group_norm_relu_16[grid(921600)](buf70,
            buf32, buf33, buf34, primals_6, primals_7, buf64, buf65, buf66,
            primals_15, primals_16, 921600, XBLOCK=512, num_warps=8,
            num_stages=1)
        del primals_16
        del primals_7
        buf72 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf74 = reinterpret_tensor(buf72, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf72
        buf75 = empty_strided_cuda((256, 1024, 1, 1), (1024, 1, 1024, 1024),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_17[grid(256)](buf74,
            primals_17, buf75, 256, 1024, num_warps=8, num_stages=1)
        buf76 = extern_kernels.convolution(buf70, buf75, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf76, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf77 = buf66
        del buf66
        buf78 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf80 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf76, buf77,
            buf78, buf80, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf81 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf76,
            buf77, buf78, primals_18, primals_19, buf81, 230400, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_19
        buf83 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf85 = reinterpret_tensor(buf83, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf83
        buf86 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_14[grid(256)](buf85,
            buf3, buf86, 256, 2304, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf87 = extern_kernels.convolution(buf81, buf86, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf87, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf88 = buf78
        del buf78
        buf89 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf91 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf87, buf88,
            buf89, buf91, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf92 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf87,
            buf88, buf89, primals_21, primals_22, buf92, 230400, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_22
        buf94 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf96 = reinterpret_tensor(buf94, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf94
        buf97 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_9[grid(1024)](buf96,
            primals_23, buf97, 1024, 256, num_warps=2, num_stages=1)
        buf98 = extern_kernels.convolution(buf92, buf97, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf98, (4, 1024, 15, 15), (230400, 1, 15360, 1024))
        buf99 = buf89
        del buf89
        buf100 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf102 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf98, buf99,
            buf100, buf102, 128, 7200, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf103 = empty_strided_cuda((4, 1024, 15, 15), (230400, 1, 15360, 
            1024), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_18[grid(921600)](buf70,
            buf98, buf99, buf100, primals_24, primals_25, buf103, 921600,
            XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_25
        buf105 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf107 = reinterpret_tensor(buf105, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf105
        buf108 = empty_strided_cuda((256, 1024, 1, 1), (1024, 1, 1024, 1024
            ), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_17[grid(256)](buf107,
            primals_26, buf108, 256, 1024, num_warps=8, num_stages=1)
        buf109 = extern_kernels.convolution(buf103, buf108, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf109, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf110 = buf100
        del buf100
        buf111 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf113 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf109, buf110,
            buf111, buf113, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf114 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf109,
            buf110, buf111, primals_27, primals_28, buf114, 230400, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_28
        buf116 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf118 = reinterpret_tensor(buf116, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf116
        buf119 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_14[grid(256)](buf118,
            buf4, buf119, 256, 2304, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf120 = extern_kernels.convolution(buf114, buf119, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf120, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf121 = buf111
        del buf111
        buf122 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf124 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf120, buf121,
            buf122, buf124, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf125 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf120,
            buf121, buf122, primals_30, primals_31, buf125, 230400, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_31
        buf127 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf129 = reinterpret_tensor(buf127, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf127
        buf130 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_9[grid(1024)](buf129,
            primals_32, buf130, 1024, 256, num_warps=2, num_stages=1)
        buf131 = extern_kernels.convolution(buf125, buf130, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf131, (4, 1024, 15, 15), (230400, 1, 15360, 1024))
        buf132 = buf122
        del buf122
        buf133 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf135 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf131, buf132,
            buf133, buf135, 128, 7200, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf136 = empty_strided_cuda((4, 1024, 15, 15), (230400, 1, 15360, 
            1024), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_18[grid(921600)](buf103,
            buf131, buf132, buf133, primals_33, primals_34, buf136, 921600,
            XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_34
        buf138 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf140 = reinterpret_tensor(buf138, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf138
        buf141 = empty_strided_cuda((256, 1024, 1, 1), (1024, 1, 1024, 1024
            ), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_17[grid(256)](buf140,
            primals_35, buf141, 256, 1024, num_warps=8, num_stages=1)
        buf142 = extern_kernels.convolution(buf136, buf141, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf142, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf143 = buf133
        del buf133
        buf144 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf146 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf142, buf143,
            buf144, buf146, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf147 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf142,
            buf143, buf144, primals_36, primals_37, buf147, 230400, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_37
        buf149 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf151 = reinterpret_tensor(buf149, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf149
        buf152 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_14[grid(256)](buf151,
            buf5, buf152, 256, 2304, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf153 = extern_kernels.convolution(buf147, buf152, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf153, (4, 256, 15, 15), (57600, 1, 3840, 256))
        buf154 = buf144
        del buf144
        buf155 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf157 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_12[grid(128)](buf153, buf154,
            buf155, buf157, 128, 1800, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf158 = empty_strided_cuda((4, 256, 15, 15), (57600, 1, 3840, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_13[grid(230400)](buf153,
            buf154, buf155, primals_39, primals_40, buf158, 230400, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_40
        buf160 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf162 = reinterpret_tensor(buf160, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf160
        buf163 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_9[grid(1024)](buf162,
            primals_41, buf163, 1024, 256, num_warps=2, num_stages=1)
        buf164 = extern_kernels.convolution(buf158, buf163, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf164, (4, 1024, 15, 15), (230400, 1, 15360, 1024))
        buf165 = buf155
        del buf155
        buf166 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf168 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf164, buf165,
            buf166, buf168, 128, 7200, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf169 = empty_strided_cuda((4, 1024, 15, 15), (230400, 1, 15360, 
            1024), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_18[grid(921600)](buf136,
            buf164, buf165, buf166, primals_42, primals_43, buf169, 921600,
            XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_43
        buf171 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf173 = reinterpret_tensor(buf171, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf171
        buf174 = empty_strided_cuda((2048, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_19[grid(2048)](buf173,
            primals_44, buf174, 2048, 1024, num_warps=8, num_stages=1)
        buf175 = extern_kernels.convolution(buf169, buf174, stride=(2, 2),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf175, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf176 = empty_strided_cuda((4, 2048, 1, 1), (2048, 1, 8192, 8192),
            torch.float32)
        buf177 = empty_strided_cuda((4, 2048, 1, 1), (2048, 1, 8192, 8192),
            torch.float32)
        buf179 = empty_strided_cuda((4, 2048, 1, 1), (2048, 1, 8192, 8192),
            torch.float32)
        triton_per_fused_native_group_norm_20[grid(8192)](buf175, buf176,
            buf177, buf179, 8192, 64, XBLOCK=8, num_warps=4, num_stages=1)
        buf181 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf183 = reinterpret_tensor(buf181, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf181
        buf184 = empty_strided_cuda((512, 1024, 1, 1), (1024, 1, 1024, 1024
            ), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_21[grid(512)](buf183,
            primals_47, buf184, 512, 1024, num_warps=8, num_stages=1)
        buf185 = extern_kernels.convolution(buf169, buf184, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf185, (4, 512, 15, 15), (115200, 1, 7680, 512))
        buf186 = buf166
        del buf166
        buf187 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf189 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_22[grid(128)](buf185, buf186,
            buf187, buf189, 128, 3600, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf190 = empty_strided_cuda((4, 512, 15, 15), (115200, 1, 7680, 512
            ), torch.float32)
        triton_poi_fused_native_group_norm_relu_23[grid(460800)](buf185,
            buf186, buf187, primals_48, primals_49, buf190, 460800, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_49
        buf192 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf194 = reinterpret_tensor(buf192, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf192
        buf195 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_24[grid(512)](buf194,
            buf6, buf195, 512, 4608, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf196 = extern_kernels.convolution(buf190, buf195, stride=(2, 2),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf196, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf197 = buf187
        del buf187
        buf198 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf200 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_25[grid(128)](buf196, buf197,
            buf198, buf200, 128, 1024, num_warps=8, num_stages=1)
        buf201 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_26[grid(131072)](buf196,
            buf197, buf198, primals_51, primals_52, buf201, 131072, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_52
        buf203 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf205 = reinterpret_tensor(buf203, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf203
        buf206 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_27[grid(2048)](buf205,
            primals_53, buf206, 2048, 512, num_warps=4, num_stages=1)
        buf207 = extern_kernels.convolution(buf201, buf206, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf207, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf208 = buf198
        del buf198
        buf209 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf211 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf207, buf208,
            buf209, buf211, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf212 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 
            2048), torch.float32)
        buf213 = buf212
        del buf212
        triton_poi_fused_add_native_group_norm_relu_29[grid(524288)](buf213,
            buf175, buf176, buf177, primals_45, primals_46, buf207, buf208,
            buf209, primals_54, primals_55, 524288, XBLOCK=512, num_warps=8,
            num_stages=1)
        del buf177
        del primals_46
        del primals_55
        buf215 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf217 = reinterpret_tensor(buf215, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf215
        buf218 = empty_strided_cuda((512, 2048, 1, 1), (2048, 1, 2048, 2048
            ), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_30[grid(512)](buf217,
            primals_56, buf218, 512, 2048, XBLOCK=1, RBLOCK=2048, num_warps
            =16, num_stages=1)
        buf219 = extern_kernels.convolution(buf213, buf218, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf219, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf220 = buf209
        del buf209
        buf221 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf223 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_25[grid(128)](buf219, buf220,
            buf221, buf223, 128, 1024, num_warps=8, num_stages=1)
        buf224 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_26[grid(131072)](buf219,
            buf220, buf221, primals_57, primals_58, buf224, 131072, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_58
        buf226 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf228 = reinterpret_tensor(buf226, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf226
        buf229 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_24[grid(512)](buf228,
            buf7, buf229, 512, 4608, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf230 = extern_kernels.convolution(buf224, buf229, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf230, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf231 = buf221
        del buf221
        buf232 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf234 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_25[grid(128)](buf230, buf231,
            buf232, buf234, 128, 1024, num_warps=8, num_stages=1)
        buf235 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_26[grid(131072)](buf230,
            buf231, buf232, primals_60, primals_61, buf235, 131072, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_61
        buf237 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf239 = reinterpret_tensor(buf237, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf237
        buf240 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_27[grid(2048)](buf239,
            primals_62, buf240, 2048, 512, num_warps=4, num_stages=1)
        buf241 = extern_kernels.convolution(buf235, buf240, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf241, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf242 = buf232
        del buf232
        buf243 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf245 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf241, buf242,
            buf243, buf245, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf246 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 
            2048), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_31[grid(524288)](buf213,
            buf241, buf242, buf243, primals_63, primals_64, buf246, 524288,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_64
        buf248 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf250 = reinterpret_tensor(buf248, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf248
        buf251 = empty_strided_cuda((512, 2048, 1, 1), (2048, 1, 2048, 2048
            ), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_30[grid(512)](buf250,
            primals_65, buf251, 512, 2048, XBLOCK=1, RBLOCK=2048, num_warps
            =16, num_stages=1)
        buf252 = extern_kernels.convolution(buf246, buf251, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf252, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf253 = buf243
        del buf243
        buf254 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf256 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_25[grid(128)](buf252, buf253,
            buf254, buf256, 128, 1024, num_warps=8, num_stages=1)
        buf257 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_26[grid(131072)](buf252,
            buf253, buf254, primals_66, primals_67, buf257, 131072, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_67
        buf259 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf261 = reinterpret_tensor(buf259, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf259
        buf262 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_24[grid(512)](buf261,
            buf8, buf262, 512, 4608, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf263 = extern_kernels.convolution(buf257, buf262, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf263, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf264 = buf254
        del buf254
        buf265 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf267 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_25[grid(128)](buf263, buf264,
            buf265, buf267, 128, 1024, num_warps=8, num_stages=1)
        buf268 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_26[grid(131072)](buf263,
            buf264, buf265, primals_69, primals_70, buf268, 131072, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_70
        buf270 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf272 = reinterpret_tensor(buf270, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf270
        buf273 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_27[grid(2048)](buf272,
            primals_71, buf273, 2048, 512, num_warps=4, num_stages=1)
        buf274 = extern_kernels.convolution(buf268, buf273, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf274, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf275 = buf265
        del buf265
        buf276 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf278 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf274, buf275,
            buf276, buf278, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf279 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 
            2048), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_31[grid(524288)](buf246,
            buf274, buf275, buf276, primals_72, primals_73, buf279, 524288,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_73
        buf281 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf283 = reinterpret_tensor(buf281, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf281
        buf284 = empty_strided_cuda((512, 2048, 1, 1), (2048, 1, 2048, 2048
            ), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_30[grid(512)](buf283,
            primals_74, buf284, 512, 2048, XBLOCK=1, RBLOCK=2048, num_warps
            =16, num_stages=1)
        buf285 = extern_kernels.convolution(buf279, buf284, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf285, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf286 = buf276
        del buf276
        buf287 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf289 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_25[grid(128)](buf285, buf286,
            buf287, buf289, 128, 1024, num_warps=8, num_stages=1)
        buf290 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_26[grid(131072)](buf285,
            buf286, buf287, primals_75, primals_76, buf290, 131072, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_76
        buf292 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf294 = reinterpret_tensor(buf292, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf292
        buf295 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_24[grid(512)](buf294,
            buf9, buf295, 512, 4608, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf296 = extern_kernels.convolution(buf290, buf295, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf296, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf297 = buf287
        del buf287
        buf298 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf300 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_25[grid(128)](buf296, buf297,
            buf298, buf300, 128, 1024, num_warps=8, num_stages=1)
        buf301 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_26[grid(131072)](buf296,
            buf297, buf298, primals_78, primals_79, buf301, 131072, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_79
        buf303 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf305 = reinterpret_tensor(buf303, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf303
        buf306 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_27[grid(2048)](buf305,
            primals_80, buf306, 2048, 512, num_warps=4, num_stages=1)
        buf307 = extern_kernels.convolution(buf301, buf306, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf307, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf308 = buf298
        del buf298
        buf309 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf311 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf307, buf308,
            buf309, buf311, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf312 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 
            2048), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_31[grid(524288)](buf279,
            buf307, buf308, buf309, primals_81, primals_82, buf312, 524288,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_82
        buf314 = reinterpret_tensor(buf34, (4096, 1, 1, 1), (1, 4096, 4096,
            4096), 0)
        del buf34
        buf316 = reinterpret_tensor(buf314, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf314
        buf317 = empty_strided_cuda((4096, 2048, 1, 1), (2048, 1, 2048, 
            2048), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_32[grid(4096)](buf316,
            primals_83, buf317, 4096, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf318 = extern_kernels.convolution(buf312, buf317, stride=(2, 2),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf318, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf319 = empty_strided_cuda((4, 4096, 1, 1), (4096, 1, 16384, 16384
            ), torch.float32)
        buf320 = empty_strided_cuda((4, 4096, 1, 1), (4096, 1, 16384, 16384
            ), torch.float32)
        buf322 = empty_strided_cuda((4, 4096, 1, 1), (4096, 1, 16384, 16384
            ), torch.float32)
        triton_per_fused_native_group_norm_33[grid(16384)](buf318, buf319,
            buf320, buf322, 16384, 16, XBLOCK=32, num_warps=4, num_stages=1)
        buf324 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf326 = reinterpret_tensor(buf324, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf324
        buf327 = empty_strided_cuda((1024, 2048, 1, 1), (2048, 1, 2048, 
            2048), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_34[grid(1024)](buf326,
            primals_86, buf327, 1024, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf328 = extern_kernels.convolution(buf312, buf327, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf328, (4, 1024, 8, 8), (65536, 1, 8192, 1024))
        buf329 = buf309
        del buf309
        buf330 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf332 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_35[grid(128)](buf328, buf329,
            buf330, buf332, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf333 = empty_strided_cuda((4, 1024, 8, 8), (65536, 1, 8192, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_36[grid(262144)](buf328,
            buf329, buf330, primals_87, primals_88, buf333, 262144, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_88
        buf335 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf337 = reinterpret_tensor(buf335, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf335
        buf338 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 
            1024), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_37[grid(1024)](buf337,
            buf10, buf338, 1024, 9216, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf339 = extern_kernels.convolution(buf333, buf338, stride=(2, 2),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf339, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf340 = buf330
        del buf330
        buf341 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf343 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_38[grid(128)](buf339, buf340,
            buf341, buf343, 128, 512, num_warps=4, num_stages=1)
        buf344 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_39[grid(65536)](buf339,
            buf340, buf341, primals_90, primals_91, buf344, 65536, XBLOCK=
            512, num_warps=4, num_stages=1)
        del primals_91
        buf346 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf348 = reinterpret_tensor(buf346, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf346
        buf349 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_40[grid(4096)](buf348,
            primals_92, buf349, 4096, 1024, num_warps=8, num_stages=1)
        buf350 = extern_kernels.convolution(buf344, buf349, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf350, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf351 = buf341
        del buf341
        buf352 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf354 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf350, buf351,
            buf352, buf354, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf355 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096
            ), torch.float32)
        buf356 = buf355
        del buf355
        triton_poi_fused_add_native_group_norm_relu_42[grid(262144)](buf356,
            buf318, buf319, buf320, primals_84, primals_85, buf350, buf351,
            buf352, primals_93, primals_94, 262144, XBLOCK=512, num_warps=8,
            num_stages=1)
        del buf320
        del primals_85
        del primals_94
        buf358 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf360 = reinterpret_tensor(buf358, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf358
        buf361 = empty_strided_cuda((1024, 4096, 1, 1), (4096, 1, 4096, 
            4096), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_43[grid(1024)](buf360,
            primals_95, buf361, 1024, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf362 = extern_kernels.convolution(buf356, buf361, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf362, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf363 = buf352
        del buf352
        buf364 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf366 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_38[grid(128)](buf362, buf363,
            buf364, buf366, 128, 512, num_warps=4, num_stages=1)
        buf367 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_39[grid(65536)](buf362,
            buf363, buf364, primals_96, primals_97, buf367, 65536, XBLOCK=
            512, num_warps=4, num_stages=1)
        del primals_97
        buf369 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf371 = reinterpret_tensor(buf369, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf369
        buf372 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 
            1024), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_37[grid(1024)](buf371,
            buf11, buf372, 1024, 9216, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf373 = extern_kernels.convolution(buf367, buf372, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf373, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf374 = buf364
        del buf364
        buf375 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf377 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_38[grid(128)](buf373, buf374,
            buf375, buf377, 128, 512, num_warps=4, num_stages=1)
        buf378 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_39[grid(65536)](buf373,
            buf374, buf375, primals_99, primals_100, buf378, 65536, XBLOCK=
            512, num_warps=4, num_stages=1)
        del primals_100
        buf380 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf382 = reinterpret_tensor(buf380, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf380
        buf383 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_40[grid(4096)](buf382,
            primals_101, buf383, 4096, 1024, num_warps=8, num_stages=1)
        buf384 = extern_kernels.convolution(buf378, buf383, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf384, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf385 = buf375
        del buf375
        buf386 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf388 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf384, buf385,
            buf386, buf388, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf389 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096
            ), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_44[grid(262144)](buf356,
            buf384, buf385, buf386, primals_102, primals_103, buf389, 
            262144, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_103
        buf391 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf393 = reinterpret_tensor(buf391, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf391
        buf394 = empty_strided_cuda((1024, 4096, 1, 1), (4096, 1, 4096, 
            4096), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_43[grid(1024)](buf393,
            primals_104, buf394, 1024, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf395 = extern_kernels.convolution(buf389, buf394, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf395, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf396 = buf386
        del buf386
        buf397 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf399 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_38[grid(128)](buf395, buf396,
            buf397, buf399, 128, 512, num_warps=4, num_stages=1)
        buf400 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_39[grid(65536)](buf395,
            buf396, buf397, primals_105, primals_106, buf400, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_106
        buf402 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf404 = reinterpret_tensor(buf402, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf402
        buf405 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 
            1024), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_37[grid(1024)](buf404,
            buf12, buf405, 1024, 9216, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf406 = extern_kernels.convolution(buf400, buf405, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf406, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf407 = buf397
        del buf397
        buf408 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf410 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_38[grid(128)](buf406, buf407,
            buf408, buf410, 128, 512, num_warps=4, num_stages=1)
        buf411 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_39[grid(65536)](buf406,
            buf407, buf408, primals_108, primals_109, buf411, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_109
        buf413 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf415 = reinterpret_tensor(buf413, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf413
        buf416 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_40[grid(4096)](buf415,
            primals_110, buf416, 4096, 1024, num_warps=8, num_stages=1)
        buf417 = extern_kernels.convolution(buf411, buf416, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf417, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf418 = buf408
        del buf408
        buf419 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf421 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf417, buf418,
            buf419, buf421, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf422 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096
            ), torch.float32)
        triton_poi_fused_add_native_group_norm_relu_44[grid(262144)](buf389,
            buf417, buf418, buf419, primals_111, primals_112, buf422, 
            262144, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_112
        buf424 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf426 = reinterpret_tensor(buf424, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf424
        buf427 = empty_strided_cuda((1024, 4096, 1, 1), (4096, 1, 4096, 
            4096), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_43[grid(1024)](buf426,
            primals_113, buf427, 1024, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf428 = extern_kernels.convolution(buf422, buf427, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf428, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf429 = buf419
        del buf419
        buf430 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf432 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_38[grid(128)](buf428, buf429,
            buf430, buf432, 128, 512, num_warps=4, num_stages=1)
        buf433 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_39[grid(65536)](buf428,
            buf429, buf430, primals_114, primals_115, buf433, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_115
        buf435 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf437 = reinterpret_tensor(buf435, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf435
        buf438 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 
            1024), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_37[grid(1024)](buf437,
            buf13, buf438, 1024, 9216, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf439 = extern_kernels.convolution(buf433, buf438, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf439, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf440 = buf430
        del buf430
        buf441 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf443 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_38[grid(128)](buf439, buf440,
            buf441, buf443, 128, 512, num_warps=4, num_stages=1)
        buf444 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_39[grid(65536)](buf439,
            buf440, buf441, primals_117, primals_118, buf444, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_118
        buf446 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf448 = reinterpret_tensor(buf446, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf446
        buf449 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_40[grid(4096)](buf448,
            primals_119, buf449, 4096, 1024, num_warps=8, num_stages=1)
        buf450 = extern_kernels.convolution(buf444, buf449, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf450, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf451 = buf441
        del buf441
        buf452 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf454 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf450, buf451,
            buf452, buf454, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf455 = empty_strided_cuda((4, 4096, 4, 4), (65536, 16, 4, 1),
            torch.float32)
        triton_poi_fused_add_native_group_norm_relu_45[grid(64, 4096)](buf422,
            buf450, buf451, buf452, primals_120, primals_121, buf455, 64, 
            4096, XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del buf452
        del primals_121
        buf456 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096
            ), torch.bool)
        triton_poi_fused_threshold_backward_46[grid(16384, 16)](buf455,
            buf456, 16384, 16, XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
    return (buf455, buf0, buf1, primals_3, primals_5, primals_6, primals_8,
        primals_9, buf2, primals_12, primals_14, primals_15, primals_17,
        primals_18, buf3, primals_21, primals_23, primals_24, primals_26,
        primals_27, buf4, primals_30, primals_32, primals_33, primals_35,
        primals_36, buf5, primals_39, primals_41, primals_42, primals_44,
        primals_45, primals_47, primals_48, buf6, primals_51, primals_53,
        primals_54, primals_56, primals_57, buf7, primals_60, primals_62,
        primals_63, primals_65, primals_66, buf8, primals_69, primals_71,
        primals_72, primals_74, primals_75, buf9, primals_78, primals_80,
        primals_81, primals_83, primals_84, primals_86, primals_87, buf10,
        primals_90, primals_92, primals_93, primals_95, primals_96, buf11,
        primals_99, primals_101, primals_102, primals_104, primals_105,
        buf12, primals_108, primals_110, primals_111, primals_113,
        primals_114, buf13, primals_117, primals_119, primals_120, buf17,
        buf18, buf19, reinterpret_tensor(buf20, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf23, (4, 32), (32, 1), 0), buf24, buf25, buf26,
        buf30, buf31, buf32, reinterpret_tensor(buf33, (4, 1024), (1024, 1),
        0), reinterpret_tensor(buf36, (4, 1024), (1024, 1), 0), buf40,
        buf41, buf42, reinterpret_tensor(buf43, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf46, (4, 32), (32, 1), 0), buf47, buf51, buf52,
        buf53, reinterpret_tensor(buf54, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf57, (4, 32), (32, 1), 0), buf58, buf62, buf63,
        buf64, reinterpret_tensor(buf65, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf68, (4, 32), (32, 1), 0), buf70, buf74, buf75,
        buf76, reinterpret_tensor(buf77, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf80, (4, 32), (32, 1), 0), buf81, buf85, buf86,
        buf87, reinterpret_tensor(buf88, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf91, (4, 32), (32, 1), 0), buf92, buf96, buf97,
        buf98, reinterpret_tensor(buf99, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf102, (4, 32), (32, 1), 0), buf103, buf107,
        buf108, buf109, reinterpret_tensor(buf110, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf113, (4, 32), (32, 1), 0), buf114, buf118,
        buf119, buf120, reinterpret_tensor(buf121, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf124, (4, 32), (32, 1), 0), buf125, buf129,
        buf130, buf131, reinterpret_tensor(buf132, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf135, (4, 32), (32, 1), 0), buf136, buf140,
        buf141, buf142, reinterpret_tensor(buf143, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf146, (4, 32), (32, 1), 0), buf147, buf151,
        buf152, buf153, reinterpret_tensor(buf154, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf157, (4, 32), (32, 1), 0), buf158, buf162,
        buf163, buf164, reinterpret_tensor(buf165, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf168, (4, 32), (32, 1), 0), buf169, buf173,
        buf174, buf175, reinterpret_tensor(buf176, (4, 2048), (2048, 1), 0),
        reinterpret_tensor(buf179, (4, 2048), (2048, 1), 0), buf183, buf184,
        buf185, reinterpret_tensor(buf186, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf189, (4, 32), (32, 1), 0), buf190, buf194,
        buf195, buf196, reinterpret_tensor(buf197, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf200, (4, 32), (32, 1), 0), buf201, buf205,
        buf206, buf207, reinterpret_tensor(buf208, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf211, (4, 32), (32, 1), 0), buf213, buf217,
        buf218, buf219, reinterpret_tensor(buf220, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf223, (4, 32), (32, 1), 0), buf224, buf228,
        buf229, buf230, reinterpret_tensor(buf231, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf234, (4, 32), (32, 1), 0), buf235, buf239,
        buf240, buf241, reinterpret_tensor(buf242, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf245, (4, 32), (32, 1), 0), buf246, buf250,
        buf251, buf252, reinterpret_tensor(buf253, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf256, (4, 32), (32, 1), 0), buf257, buf261,
        buf262, buf263, reinterpret_tensor(buf264, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf267, (4, 32), (32, 1), 0), buf268, buf272,
        buf273, buf274, reinterpret_tensor(buf275, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf278, (4, 32), (32, 1), 0), buf279, buf283,
        buf284, buf285, reinterpret_tensor(buf286, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf289, (4, 32), (32, 1), 0), buf290, buf294,
        buf295, buf296, reinterpret_tensor(buf297, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf300, (4, 32), (32, 1), 0), buf301, buf305,
        buf306, buf307, reinterpret_tensor(buf308, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf311, (4, 32), (32, 1), 0), buf312, buf316,
        buf317, buf318, reinterpret_tensor(buf319, (4, 4096), (4096, 1), 0),
        reinterpret_tensor(buf322, (4, 4096), (4096, 1), 0), buf326, buf327,
        buf328, reinterpret_tensor(buf329, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf332, (4, 32), (32, 1), 0), buf333, buf337,
        buf338, buf339, reinterpret_tensor(buf340, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf343, (4, 32), (32, 1), 0), buf344, buf348,
        buf349, buf350, reinterpret_tensor(buf351, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf354, (4, 32), (32, 1), 0), buf356, buf360,
        buf361, buf362, reinterpret_tensor(buf363, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf366, (4, 32), (32, 1), 0), buf367, buf371,
        buf372, buf373, reinterpret_tensor(buf374, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf377, (4, 32), (32, 1), 0), buf378, buf382,
        buf383, buf384, reinterpret_tensor(buf385, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf388, (4, 32), (32, 1), 0), buf389, buf393,
        buf394, buf395, reinterpret_tensor(buf396, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf399, (4, 32), (32, 1), 0), buf400, buf404,
        buf405, buf406, reinterpret_tensor(buf407, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf410, (4, 32), (32, 1), 0), buf411, buf415,
        buf416, buf417, reinterpret_tensor(buf418, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf421, (4, 32), (32, 1), 0), buf422, buf426,
        buf427, buf428, reinterpret_tensor(buf429, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf432, (4, 32), (32, 1), 0), buf433, buf437,
        buf438, buf439, reinterpret_tensor(buf440, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf443, (4, 32), (32, 1), 0), buf444, buf448,
        buf449, buf450, reinterpret_tensor(buf451, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf454, (4, 32), (32, 1), 0), buf456)


def conv1x1(cin, cout, stride=1, bias=False):
    return StdConv2d(cin, cout, kernel_size=1, stride=stride, padding=0,
        bias=bias)


def conv3x3(cin, cout, stride=1, groups=1, bias=False):
    return StdConv2d(cin, cout, kernel_size=3, stride=stride, padding=1,
        bias=bias, groups=groups)


def np2th(weights, conv=False):
    """Possibly convert HWIO to OIHW."""
    if conv:
        weights = weights.transpose([3, 2, 0, 1])
    return torch.from_numpy(weights)


class StdConv2d(nn.Conv2d):

    def forward(self, x):
        w = self.weight
        v, m = torch.var_mean(w, dim=[1, 2, 3], keepdim=True, unbiased=False)
        w = (w - m) / torch.sqrt(v + 1e-05)
        return F.conv2d(x, w, self.bias, self.stride, self.padding, self.
            dilation, self.groups)


class PreActBottleneck(nn.Module):
    """Pre-activation (v2) bottleneck block.
    """

    def __init__(self, cin, cout=None, cmid=None, stride=1):
        super().__init__()
        cout = cout or cin
        cmid = cmid or cout // 4
        self.gn1 = nn.GroupNorm(32, cmid, eps=1e-06)
        self.conv1 = conv1x1(cin, cmid, bias=False)
        self.gn2 = nn.GroupNorm(32, cmid, eps=1e-06)
        self.conv2 = conv3x3(cmid, cmid, stride, bias=False)
        self.gn3 = nn.GroupNorm(32, cout, eps=1e-06)
        self.conv3 = conv1x1(cmid, cout, bias=False)
        self.relu = nn.ReLU(inplace=True)
        if stride != 1 or cin != cout:
            self.downsample = conv1x1(cin, cout, stride, bias=False)
            self.gn_proj = nn.GroupNorm(cout, cout)

    def forward(self, x):
        residual = x
        if hasattr(self, 'downsample'):
            residual = self.downsample(x)
            residual = self.gn_proj(residual)
        y = self.relu(self.gn1(self.conv1(x)))
        y = self.relu(self.gn2(self.conv2(y)))
        y = self.gn3(self.conv3(y))
        y = self.relu(residual + y)
        return y

    def load_from(self, weights, n_block, n_unit):
        conv1_weight = np2th(weights[pjoin(n_block, n_unit, 'conv1/kernel')
            ], conv=True)
        conv2_weight = np2th(weights[pjoin(n_block, n_unit, 'conv2/kernel')
            ], conv=True)
        conv3_weight = np2th(weights[pjoin(n_block, n_unit, 'conv3/kernel')
            ], conv=True)
        gn1_weight = np2th(weights[pjoin(n_block, n_unit, 'gn1/scale')])
        gn1_bias = np2th(weights[pjoin(n_block, n_unit, 'gn1/bias')])
        gn2_weight = np2th(weights[pjoin(n_block, n_unit, 'gn2/scale')])
        gn2_bias = np2th(weights[pjoin(n_block, n_unit, 'gn2/bias')])
        gn3_weight = np2th(weights[pjoin(n_block, n_unit, 'gn3/scale')])
        gn3_bias = np2th(weights[pjoin(n_block, n_unit, 'gn3/bias')])
        self.conv1.weight.copy_(conv1_weight)
        self.conv2.weight.copy_(conv2_weight)
        self.conv3.weight.copy_(conv3_weight)
        self.gn1.weight.copy_(gn1_weight.view(-1))
        self.gn1.bias.copy_(gn1_bias.view(-1))
        self.gn2.weight.copy_(gn2_weight.view(-1))
        self.gn2.bias.copy_(gn2_bias.view(-1))
        self.gn3.weight.copy_(gn3_weight.view(-1))
        self.gn3.bias.copy_(gn3_bias.view(-1))
        if hasattr(self, 'downsample'):
            proj_conv_weight = np2th(weights[pjoin(n_block, n_unit,
                'conv_proj/kernel')], conv=True)
            proj_gn_weight = np2th(weights[pjoin(n_block, n_unit,
                'gn_proj/scale')])
            proj_gn_bias = np2th(weights[pjoin(n_block, n_unit,
                'gn_proj/bias')])
            self.downsample.weight.copy_(proj_conv_weight)
            self.gn_proj.weight.copy_(proj_gn_weight.view(-1))
            self.gn_proj.bias.copy_(proj_gn_bias.view(-1))


class ResNetV2New(nn.Module):
    """Implementation of Pre-activation (v2) ResNet mode."""

    def __init__(self, block_units, width_factor):
        super().__init__()
        width = int(64 * width_factor)
        self.width = width
        self.root = nn.Sequential(OrderedDict([('conv', StdConv2d(3, width,
            kernel_size=7, stride=2, bias=False, padding=3)), ('gn', nn.
            GroupNorm(32, width, eps=1e-06)), ('relu', nn.ReLU(inplace=True
            )), ('pool', nn.MaxPool2d(kernel_size=3, stride=2, padding=0))]))
        self.body = nn.Sequential(OrderedDict([('block1', nn.Sequential(
            OrderedDict([('unit1', PreActBottleneck(cin=width, cout=width *
            4, cmid=width))] + [(f'unit{i:d}', PreActBottleneck(cin=width *
            4, cout=width * 4, cmid=width)) for i in range(2, block_units[0
            ] + 1)]))), ('block2', nn.Sequential(OrderedDict([('unit1',
            PreActBottleneck(cin=width * 4, cout=width * 8, cmid=width * 2,
            stride=2))] + [(f'unit{i:d}', PreActBottleneck(cin=width * 8,
            cout=width * 8, cmid=width * 2)) for i in range(2, block_units[
            1] + 1)]))), ('block3', nn.Sequential(OrderedDict([('unit1',
            PreActBottleneck(cin=width * 8, cout=width * 16, cmid=width * 4,
            stride=2))] + [(f'unit{i:d}', PreActBottleneck(cin=width * 16,
            cout=width * 16, cmid=width * 4)) for i in range(2, block_units
            [2] + 1)])))]))

    def forward(self, input_0):
        primals_1 = self.root.conv.weight
        primals_3 = self.root.gn.weight
        primals_4 = self.root.gn.bias
        primals_9 = self.body.block1.unit1.gn1.weight
        primals_10 = self.body.block1.unit1.gn1.bias
        primals_8 = self.body.block1.unit1.conv1.weight
        primals_12 = self.body.block1.unit1.gn2.weight
        primals_13 = self.body.block1.unit1.gn2.bias
        primals_11 = self.body.block1.unit1.conv2.weight
        primals_6 = self.body.block1.unit1.gn3.weight
        primals_7 = self.body.block1.unit1.gn3.bias
        primals_5 = self.body.block1.unit1.conv3.weight
        primals_14 = self.body.block1.unit1.downsample.weight
        primals_15 = self.body.block1.unit1.gn_proj.weight
        primals_16 = self.body.block1.unit1.gn_proj.bias
        primals_18 = self.body.block1.unit2.gn1.weight
        primals_19 = self.body.block1.unit2.gn1.bias
        primals_17 = self.body.block1.unit2.conv1.weight
        primals_21 = self.body.block1.unit2.gn2.weight
        primals_22 = self.body.block1.unit2.gn2.bias
        primals_20 = self.body.block1.unit2.conv2.weight
        primals_24 = self.body.block1.unit2.gn3.weight
        primals_25 = self.body.block1.unit2.gn3.bias
        primals_23 = self.body.block1.unit2.conv3.weight
        primals_27 = self.body.block1.unit3.gn1.weight
        primals_28 = self.body.block1.unit3.gn1.bias
        primals_26 = self.body.block1.unit3.conv1.weight
        primals_30 = self.body.block1.unit3.gn2.weight
        primals_31 = self.body.block1.unit3.gn2.bias
        primals_29 = self.body.block1.unit3.conv2.weight
        primals_33 = self.body.block1.unit3.gn3.weight
        primals_34 = self.body.block1.unit3.gn3.bias
        primals_32 = self.body.block1.unit3.conv3.weight
        primals_36 = self.body.block1.unit4.gn1.weight
        primals_37 = self.body.block1.unit4.gn1.bias
        primals_35 = self.body.block1.unit4.conv1.weight
        primals_39 = self.body.block1.unit4.gn2.weight
        primals_40 = self.body.block1.unit4.gn2.bias
        primals_38 = self.body.block1.unit4.conv2.weight
        primals_42 = self.body.block1.unit4.gn3.weight
        primals_43 = self.body.block1.unit4.gn3.bias
        primals_41 = self.body.block1.unit4.conv3.weight
        primals_48 = self.body.block2.unit1.gn1.weight
        primals_49 = self.body.block2.unit1.gn1.bias
        primals_47 = self.body.block2.unit1.conv1.weight
        primals_51 = self.body.block2.unit1.gn2.weight
        primals_52 = self.body.block2.unit1.gn2.bias
        primals_50 = self.body.block2.unit1.conv2.weight
        primals_45 = self.body.block2.unit1.gn3.weight
        primals_46 = self.body.block2.unit1.gn3.bias
        primals_53 = self.body.block2.unit1.conv3.weight
        primals_44 = self.body.block2.unit1.downsample.weight
        primals_54 = self.body.block2.unit1.gn_proj.weight
        primals_55 = self.body.block2.unit1.gn_proj.bias
        primals_57 = self.body.block2.unit2.gn1.weight
        primals_58 = self.body.block2.unit2.gn1.bias
        primals_56 = self.body.block2.unit2.conv1.weight
        primals_60 = self.body.block2.unit2.gn2.weight
        primals_61 = self.body.block2.unit2.gn2.bias
        primals_59 = self.body.block2.unit2.conv2.weight
        primals_63 = self.body.block2.unit2.gn3.weight
        primals_64 = self.body.block2.unit2.gn3.bias
        primals_62 = self.body.block2.unit2.conv3.weight
        primals_66 = self.body.block2.unit3.gn1.weight
        primals_67 = self.body.block2.unit3.gn1.bias
        primals_65 = self.body.block2.unit3.conv1.weight
        primals_69 = self.body.block2.unit3.gn2.weight
        primals_70 = self.body.block2.unit3.gn2.bias
        primals_68 = self.body.block2.unit3.conv2.weight
        primals_72 = self.body.block2.unit3.gn3.weight
        primals_73 = self.body.block2.unit3.gn3.bias
        primals_71 = self.body.block2.unit3.conv3.weight
        primals_75 = self.body.block2.unit4.gn1.weight
        primals_76 = self.body.block2.unit4.gn1.bias
        primals_74 = self.body.block2.unit4.conv1.weight
        primals_78 = self.body.block2.unit4.gn2.weight
        primals_79 = self.body.block2.unit4.gn2.bias
        primals_77 = self.body.block2.unit4.conv2.weight
        primals_81 = self.body.block2.unit4.gn3.weight
        primals_82 = self.body.block2.unit4.gn3.bias
        primals_80 = self.body.block2.unit4.conv3.weight
        primals_87 = self.body.block3.unit1.gn1.weight
        primals_88 = self.body.block3.unit1.gn1.bias
        primals_86 = self.body.block3.unit1.conv1.weight
        primals_90 = self.body.block3.unit1.gn2.weight
        primals_91 = self.body.block3.unit1.gn2.bias
        primals_89 = self.body.block3.unit1.conv2.weight
        primals_84 = self.body.block3.unit1.gn3.weight
        primals_85 = self.body.block3.unit1.gn3.bias
        primals_92 = self.body.block3.unit1.conv3.weight
        primals_83 = self.body.block3.unit1.downsample.weight
        primals_93 = self.body.block3.unit1.gn_proj.weight
        primals_94 = self.body.block3.unit1.gn_proj.bias
        primals_96 = self.body.block3.unit2.gn1.weight
        primals_97 = self.body.block3.unit2.gn1.bias
        primals_95 = self.body.block3.unit2.conv1.weight
        primals_99 = self.body.block3.unit2.gn2.weight
        primals_100 = self.body.block3.unit2.gn2.bias
        primals_98 = self.body.block3.unit2.conv2.weight
        primals_102 = self.body.block3.unit2.gn3.weight
        primals_103 = self.body.block3.unit2.gn3.bias
        primals_101 = self.body.block3.unit2.conv3.weight
        primals_105 = self.body.block3.unit3.gn1.weight
        primals_106 = self.body.block3.unit3.gn1.bias
        primals_104 = self.body.block3.unit3.conv1.weight
        primals_108 = self.body.block3.unit3.gn2.weight
        primals_109 = self.body.block3.unit3.gn2.bias
        primals_107 = self.body.block3.unit3.conv2.weight
        primals_111 = self.body.block3.unit3.gn3.weight
        primals_112 = self.body.block3.unit3.gn3.bias
        primals_110 = self.body.block3.unit3.conv3.weight
        primals_114 = self.body.block3.unit4.gn1.weight
        primals_115 = self.body.block3.unit4.gn1.bias
        primals_113 = self.body.block3.unit4.conv1.weight
        primals_117 = self.body.block3.unit4.gn2.weight
        primals_118 = self.body.block3.unit4.gn2.bias
        primals_116 = self.body.block3.unit4.conv2.weight
        primals_120 = self.body.block3.unit4.gn3.weight
        primals_121 = self.body.block3.unit4.gn3.bias
        primals_119 = self.body.block3.unit4.conv3.weight
        primals_2 = input_0
        output = call([primals_1, primals_2, primals_3, primals_4,
            primals_5, primals_6, primals_7, primals_8, primals_9,
            primals_10, primals_11, primals_12, primals_13, primals_14,
            primals_15, primals_16, primals_17, primals_18, primals_19,
            primals_20, primals_21, primals_22, primals_23, primals_24,
            primals_25, primals_26, primals_27, primals_28, primals_29,
            primals_30, primals_31, primals_32, primals_33, primals_34,
            primals_35, primals_36, primals_37, primals_38, primals_39,
            primals_40, primals_41, primals_42, primals_43, primals_44,
            primals_45, primals_46, primals_47, primals_48, primals_49,
            primals_50, primals_51, primals_52, primals_53, primals_54,
            primals_55, primals_56, primals_57, primals_58, primals_59,
            primals_60, primals_61, primals_62, primals_63, primals_64,
            primals_65, primals_66, primals_67, primals_68, primals_69,
            primals_70, primals_71, primals_72, primals_73, primals_74,
            primals_75, primals_76, primals_77, primals_78, primals_79,
            primals_80, primals_81, primals_82, primals_83, primals_84,
            primals_85, primals_86, primals_87, primals_88, primals_89,
            primals_90, primals_91, primals_92, primals_93, primals_94,
            primals_95, primals_96, primals_97, primals_98, primals_99,
            primals_100, primals_101, primals_102, primals_103, primals_104,
            primals_105, primals_106, primals_107, primals_108, primals_109,
            primals_110, primals_111, primals_112, primals_113, primals_114,
            primals_115, primals_116, primals_117, primals_118, primals_119,
            primals_120, primals_121])
        return output[0]


Measured latency_ms: 0.037364