# AOT ID: ['0_forward']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _align as align
from torch import device, empty_strided
from torch._inductor.async_compile import AsyncCompile
from torch._inductor.select_algorithm import extern_kernels
from torch._inductor.codegen.multi_kernel import MultiKernelCall
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid, split_scan_grid, grid_combo_kernels, start_graph, end_graph
from torch._C import _cuda_getCurrentRawStream as get_raw_stream

aten = torch.ops.aten
inductor_ops = torch.ops.inductor
_quantized = torch.ops._quantized
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cpu = torch._C._dynamo.guards._empty_strided_cpu
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
empty_strided_xpu = torch._C._dynamo.guards._empty_strided_xpu
reinterpret_tensor = torch._C._dynamo.guards._reinterpret_tensor
alloc_from_pool = torch.ops.inductor._alloc_from_pool
async_compile = AsyncCompile()


# kernel path: runs/run_shard_4/inductor_cache/a2/ca2l7bjxfwrklzvcxfa2hnyzqh3p6neak37vi6fkugdhbu26fbpz.py
# Unsorted Source Nodes: [], Original ATen: []
# Source node to ATen node mapping:
triton_poi_fused_0 = async_compile.triton('triton_poi_fused_0', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[1024, 64], tile_hint=TileHint.SQUARE,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_0', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/5b/c5brnjme4e4oybuabwsko4vuljormwjqoawce7jgxo5fbkhzx55r.py
# Unsorted Source Nodes: [], Original ATen: []
# Source node to ATen node mapping:
triton_poi_fused_1 = async_compile.triton('triton_poi_fused_1', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[16, 4096], tile_hint=TileHint.SQUARE,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 3), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_1', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_1(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK : tl.constexpr, XBLOCK : tl.constexpr):
    ynumel = 12
    xnumel = 4096
    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 = 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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/co/ccosum7u5lx5fx5hf5opofiygxj2ntiq67yo5gfegevmhtkaru4r.py
# Unsorted Source Nodes: [], Original ATen: []
# Source node to ATen node mapping:
triton_poi_fused_2 = async_compile.triton('triton_poi_fused_2', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[65536, 16], tile_hint=TileHint.SQUARE,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_2', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_2(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK : tl.constexpr, XBLOCK : tl.constexpr):
    ynumel = 65536
    xnumel = 9
    yoffset = (tl.program_id(1) + tl.program_id(2) * tl.num_programs(1)) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    ymask = 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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/qg/cqg4z653mpzmif22rwtpmv42y4lbkkxhxjqguwoxl3wb6cn5fn7k.py
# Unsorted Source Nodes: [], Original ATen: []
# Source node to ATen node mapping:
triton_poi_fused_3 = async_compile.triton('triton_poi_fused_3', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144, 16], tile_hint=TileHint.SQUARE,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_3', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_3(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK : tl.constexpr, XBLOCK : tl.constexpr):
    ynumel = 262144
    xnumel = 9
    yoffset = (tl.program_id(1) + tl.program_id(2) * tl.num_programs(1)) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    ymask = 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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/ot/cotn5a2cqhwvdw4ugt6b2a4jl2ou2mh37mnmwxgwogdqw4kcufhp.py
# Unsorted Source Nodes: [], Original ATen: []
# Source node to ATen node mapping:
triton_poi_fused_4 = async_compile.triton('triton_poi_fused_4', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[1048576, 16], tile_hint=TileHint.SQUARE,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_4', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_4(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK : tl.constexpr, XBLOCK : tl.constexpr):
    ynumel = 1048576
    xnumel = 9
    yoffset = (tl.program_id(1) + tl.program_id(2) * tl.num_programs(1)) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    ymask = 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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/7n/c7npfx4cng24bae4uqu2hpgblpis6j6mmnvhinuzjms74o3kespg.py
# Unsorted Source Nodes: [], Original ATen: []
# Source node to ATen node mapping:
triton_poi_fused_5 = async_compile.triton('triton_poi_fused_5', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[4194304, 16], tile_hint=TileHint.SQUARE,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_5', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_5(in_ptr0, out_ptr0, ynumel, xnumel, YBLOCK : tl.constexpr, XBLOCK : tl.constexpr):
    ynumel = 4194304
    xnumel = 9
    yoffset = (tl.program_id(1) + tl.program_id(2) * tl.num_programs(1)) * YBLOCK
    yindex = yoffset + tl.arange(0, YBLOCK)[None, :]
    ymask = 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 % 2048
    y1 = (yindex // 2048)
    tmp0 = tl.load(in_ptr0 + (x2 + (9*y3)), xmask, eviction_policy='evict_last')
    tl.store(out_ptr0 + (y0 + (2048*x2) + (18432*y1)), tmp0, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/ck/cck257ksuszi7rylew7fge2srrwr6phqjm3wbowg7merkmnxmshd.py
# Topologically Sorted Source Nodes: [var_mean, sub, add, sqrt, w], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add => add
#   sqrt => sqrt
#   sub => sub
#   var_mean => var_mean
#   w => div
# Graph fragment:
#   %var_mean : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_1, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_1, %getitem_1), kwargs = {})
#   %add : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem, 1e-10), kwargs = {})
#   %sqrt : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add,), kwargs = {})
#   %div : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub, %sqrt), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_6 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_6', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[256, 256],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_6', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_6(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, :]
    roffset = 0
    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])
    tmp3 = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/nt/cntsn7m3r2xjxa4wdf4m34w7p5wrpvazgixessnri35z7hkzioyv.py
# Topologically Sorted Source Nodes: [input_2], Original ATen: [aten.constant_pad_nd]
# Source node to ATen node mapping:
#   input_2 => constant_pad_nd
# Graph fragment:
#   %constant_pad_nd : [num_users=2] = call_function[target=torch.ops.aten.constant_pad_nd.default](args = (%convolution, [1, 1, 1, 1], 0.0), kwargs = {})
triton_poi_fused_constant_pad_nd_7 = async_compile.triton('triton_poi_fused_constant_pad_nd_7', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[2097152], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_constant_pad_nd_7', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_constant_pad_nd_7(in_ptr0, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 1183744
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x2 = (xindex // 8704) % 34
    x1 = (xindex // 256) % 34
    x3 = (xindex // 295936)
    x4 = xindex % 8704
    x6 = xindex
    tmp0 = (-1) + x2
    tmp1 = tl.full([1], 0, tl.int64)
    tmp2 = tmp0 >= tmp1
    tmp3 = tl.full([1], 32, tl.int64)
    tmp4 = tmp0 < tmp3
    tmp5 = (-1) + x1
    tmp6 = tmp5 >= tmp1
    tmp7 = tmp5 < tmp3
    tmp8 = tmp2 & tmp4
    tmp9 = tmp8 & tmp6
    tmp10 = tmp9 & tmp7
    tmp11 = tl.load(in_ptr0 + ((-8448) + x4 + (8192*x2) + (262144*x3)), tmp10, other=0.0)
    tl.store(out_ptr0 + (x6), tmp11, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/bf/cbf5dxwqyr3hqcx4qflqp4smyzjh74okbtbp3q4x6lxhqo5bx6kt.py
# Topologically Sorted Source Nodes: [input_3], Original ATen: [aten.max_pool2d_with_indices]
# Source node to ATen node mapping:
#   input_3 => getitem_2, getitem_3
# Graph fragment:
#   %getitem_2 : [num_users=2] = call_function[target=operator.getitem](args = (%_low_memory_max_pool2d_with_offsets, 0), kwargs = {})
#   %getitem_3 : [num_users=1] = call_function[target=operator.getitem](args = (%_low_memory_max_pool2d_with_offsets, 1), kwargs = {})
triton_poi_fused_max_pool2d_with_indices_8 = async_compile.triton('triton_poi_fused_max_pool2d_with_indices_8', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*i8', 3: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_max_pool2d_with_indices_8', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 9, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_max_pool2d_with_indices_8(in_ptr0, out_ptr0, out_ptr1, xnumel, XBLOCK : tl.constexpr):
    xnumel = 262144
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex % 256
    x1 = (xindex // 256) % 16
    x2 = (xindex // 4096) % 16
    x3 = (xindex // 65536)
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp1 = tl.load(in_ptr0 + (256 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp3 = tl.load(in_ptr0 + (512 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp5 = tl.load(in_ptr0 + (8704 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp7 = tl.load(in_ptr0 + (8960 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp9 = tl.load(in_ptr0 + (9216 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp11 = tl.load(in_ptr0 + (17408 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp13 = tl.load(in_ptr0 + (17664 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    tmp15 = tl.load(in_ptr0 + (17920 + x0 + (512*x1) + (17408*x2) + (295936*x3)), None)
    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, None)
    tl.store(out_ptr1 + (x4), tmp41, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/v6/cv6xitrbrydxmqmrppdwzu4z4evlalp2yvk4c5vppkczm3j3ligg.py
# Topologically Sorted Source Nodes: [group_norm], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm => add_1, rsqrt, var_mean_1
# Graph fragment:
#   %var_mean_1 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_1 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_4, 1e-05), kwargs = {})
#   %rsqrt : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_1,), kwargs = {})
triton_red_fused_native_group_norm_9 = async_compile.triton('triton_red_fused_native_group_norm_9', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[128, 2048],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_native_group_norm_9', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_native_group_norm_9(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 % 8
        r3 = (rindex // 8)
        tmp0 = tl.load(in_ptr0 + (r2 + (8*x0) + (256*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 = 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + (x4), tmp9, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/fa/cfasmvqd2wokec24hd5leef4rosb4wbws23u3moszdu6v4nwesae.py
# Topologically Sorted Source Nodes: [group_norm, out], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm => add_2, mul_1
#   out => relu
# Graph fragment:
#   %mul_1 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_1, %unsqueeze_5), kwargs = {})
#   %add_2 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_1, %unsqueeze_2), kwargs = {})
#   %relu : [num_users=3] = call_function[target=torch.ops.aten.relu.default](args = (%add_2,), kwargs = {})
triton_poi_fused_native_group_norm_relu_10 = async_compile.triton('triton_poi_fused_native_group_norm_relu_10', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_10', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_10(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 262144
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 256
    x2 = (xindex // 65536)
    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 = 2048.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/7p/c7p6yuwjc2qmdlwhk2ntbb3enj6br3kuvouoikxqtnwnwwyibm2m.py
# Topologically Sorted Source Nodes: [var_mean_1, sub_1, add_1, sqrt_1, w_1], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_1 => add_3
#   sqrt_1 => sqrt_1
#   sub_1 => sub_2
#   var_mean_1 => var_mean_2
#   w_1 => div_1
# Graph fragment:
#   %var_mean_2 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_5, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_2 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_5, %getitem_7), kwargs = {})
#   %add_3 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_6, 1e-10), kwargs = {})
#   %sqrt_1 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_3,), kwargs = {})
#   %div_1 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_2, %sqrt_1), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_11 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_11', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[1024, 256],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_11', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_11(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel):
    xnumel = 1024
    XBLOCK: tl.constexpr = 1
    rnumel = 256
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/hy/chyilz3henugk2yh7bv56i2xnaqemzqpl6po2ro6wijtbh46vtdh.py
# Topologically Sorted Source Nodes: [var_mean_2, sub_2, add_2, sqrt_2, w_2], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_2 => add_4
#   sqrt_2 => sqrt_2
#   sub_2 => sub_3
#   var_mean_2 => var_mean_3
#   w_2 => div_2
# Graph fragment:
#   %var_mean_3 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_6, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_3 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_6, %getitem_9), kwargs = {})
#   %add_4 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_8, 1e-10), kwargs = {})
#   %sqrt_2 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_4,), kwargs = {})
#   %div_2 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_3, %sqrt_2), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_12 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_12', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[256, 256],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_12', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_12(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel):
    xnumel = 256
    XBLOCK: tl.constexpr = 1
    rnumel = 256
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/3y/c3yxgcofabvzf5b3eonlvvlvp5hq7inszok367sxc2uhnt62smgv.py
# Topologically Sorted Source Nodes: [out_2], Original ATen: [aten.convolution]
# Source node to ATen node mapping:
#   out_2 => convolution_3
# Graph fragment:
#   %convolution_3 : [num_users=2] = call_function[target=torch.ops.aten.convolution.default](args = (%relu_1, %primals_9, %primals_10, [1, 1], [1, 1], [1, 1], False, [0, 0], 1), kwargs = {})
triton_poi_fused_convolution_13 = async_compile.triton('triton_poi_fused_convolution_13', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_convolution_13', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_convolution_13(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 262144
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 256
    tmp0 = tl.load(in_out_ptr0 + (x2), None)
    tmp1 = tl.load(in_ptr0 + (x0), None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x2), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/fl/cflhmffcentzihxd2lm4f4c7jl6bncsabeh44cewr2fojudyc2k4.py
# Topologically Sorted Source Nodes: [input_4], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_4 => add_10
# Graph fragment:
#   %add_10 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_4, %convolution_1), kwargs = {})
triton_poi_fused_add_14 = async_compile.triton('triton_poi_fused_add_14', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[1048576], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_14', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_14(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 1048576
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (x0), None)
    tmp1 = tl.load(in_out_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/si/csiiojtlgokw2jw42ubk2xbgw5jlgcxayafs3q7zswsfedxizwoc.py
# Topologically Sorted Source Nodes: [group_norm_3], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_3 => add_11, rsqrt_3, var_mean_7
# Graph fragment:
#   %var_mean_7 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_6, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_11 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_16, 1e-05), kwargs = {})
#   %rsqrt_3 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_11,), kwargs = {})
triton_red_fused_native_group_norm_15 = async_compile.triton('triton_red_fused_native_group_norm_15', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[128, 8192],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_native_group_norm_15', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@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 = 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 % 32
        r3 = (rindex // 32)
        tmp0 = tl.load(in_ptr0 + (r2 + (32*x0) + (1024*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 = 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + (x4), tmp9, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/pq/cpqmt4ehbn6is274yejx4zty2dzaa7qy7b6yhnpuy3tx6223wuua.py
# Topologically Sorted Source Nodes: [group_norm_3, out_4], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_3 => add_12, mul_7
#   out_4 => relu_3
# Graph fragment:
#   %mul_7 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_7, %unsqueeze_23), kwargs = {})
#   %add_12 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_7, %unsqueeze_20), kwargs = {})
#   %relu_3 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_12,), kwargs = {})
triton_poi_fused_native_group_norm_relu_16 = async_compile.triton('triton_poi_fused_native_group_norm_relu_16', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[1048576], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_16', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_16(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 1048576
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 1024
    x2 = (xindex // 262144)
    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 = 8192.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/rf/crfnkyefyns5oxfvn3xcagl2davuc4ecbrrklayhwc5y4v54ackv.py
# Topologically Sorted Source Nodes: [var_mean_4, sub_4, add_5, sqrt_4, w_4], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_5 => add_13
#   sqrt_4 => sqrt_4
#   sub_4 => sub_8
#   var_mean_4 => var_mean_8
#   w_4 => div_4
# Graph fragment:
#   %var_mean_8 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_16, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_8 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_16, %getitem_19), kwargs = {})
#   %add_13 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_18, 1e-10), kwargs = {})
#   %sqrt_4 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_13,), kwargs = {})
#   %div_4 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_8, %sqrt_4), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_17 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_17', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[256, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_17', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_17(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel):
    xnumel = 256
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/2i/c2iroi5tyq6bdv2nnl6vpicnvrvjqphovygeuprbla3wfoavamb7.py
# Topologically Sorted Source Nodes: [input_5], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_5 => add_19
# Graph fragment:
#   %add_19 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_7, %add_10), kwargs = {})
triton_poi_fused_add_18 = async_compile.triton('triton_poi_fused_add_18', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[1048576], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_18', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_18(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 1048576
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + (x0), None)
    tmp1 = tl.load(in_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/6a/c6aj2cpzdg3dhbfhkkua4xiwtcie4yfjb4mh66com5kropbmjwni.py
# Topologically Sorted Source Nodes: [var_mean_10, sub_10, add_14, sqrt_10, w_10], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_14 => add_40
#   sqrt_10 => sqrt_10
#   sub_10 => sub_23
#   var_mean_10 => var_mean_23
#   w_10 => div_10
# Graph fragment:
#   %var_mean_23 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_46, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_23 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_46, %getitem_49), kwargs = {})
#   %add_40 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_48, 1e-10), kwargs = {})
#   %sqrt_10 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_40,), kwargs = {})
#   %div_10 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_23, %sqrt_10), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_19 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_19', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[2048, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_19', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_19(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel):
    xnumel = 2048
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/o6/co6t5ttpyhicnphta2nl3sop7ipjogaapb57hy7c7z6oibxmwpd7.py
# Topologically Sorted Source Nodes: [var_mean_11, sub_11, add_15, sqrt_11, w_11], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_15 => add_41
#   sqrt_11 => sqrt_11
#   sub_11 => sub_24
#   var_mean_11 => var_mean_24
#   w_11 => div_11
# Graph fragment:
#   %var_mean_24 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_47, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_24 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_47, %getitem_51), kwargs = {})
#   %add_41 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_50, 1e-10), kwargs = {})
#   %sqrt_11 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_41,), kwargs = {})
#   %div_11 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_24, %sqrt_11), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_20 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_20', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[512, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_20', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_20(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel):
    xnumel = 512
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/am/cam45fkuyx7dbg52ucmhl65jnrvcnlo7pyx6a2j5lvsd5bviopuj.py
# Topologically Sorted Source Nodes: [group_norm_13], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_13 => add_42, rsqrt_13, var_mean_25
# Graph fragment:
#   %var_mean_25 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_26, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_42 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_52, 1e-05), kwargs = {})
#   %rsqrt_13 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_42,), kwargs = {})
triton_red_fused_native_group_norm_21 = async_compile.triton('triton_red_fused_native_group_norm_21', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[128, 4096],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_native_group_norm_21', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_native_group_norm_21(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 % 16
        r3 = (rindex // 16)
        tmp0 = tl.load(in_ptr0 + (r2 + (16*x0) + (512*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 = 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + (x4), tmp9, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/fy/cfy57czzc2qkjv6pjz77rgn32p5crruqb55nl4xixwalsbs5mwei.py
# Topologically Sorted Source Nodes: [group_norm_13, relu_13], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_13 => add_43, mul_27
#   relu_13 => relu_13
# Graph fragment:
#   %mul_27 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_27, %unsqueeze_83), kwargs = {})
#   %add_43 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_27, %unsqueeze_80), kwargs = {})
#   %relu_13 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_43,), kwargs = {})
triton_poi_fused_native_group_norm_relu_22 = async_compile.triton('triton_poi_fused_native_group_norm_relu_22', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[524288], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_22', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_22(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 524288
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 512
    x2 = (xindex // 131072)
    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 = 4096.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/rn/crns2mhxlz3fmf3u6euptei4k75a2kpn32faj6chx5qgflid5c6b.py
# Topologically Sorted Source Nodes: [out_18], Original ATen: [aten.convolution]
# Source node to ATen node mapping:
#   out_18 => convolution_16
# Graph fragment:
#   %convolution_16 : [num_users=2] = call_function[target=torch.ops.aten.convolution.default](args = (%relu_13, %primals_50, %primals_51, [2, 2], [1, 1], [1, 1], False, [0, 0], 1), kwargs = {})
triton_poi_fused_convolution_23 = async_compile.triton('triton_poi_fused_convolution_23', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[131072], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_convolution_23', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_convolution_23(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 131072
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 512
    tmp0 = tl.load(in_out_ptr0 + (x2), None)
    tmp1 = tl.load(in_ptr0 + (x0), None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x2), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/7q/c7qjvpiszscw2ipcio4ffhrmgfbubit4radh6syg4zqvckqbz52z.py
# Topologically Sorted Source Nodes: [group_norm_14], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_14 => add_44, rsqrt_14, var_mean_26
# Graph fragment:
#   %var_mean_26 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_28, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_44 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_54, 1e-05), kwargs = {})
#   %rsqrt_14 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_44,), kwargs = {})
triton_per_fused_native_group_norm_24 = async_compile.triton('triton_per_fused_native_group_norm_24', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[128, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_native_group_norm_24', 'mutated_arg_names': [], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_native_group_norm_24(in_ptr0, out_ptr0, out_ptr1, out_ptr2, xnumel, rnumel):
    xnumel = 128
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/ad/cadjzg3pzepovud42t5i6gbftlolabw3fp27unoow5hoyvjliyaa.py
# Topologically Sorted Source Nodes: [group_norm_14, relu_14], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_14 => add_45, mul_29
#   relu_14 => relu_14
# Graph fragment:
#   %mul_29 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_29, %unsqueeze_89), kwargs = {})
#   %add_45 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_29, %unsqueeze_86), kwargs = {})
#   %relu_14 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_45,), kwargs = {})
triton_poi_fused_native_group_norm_relu_25 = async_compile.triton('triton_poi_fused_native_group_norm_relu_25', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[131072], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_25', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_25(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 131072
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/mr/cmru36jvazn4nvftmbz3p4esd55x5bjsn5arm2fs34ru32eusb5g.py
# Topologically Sorted Source Nodes: [var_mean_12, sub_12, add_16, sqrt_12, w_12], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_16 => add_46
#   sqrt_12 => sqrt_12
#   sub_12 => sub_27
#   var_mean_12 => var_mean_27
#   w_12 => div_12
# Graph fragment:
#   %var_mean_27 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_54, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_27 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_54, %getitem_57), kwargs = {})
#   %add_46 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_56, 1e-10), kwargs = {})
#   %sqrt_12 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_46,), kwargs = {})
#   %div_12 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_27, %sqrt_12), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_26 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_26', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[2048, 512],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_26', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_26(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel):
    xnumel = 2048
    XBLOCK: tl.constexpr = 1
    rnumel = 512
    RBLOCK: tl.constexpr = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/2c/c2c52oqydx2qqnye3ms2nhtnjykxyv6xutsiklmey66ax3u3kxre.py
# Topologically Sorted Source Nodes: [input_8], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_8 => add_47
# Graph fragment:
#   %add_47 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_17, %convolution_14), kwargs = {})
triton_poi_fused_add_27 = async_compile.triton('triton_poi_fused_add_27', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[524288], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_27', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_27(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 524288
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (x0), None)
    tmp1 = tl.load(in_out_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/bz/cbzasy4ze2re4vldncooexegruzzqnk6h26e2lq65kivzh26krpx.py
# Topologically Sorted Source Nodes: [group_norm_15], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_15 => add_48, rsqrt_15, var_mean_28
# Graph fragment:
#   %var_mean_28 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_30, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_48 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_58, 1e-05), kwargs = {})
#   %rsqrt_15 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_48,), kwargs = {})
triton_red_fused_native_group_norm_28 = async_compile.triton('triton_red_fused_native_group_norm_28', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[128, 4096],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_native_group_norm_28', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@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 = 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + (x4), tmp9, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/ai/caiz2ipqaqy3yvfxd23r6kgede3xfyove4vfzoze622iyk6yxnob.py
# Topologically Sorted Source Nodes: [group_norm_15, out_20], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_15 => add_49, mul_31
#   out_20 => relu_15
# Graph fragment:
#   %mul_31 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_31, %unsqueeze_95), kwargs = {})
#   %add_49 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_31, %unsqueeze_92), kwargs = {})
#   %relu_15 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_49,), kwargs = {})
triton_poi_fused_native_group_norm_relu_29 = async_compile.triton('triton_poi_fused_native_group_norm_relu_29', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[524288], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_29', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_29(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 524288
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = 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 + ((32*x2) + (x0 // 64)), None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + ((32*x2) + (x0 // 64)), 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 = 4096.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/q7/cq7qfvsx4rl6ppxrincqirqseiykkhanw5f6ciztpudikgkuztk7.py
# Topologically Sorted Source Nodes: [var_mean_13, sub_13, add_18, sqrt_13, w_13], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_18 => add_50
#   sqrt_13 => sqrt_13
#   sub_13 => sub_29
#   var_mean_13 => var_mean_29
#   w_13 => div_13
# Graph fragment:
#   %var_mean_29 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_57, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_29 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_57, %getitem_61), kwargs = {})
#   %add_50 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_60, 1e-10), kwargs = {})
#   %sqrt_13 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_50,), kwargs = {})
#   %div_13 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_29, %sqrt_13), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_30 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_30', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[512, 2048],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_30', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@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 = tmp4_tmp[:, None]
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/46/c46uzwtkm72q554z66kfflo66d3jxej542mlrkn5kejeivkb77fl.py
# Topologically Sorted Source Nodes: [input_9], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_9 => add_56
# Graph fragment:
#   %add_56 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_20, %add_47), kwargs = {})
triton_poi_fused_add_31 = async_compile.triton('triton_poi_fused_add_31', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[524288], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_31', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_31(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 524288
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + (x0), None)
    tmp1 = tl.load(in_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/kt/cktrt7d4uohqooff3hbktlyw3jxflx7srzvymlnrkdul5brzhp4v.py
# Topologically Sorted Source Nodes: [var_mean_19, sub_19, add_27, sqrt_19, w_19], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_27 => add_77
#   sqrt_19 => sqrt_19
#   sub_19 => sub_44
#   var_mean_19 => var_mean_44
#   w_19 => div_19
# Graph fragment:
#   %var_mean_44 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_87, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_44 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_87, %getitem_91), kwargs = {})
#   %add_77 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_90, 1e-10), kwargs = {})
#   %sqrt_19 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_77,), kwargs = {})
#   %div_19 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_44, %sqrt_19), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_32 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_32', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[4096, 2048],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_32', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@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):
    xnumel = 4096
    rnumel = 2048
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = 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 = tmp4_tmp[:, None]
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/2p/c2pa75h6vcympkonevngx7jgya3va4wrjf32c2j6odcqubxn55kq.py
# Topologically Sorted Source Nodes: [var_mean_20, sub_20, add_28, sqrt_20, w_20], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_28 => add_78
#   sqrt_20 => sqrt_20
#   sub_20 => sub_45
#   var_mean_20 => var_mean_45
#   w_20 => div_20
# Graph fragment:
#   %var_mean_45 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_88, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_45 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_88, %getitem_93), kwargs = {})
#   %add_78 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_92, 1e-10), kwargs = {})
#   %sqrt_20 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_78,), kwargs = {})
#   %div_20 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_45, %sqrt_20), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_33 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_33', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[1024, 2048],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_33', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_33(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 = tmp4_tmp[:, None]
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/pk/cpkn7dyjdvgjdsd22adrasuzoh2m2mcmlbhqoa355to4spbmfc6o.py
# Topologically Sorted Source Nodes: [group_norm_25], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_25 => add_79, rsqrt_25, var_mean_46
# Graph fragment:
#   %var_mean_46 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_50, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_79 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_94, 1e-05), kwargs = {})
#   %rsqrt_25 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_79,), kwargs = {})
triton_red_fused_native_group_norm_34 = async_compile.triton('triton_red_fused_native_group_norm_34', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[128, 2048],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_native_group_norm_34', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_native_group_norm_34(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 = 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + (x4), tmp9, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/do/cdosiy5sv6smtosgbknn2mualigm45xk4rnnmiei2dbhnr6jbcyh.py
# Topologically Sorted Source Nodes: [group_norm_25, relu_25], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_25 => add_80, mul_51
#   relu_25 => relu_25
# Graph fragment:
#   %mul_51 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_51, %unsqueeze_155), kwargs = {})
#   %add_80 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_51, %unsqueeze_152), kwargs = {})
#   %relu_25 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_80,), kwargs = {})
triton_poi_fused_native_group_norm_relu_35 = async_compile.triton('triton_poi_fused_native_group_norm_relu_35', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_35', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_35(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 262144
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/3e/c3edz2jlgd7x3ojnazo34vks4lvi36gew45ffjv4j6xacqlcirpz.py
# Topologically Sorted Source Nodes: [out_34], Original ATen: [aten.convolution]
# Source node to ATen node mapping:
#   out_34 => convolution_29
# Graph fragment:
#   %convolution_29 : [num_users=2] = call_function[target=torch.ops.aten.convolution.default](args = (%relu_25, %primals_91, %primals_92, [2, 2], [1, 1], [1, 1], False, [0, 0], 1), kwargs = {})
triton_poi_fused_convolution_36 = async_compile.triton('triton_poi_fused_convolution_36', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[65536], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_convolution_36', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_convolution_36(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 65536
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 1024
    tmp0 = tl.load(in_out_ptr0 + (x2), None)
    tmp1 = tl.load(in_ptr0 + (x0), None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x2), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/u5/cu5qbvq7rhsj5qzjpgn4u3l7m2flsdl6jv6rsorhhef7z7t5rpeu.py
# Topologically Sorted Source Nodes: [group_norm_26], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_26 => add_81, rsqrt_26, var_mean_47
# Graph fragment:
#   %var_mean_47 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_52, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_81 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_96, 1e-05), kwargs = {})
#   %rsqrt_26 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_81,), kwargs = {})
triton_per_fused_native_group_norm_37 = async_compile.triton('triton_per_fused_native_group_norm_37', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[128, 512],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_native_group_norm_37', 'mutated_arg_names': [], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_native_group_norm_37(in_ptr0, out_ptr0, out_ptr1, out_ptr2, xnumel, rnumel):
    xnumel = 128
    XBLOCK: tl.constexpr = 1
    rnumel = 512
    RBLOCK: tl.constexpr = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/ne/cne7llmjajc2ac624wbhyotx4of4ba24zgfkmy5mj6hluta3oajy.py
# Topologically Sorted Source Nodes: [group_norm_26, relu_26], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_26 => add_82, mul_53
#   relu_26 => relu_26
# Graph fragment:
#   %mul_53 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_53, %unsqueeze_161), kwargs = {})
#   %add_82 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_53, %unsqueeze_158), kwargs = {})
#   %relu_26 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_82,), kwargs = {})
triton_poi_fused_native_group_norm_relu_38 = async_compile.triton('triton_poi_fused_native_group_norm_relu_38', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[65536], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_38', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_38(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 65536
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/pw/cpwuyihukeko3sz2mange4jiyuc6hegivng7t6xlmjwzff2jslfm.py
# Topologically Sorted Source Nodes: [var_mean_21, sub_21, add_29, sqrt_21, w_21], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_29 => add_83
#   sqrt_21 => sqrt_21
#   sub_21 => sub_48
#   var_mean_21 => var_mean_48
#   w_21 => div_21
# Graph fragment:
#   %var_mean_48 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_95, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_48 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_95, %getitem_99), kwargs = {})
#   %add_83 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_98, 1e-10), kwargs = {})
#   %sqrt_21 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_83,), kwargs = {})
#   %div_21 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_48, %sqrt_21), kwargs = {})
triton_per_fused_add_div_sqrt_sub_var_mean_39 = async_compile.triton('triton_per_fused_add_div_sqrt_sub_var_mean_39', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[4096, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_div_sqrt_sub_var_mean_39', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_39(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel):
    xnumel = 4096
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = 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-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/kt/cktxvckhfax7pjim22s6n5uzucjshabg76bthqfv5bt7xvx2rg7v.py
# Topologically Sorted Source Nodes: [input_12], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_12 => add_84
# Graph fragment:
#   %add_84 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_30, %convolution_27), kwargs = {})
triton_poi_fused_add_40 = async_compile.triton('triton_poi_fused_add_40', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_40', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_40(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 262144
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (x0), None)
    tmp1 = tl.load(in_out_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/3z/c3zgsvchcnqibeqy5jdmcbb664t2dc7anoixlyfsbcbmr7q6etbj.py
# Topologically Sorted Source Nodes: [group_norm_27], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_27 => add_85, rsqrt_27, var_mean_49
# Graph fragment:
#   %var_mean_49 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_54, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_85 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_100, 1e-05), kwargs = {})
#   %rsqrt_27 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_85,), kwargs = {})
triton_red_fused_native_group_norm_41 = async_compile.triton('triton_red_fused_native_group_norm_41', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[128, 2048],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_native_group_norm_41', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 1, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@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 = 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + (x4), tmp9, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/5j/c5jagcpyiyis7hpqnt5po5ouog6tiegjmrxnuvik36qafxw6ph47.py
# Topologically Sorted Source Nodes: [group_norm_27, out_36], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_27 => add_86, mul_55
#   out_36 => relu_27
# Graph fragment:
#   %mul_55 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_55, %unsqueeze_167), kwargs = {})
#   %add_86 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_55, %unsqueeze_164), kwargs = {})
#   %relu_27 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_86,), kwargs = {})
triton_poi_fused_native_group_norm_relu_42 = async_compile.triton('triton_poi_fused_native_group_norm_relu_42', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_42', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_42(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 262144
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = 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 + ((32*x2) + (x0 // 128)), None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + ((32*x2) + (x0 // 128)), 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/5c/c5cnjqjnvm5kgsecw54s3qbswpzb3ndbzzivmfbmbr5ek3n7tfho.py
# Topologically Sorted Source Nodes: [var_mean_22, sub_22, add_31, sqrt_22, w_22], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_31 => add_87
#   sqrt_22 => sqrt_22
#   sub_22 => sub_50
#   var_mean_22 => var_mean_50
#   w_22 => div_22
# Graph fragment:
#   %var_mean_50 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_98, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_50 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_98, %getitem_103), kwargs = {})
#   %add_87 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_102, 1e-10), kwargs = {})
#   %sqrt_22 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_87,), kwargs = {})
#   %div_22 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_50, %sqrt_22), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_43 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_43', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[1024, 4096],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_43', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@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 = tmp4_tmp[:, None]
    tmp5 = 4096.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/dl/cdlkdgo2g6uuwzzliq3ols47a2pt4qrqa2hxzxqniidji2r3opyh.py
# Topologically Sorted Source Nodes: [input_13], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_13 => add_93
# Graph fragment:
#   %add_93 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_33, %add_84), kwargs = {})
triton_poi_fused_add_44 = async_compile.triton('triton_poi_fused_add_44', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[262144], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_44', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_44(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 262144
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + (x0), None)
    tmp1 = tl.load(in_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/p2/cp2pkyyfmqpfiixnv3jjjvia7zvprrskyyin2oz4s5h4td3uobbn.py
# Topologically Sorted Source Nodes: [var_mean_28, sub_28, add_40, sqrt_28, w_28], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_40 => add_114
#   sqrt_28 => sqrt_28
#   sub_28 => sub_65
#   var_mean_28 => var_mean_65
#   w_28 => div_28
# Graph fragment:
#   %var_mean_65 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_128, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_65 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_128, %getitem_133), kwargs = {})
#   %add_114 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_132, 1e-10), kwargs = {})
#   %sqrt_28 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_114,), kwargs = {})
#   %div_28 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_65, %sqrt_28), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_45 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_45', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[8192, 4096],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_45', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_45(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel, XBLOCK : tl.constexpr, RBLOCK : tl.constexpr):
    xnumel = 8192
    rnumel = 4096
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = 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 + (4096*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 = tmp4_tmp[:, None]
    tmp5 = 4096.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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 + (4096*x0)), rmask, eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + (4096*x0)), tmp12, rmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/7v/c7vndo53sxch2xfxk2j225jshkuji44jqxb3kasd35ift5bl4cqu.py
# Topologically Sorted Source Nodes: [var_mean_29, sub_29, add_41, sqrt_29, w_29], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_41 => add_115
#   sqrt_29 => sqrt_29
#   sub_29 => sub_66
#   var_mean_29 => var_mean_66
#   w_29 => div_29
# Graph fragment:
#   %var_mean_66 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_129, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_66 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_129, %getitem_135), kwargs = {})
#   %add_115 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_134, 1e-10), kwargs = {})
#   %sqrt_29 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_115,), kwargs = {})
#   %div_29 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_66, %sqrt_29), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_46 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_46', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[2048, 4096],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_46', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_46(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel, XBLOCK : tl.constexpr, RBLOCK : tl.constexpr):
    xnumel = 2048
    rnumel = 4096
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = 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 + (4096*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 = tmp4_tmp[:, None]
    tmp5 = 4096.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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 + (4096*x0)), rmask, eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + (4096*x0)), tmp12, rmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/c4/cc4m7vudmm3cnmrdoq6nrxav3dfryhniaztwf56ak3xwbsoexd6j.py
# Topologically Sorted Source Nodes: [group_norm_37], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_37 => add_116, rsqrt_37, var_mean_67
# Graph fragment:
#   %var_mean_67 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_74, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_116 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_136, 1e-05), kwargs = {})
#   %rsqrt_37 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_116,), kwargs = {})
triton_per_fused_native_group_norm_47 = async_compile.triton('triton_per_fused_native_group_norm_47', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[128, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_native_group_norm_47', 'mutated_arg_names': [], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_native_group_norm_47(in_ptr0, out_ptr0, out_ptr1, out_ptr2, xnumel, rnumel):
    xnumel = 128
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = tl.full([RBLOCK], True, tl.int1)
    r2 = rindex % 64
    r3 = (rindex // 64)
    x0 = xindex % 32
    x1 = (xindex // 32)
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + (64*x0) + (2048*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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/c4/cc4yjngdidzi6e5bjkxxkejgcpj7dbiephcer54rlmajddthlte7.py
# Topologically Sorted Source Nodes: [group_norm_37, relu_37], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_37 => add_117, mul_75
#   relu_37 => relu_37
# Graph fragment:
#   %mul_75 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_75, %unsqueeze_227), kwargs = {})
#   %add_117 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_75, %unsqueeze_224), kwargs = {})
#   %relu_37 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_117,), kwargs = {})
triton_poi_fused_native_group_norm_relu_48 = async_compile.triton('triton_poi_fused_native_group_norm_relu_48', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[131072], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_48', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_48(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 131072
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 2048
    x2 = (xindex // 32768)
    tmp0 = tl.load(in_ptr0 + (x3), None)
    tmp1 = tl.load(in_ptr1 + ((32*x2) + (x0 // 64)), None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + ((32*x2) + (x0 // 64)), 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/bg/cbgnzftadm3ygxe6jr4nyqfszukghqcdcun5ko2zoekytzrl7ze7.py
# Topologically Sorted Source Nodes: [out_50], Original ATen: [aten.convolution]
# Source node to ATen node mapping:
#   out_50 => convolution_42
# Graph fragment:
#   %convolution_42 : [num_users=2] = call_function[target=torch.ops.aten.convolution.default](args = (%relu_37, %primals_132, %primals_133, [2, 2], [1, 1], [1, 1], False, [0, 0], 1), kwargs = {})
triton_poi_fused_convolution_49 = async_compile.triton('triton_poi_fused_convolution_49', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[32768], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_convolution_49', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_convolution_49(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 32768
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 2048
    tmp0 = tl.load(in_out_ptr0 + (x2), None)
    tmp1 = tl.load(in_ptr0 + (x0), None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x2), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/lc/clcxsrztfooasql5b6o2fhwxukcgbzvvpsfy34xamrihxhotepnv.py
# Topologically Sorted Source Nodes: [group_norm_38], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_38 => add_118, rsqrt_38, var_mean_68
# Graph fragment:
#   %var_mean_68 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_76, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_118 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_138, 1e-05), kwargs = {})
#   %rsqrt_38 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_118,), kwargs = {})
triton_per_fused_native_group_norm_50 = async_compile.triton('triton_per_fused_native_group_norm_50', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[128, 256],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_native_group_norm_50', 'mutated_arg_names': [], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_native_group_norm_50(in_ptr0, out_ptr0, out_ptr1, out_ptr2, xnumel, rnumel):
    xnumel = 128
    XBLOCK: tl.constexpr = 1
    rnumel = 256
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = tl.full([RBLOCK], True, tl.int1)
    r2 = rindex % 64
    r3 = (rindex // 64)
    x0 = xindex % 32
    x1 = (xindex // 32)
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + (64*x0) + (2048*r3) + (8192*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], 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.rsqrt(tmp17)
    tl.store(out_ptr2 + (x4), tmp18, None)
    tl.store(out_ptr0 + (x4), tmp8, None)
    tl.store(out_ptr1 + (x4), tmp13, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/76/c76lb5dgw7uy4lpt3ebksnkexpk5a4mcifrw43rrzrmwnhrksd6u.py
# Topologically Sorted Source Nodes: [group_norm_38, relu_38], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_38 => add_119, mul_77
#   relu_38 => relu_38
# Graph fragment:
#   %mul_77 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_77, %unsqueeze_233), kwargs = {})
#   %add_119 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_77, %unsqueeze_230), kwargs = {})
#   %relu_38 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_119,), kwargs = {})
triton_poi_fused_native_group_norm_relu_51 = async_compile.triton('triton_poi_fused_native_group_norm_relu_51', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[32768], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_51', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_51(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 32768
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 2048
    x2 = (xindex // 8192)
    tmp0 = tl.load(in_ptr0 + (x3), None)
    tmp1 = tl.load(in_ptr1 + ((32*x2) + (x0 // 64)), None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + ((32*x2) + (x0 // 64)), 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 = 256.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/a4/ca4jkajxllucjxjlawcrmgbqoc3gf3uabc23n74mijvijx6un6v4.py
# Topologically Sorted Source Nodes: [var_mean_30, sub_30, add_42, sqrt_30, w_30], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_42 => add_120
#   sqrt_30 => sqrt_30
#   sub_30 => sub_69
#   var_mean_30 => var_mean_69
#   w_30 => div_30
# Graph fragment:
#   %var_mean_69 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_136, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_69 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_136, %getitem_141), kwargs = {})
#   %add_120 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_140, 1e-10), kwargs = {})
#   %sqrt_30 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_120,), kwargs = {})
#   %div_30 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_69, %sqrt_30), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_52 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_52', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[8192, 2048],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_52', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_52(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel, XBLOCK : tl.constexpr, RBLOCK : tl.constexpr):
    xnumel = 8192
    rnumel = 2048
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = 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 = tmp4_tmp[:, None]
    tmp5 = 2048.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/tr/ctrvbts2mcg36tlsxhn7jg7xen2u6a7kd7u4n3mosznsb6fa2wyo.py
# Topologically Sorted Source Nodes: [input_16], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_16 => add_121
# Graph fragment:
#   %add_121 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_43, %convolution_40), kwargs = {})
triton_poi_fused_add_53 = async_compile.triton('triton_poi_fused_add_53', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[131072], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_53', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_53(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 131072
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (x0), None)
    tmp1 = tl.load(in_out_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/bm/cbmg74gizsfkitta6qalg37yo25qnqf63c5jyevmzhqmxnjx7xom.py
# Topologically Sorted Source Nodes: [group_norm_39], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   group_norm_39 => add_122, rsqrt_39, var_mean_70
# Graph fragment:
#   %var_mean_70 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_78, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_122 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_142, 1e-05), kwargs = {})
#   %rsqrt_39 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_122,), kwargs = {})
triton_per_fused_native_group_norm_54 = async_compile.triton('triton_per_fused_native_group_norm_54', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[128, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: 'i32', 5: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_native_group_norm_54', 'mutated_arg_names': [], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_native_group_norm_54(in_ptr0, out_ptr0, out_ptr1, out_ptr2, xnumel, rnumel):
    xnumel = 128
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = tl.full([RBLOCK], True, tl.int1)
    r2 = rindex % 256
    r3 = (rindex // 256)
    x0 = xindex % 32
    x1 = (xindex // 32)
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + (256*x0) + (8192*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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/gz/cgzyjy3o2gqoit7amj557zg7toflqyj43kjgzl3ej62i7hk6lnee.py
# Topologically Sorted Source Nodes: [group_norm_39, out_52], Original ATen: [aten.native_group_norm, aten.relu]
# Source node to ATen node mapping:
#   group_norm_39 => add_123, mul_79
#   out_52 => relu_39
# Graph fragment:
#   %mul_79 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_79, %unsqueeze_239), kwargs = {})
#   %add_123 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_79, %unsqueeze_236), kwargs = {})
#   %relu_39 : [num_users=2] = call_function[target=torch.ops.aten.relu.default](args = (%add_123,), kwargs = {})
triton_poi_fused_native_group_norm_relu_55 = async_compile.triton('triton_poi_fused_native_group_norm_relu_55', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[131072], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_native_group_norm_relu_55', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 5, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_native_group_norm_relu_55(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 131072
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x3 = xindex
    x0 = xindex % 8192
    x2 = (xindex // 32768)
    tmp0 = tl.load(in_ptr0 + (x3), None)
    tmp1 = tl.load(in_ptr1 + ((32*x2) + (x0 // 256)), None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + ((32*x2) + (x0 // 256)), 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-05
    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)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/aj/cajj5ki6azp2kbx2jxbslibq6dzfyc3ipjv2qjovureewr6dmplt.py
# Topologically Sorted Source Nodes: [var_mean_31, sub_31, add_44, sqrt_31, w_31], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
# Source node to ATen node mapping:
#   add_44 => add_124
#   sqrt_31 => sqrt_31
#   sub_31 => sub_71
#   var_mean_31 => var_mean_71
#   w_31 => div_31
# Graph fragment:
#   %var_mean_71 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%primals_139, [1, 2, 3]), kwargs = {correction: 0, keepdim: True})
#   %sub_71 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_139, %getitem_145), kwargs = {})
#   %add_124 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_144, 1e-10), kwargs = {})
#   %sqrt_31 : [num_users=2] = call_function[target=torch.ops.aten.sqrt.default](args = (%add_124,), kwargs = {})
#   %div_31 : [num_users=2] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_71, %sqrt_31), kwargs = {})
triton_red_fused_add_div_sqrt_sub_var_mean_56 = async_compile.triton('triton_red_fused_add_div_sqrt_sub_var_mean_56', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.reduction(
    size_hints=[2048, 8192],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_red_fused_add_div_sqrt_sub_var_mean_56', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_56(in_out_ptr0, in_ptr0, out_ptr1, xnumel, rnumel, XBLOCK : tl.constexpr, RBLOCK : tl.constexpr):
    xnumel = 2048
    rnumel = 8192
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = 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 + (8192*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 = tmp4_tmp[:, None]
    tmp5 = 8192.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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 + (8192*x0)), rmask, eviction_policy='evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + (8192*x0)), tmp12, rmask)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/ff/cff7brpmobqi2vug2ta24kdr3loqrvuixh2kh2dnci64fj23ijsj.py
# Topologically Sorted Source Nodes: [input_17], Original ATen: [aten.add]
# Source node to ATen node mapping:
#   input_17 => add_130
# Graph fragment:
#   %add_130 : [num_users=3] = call_function[target=torch.ops.aten.add.Tensor](args = (%convolution_46, %add_121), kwargs = {})
triton_poi_fused_add_57 = async_compile.triton('triton_poi_fused_add_57', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[131072], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_add_57', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_add_57(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 131072
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + (x0), None)
    tmp1 = tl.load(in_ptr0 + (x0), None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x0), tmp2, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/sz/cszq7gbtdxzwt3qzvghesh6nlz5v2y6sbgs46237zpvjscw4bbk4.py
# Topologically Sorted Source Nodes: [input_20], Original ATen: [aten.native_group_norm]
# Source node to ATen node mapping:
#   input_20 => add_149, rsqrt_48, var_mean_85
# Graph fragment:
#   %var_mean_85 : [num_users=2] = call_function[target=torch.ops.aten.var_mean.correction](args = (%view_96, [2, 3]), kwargs = {correction: 0, keepdim: True})
#   %add_149 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%getitem_172, 1e-05), kwargs = {})
#   %rsqrt_48 : [num_users=2] = call_function[target=torch.ops.aten.rsqrt.default](args = (%add_149,), kwargs = {})
triton_per_fused_native_group_norm_58 = async_compile.triton('triton_per_fused_native_group_norm_58', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[128, 1024],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_native_group_norm_58', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': True, 'num_load': 1, 'num_reduction': 4, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_native_group_norm_58(in_out_ptr0, in_ptr0, out_ptr0, xnumel, rnumel):
    xnumel = 128
    XBLOCK: tl.constexpr = 1
    rnumel = 1024
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    xmask = tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    roffset = 0
    rmask = tl.full([RBLOCK], True, tl.int1)
    r2 = rindex % 256
    r3 = (rindex // 256)
    x0 = xindex % 32
    x1 = (xindex // 32)
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + (256*x0) + (8192*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-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.rsqrt(tmp17)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + (x4), tmp18, None)
    tl.store(out_ptr0 + (x4), tmp8, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/ho/chohdgeexcik3iyqkflbyj2cmb4wqtijhbp72tnfgmvhausg25tu.py
# Topologically Sorted Source Nodes: [input_20, input_21, input_22], Original ATen: [aten.native_group_norm, aten.relu, aten.mean]
# Source node to ATen node mapping:
#   input_20 => add_150, mul_97
#   input_21 => relu_48
#   input_22 => mean
# Graph fragment:
#   %mul_97 : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%view_97, %unsqueeze_293), kwargs = {})
#   %add_150 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mul_97, %unsqueeze_290), kwargs = {})
#   %relu_48 : [num_users=1] = call_function[target=torch.ops.aten.relu.default](args = (%add_150,), kwargs = {})
#   %mean : [num_users=2] = call_function[target=torch.ops.aten.mean.dim](args = (%relu_48, [-1, -2], True), kwargs = {})
triton_poi_fused_mean_native_group_norm_relu_59 = async_compile.triton('triton_poi_fused_mean_native_group_norm_relu_59', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[32768], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '*fp32', 6: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 3, 4, 5, 6), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_mean_native_group_norm_relu_59', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 8, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_mean_native_group_norm_relu_59(in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 32768
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = tl.full([XBLOCK], True, tl.int1)
    x0 = xindex % 8192
    x1 = (xindex // 8192)
    x2 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + (32768*x1)), None)
    tmp1 = tl.load(in_ptr1 + ((x2 // 256)), None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + ((x2 // 256)), None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr3 + (x0), None, eviction_policy='evict_last')
    tmp7 = tl.load(in_ptr4 + (x0), None, eviction_policy='evict_last')
    tmp11 = tl.load(in_ptr0 + (8192 + x0 + (32768*x1)), None)
    tmp18 = tl.load(in_ptr0 + (16384 + x0 + (32768*x1)), None)
    tmp25 = tl.load(in_ptr0 + (24576 + x0 + (32768*x1)), None)
    tmp2 = tmp0 - tmp1
    tmp4 = tmp2 * tmp3
    tmp6 = tmp4 * tmp5
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 0, tl.int32)
    tmp10 = triton_helpers.maximum(tmp9, tmp8)
    tmp12 = tmp11 - tmp1
    tmp13 = tmp12 * tmp3
    tmp14 = tmp13 * tmp5
    tmp15 = tmp14 + tmp7
    tmp16 = triton_helpers.maximum(tmp9, tmp15)
    tmp17 = tmp10 + tmp16
    tmp19 = tmp18 - tmp1
    tmp20 = tmp19 * tmp3
    tmp21 = tmp20 * tmp5
    tmp22 = tmp21 + tmp7
    tmp23 = triton_helpers.maximum(tmp9, tmp22)
    tmp24 = tmp17 + tmp23
    tmp26 = tmp25 - tmp1
    tmp27 = tmp26 * tmp3
    tmp28 = tmp27 * tmp5
    tmp29 = tmp28 + tmp7
    tmp30 = triton_helpers.maximum(tmp9, tmp29)
    tmp31 = tmp24 + tmp30
    tmp32 = 4.0
    tmp33 = tmp31 / tmp32
    tl.store(out_ptr0 + (x2), tmp33, None)
''', device_str='cuda')


# kernel path: runs/run_shard_4/inductor_cache/sw/csw2vezjin4bvf6fhnzk3tefnt5ol3gapui4lrf37dd4xtvyd7fq.py
# Topologically Sorted Source Nodes: [input_23], Original ATen: [aten.convolution]
# Source node to ATen node mapping:
#   input_23 => convolution_53
# Graph fragment:
#   %convolution_53 : [num_users=1] = call_function[target=torch.ops.aten.convolution.default](args = (%mean, %primals_169, %primals_170, [1, 1], [0, 0], [1, 1], False, [0, 0], 1), kwargs = {})
triton_poi_fused_convolution_60 = async_compile.triton('triton_poi_fused_convolution_60', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.pointwise(
    size_hints=[131072], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_convolution_60', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 0, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_convolution_60(in_out_ptr0, in_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 87372
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x2 = xindex
    x0 = xindex % 21843
    tmp0 = tl.load(in_out_ptr0 + (x2), xmask)
    tmp1 = tl.load(in_ptr0 + (x0), xmask, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + (x2), tmp2, xmask)
''', device_str='cuda')


async_compile.wait(globals())
del async_compile

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, primals_122, primals_123, primals_124, primals_125, primals_126, primals_127, primals_128, primals_129, primals_130, primals_131, primals_132, primals_133, primals_134, primals_135, primals_136, primals_137, primals_138, primals_139, primals_140, primals_141, primals_142, primals_143, primals_144, primals_145, primals_146, primals_147, primals_148, primals_149, primals_150, primals_151, primals_152, primals_153, primals_154, primals_155, primals_156, primals_157, primals_158, primals_159, primals_160, primals_161, primals_162, primals_163, primals_164, primals_165, primals_166, primals_167, primals_168, primals_169, primals_170 = 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, (256, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_7, (256, ), (1, ))
    assert_size_stride(primals_8, (256, ), (1, ))
    assert_size_stride(primals_9, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_10, (256, ), (1, ))
    assert_size_stride(primals_11, (256, ), (1, ))
    assert_size_stride(primals_12, (256, ), (1, ))
    assert_size_stride(primals_13, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_14, (1024, ), (1, ))
    assert_size_stride(primals_15, (1024, ), (1, ))
    assert_size_stride(primals_16, (256, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_17, (256, ), (1, ))
    assert_size_stride(primals_18, (256, ), (1, ))
    assert_size_stride(primals_19, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_20, (256, ), (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, (256, ), (1, ))
    assert_size_stride(primals_33, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_34, (1024, ), (1, ))
    assert_size_stride(primals_35, (1024, ), (1, ))
    assert_size_stride(primals_36, (256, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_37, (256, ), (1, ))
    assert_size_stride(primals_38, (256, ), (1, ))
    assert_size_stride(primals_39, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_40, (256, ), (1, ))
    assert_size_stride(primals_41, (256, ), (1, ))
    assert_size_stride(primals_42, (256, ), (1, ))
    assert_size_stride(primals_43, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_44, (1024, ), (1, ))
    assert_size_stride(primals_45, (1024, ), (1, ))
    assert_size_stride(primals_46, (2048, 1024, 1, 1), (1024, 1, 1, 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, (512, ), (1, ))
    assert_size_stride(primals_54, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_55, (2048, ), (1, ))
    assert_size_stride(primals_56, (2048, ), (1, ))
    assert_size_stride(primals_57, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_58, (512, ), (1, ))
    assert_size_stride(primals_59, (512, ), (1, ))
    assert_size_stride(primals_60, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_61, (512, ), (1, ))
    assert_size_stride(primals_62, (512, ), (1, ))
    assert_size_stride(primals_63, (512, ), (1, ))
    assert_size_stride(primals_64, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_65, (2048, ), (1, ))
    assert_size_stride(primals_66, (2048, ), (1, ))
    assert_size_stride(primals_67, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_68, (512, ), (1, ))
    assert_size_stride(primals_69, (512, ), (1, ))
    assert_size_stride(primals_70, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_71, (512, ), (1, ))
    assert_size_stride(primals_72, (512, ), (1, ))
    assert_size_stride(primals_73, (512, ), (1, ))
    assert_size_stride(primals_74, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_75, (2048, ), (1, ))
    assert_size_stride(primals_76, (2048, ), (1, ))
    assert_size_stride(primals_77, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_78, (512, ), (1, ))
    assert_size_stride(primals_79, (512, ), (1, ))
    assert_size_stride(primals_80, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_81, (512, ), (1, ))
    assert_size_stride(primals_82, (512, ), (1, ))
    assert_size_stride(primals_83, (512, ), (1, ))
    assert_size_stride(primals_84, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_85, (2048, ), (1, ))
    assert_size_stride(primals_86, (2048, ), (1, ))
    assert_size_stride(primals_87, (4096, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_88, (1024, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_89, (1024, ), (1, ))
    assert_size_stride(primals_90, (1024, ), (1, ))
    assert_size_stride(primals_91, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_92, (1024, ), (1, ))
    assert_size_stride(primals_93, (1024, ), (1, ))
    assert_size_stride(primals_94, (1024, ), (1, ))
    assert_size_stride(primals_95, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_96, (4096, ), (1, ))
    assert_size_stride(primals_97, (4096, ), (1, ))
    assert_size_stride(primals_98, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_99, (1024, ), (1, ))
    assert_size_stride(primals_100, (1024, ), (1, ))
    assert_size_stride(primals_101, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_102, (1024, ), (1, ))
    assert_size_stride(primals_103, (1024, ), (1, ))
    assert_size_stride(primals_104, (1024, ), (1, ))
    assert_size_stride(primals_105, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_106, (4096, ), (1, ))
    assert_size_stride(primals_107, (4096, ), (1, ))
    assert_size_stride(primals_108, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_109, (1024, ), (1, ))
    assert_size_stride(primals_110, (1024, ), (1, ))
    assert_size_stride(primals_111, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_112, (1024, ), (1, ))
    assert_size_stride(primals_113, (1024, ), (1, ))
    assert_size_stride(primals_114, (1024, ), (1, ))
    assert_size_stride(primals_115, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_116, (4096, ), (1, ))
    assert_size_stride(primals_117, (4096, ), (1, ))
    assert_size_stride(primals_118, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_119, (1024, ), (1, ))
    assert_size_stride(primals_120, (1024, ), (1, ))
    assert_size_stride(primals_121, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_122, (1024, ), (1, ))
    assert_size_stride(primals_123, (1024, ), (1, ))
    assert_size_stride(primals_124, (1024, ), (1, ))
    assert_size_stride(primals_125, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_126, (4096, ), (1, ))
    assert_size_stride(primals_127, (4096, ), (1, ))
    assert_size_stride(primals_128, (8192, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_129, (2048, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_130, (2048, ), (1, ))
    assert_size_stride(primals_131, (2048, ), (1, ))
    assert_size_stride(primals_132, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_133, (2048, ), (1, ))
    assert_size_stride(primals_134, (2048, ), (1, ))
    assert_size_stride(primals_135, (2048, ), (1, ))
    assert_size_stride(primals_136, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_137, (8192, ), (1, ))
    assert_size_stride(primals_138, (8192, ), (1, ))
    assert_size_stride(primals_139, (2048, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_140, (2048, ), (1, ))
    assert_size_stride(primals_141, (2048, ), (1, ))
    assert_size_stride(primals_142, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_143, (2048, ), (1, ))
    assert_size_stride(primals_144, (2048, ), (1, ))
    assert_size_stride(primals_145, (2048, ), (1, ))
    assert_size_stride(primals_146, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_147, (8192, ), (1, ))
    assert_size_stride(primals_148, (8192, ), (1, ))
    assert_size_stride(primals_149, (2048, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_150, (2048, ), (1, ))
    assert_size_stride(primals_151, (2048, ), (1, ))
    assert_size_stride(primals_152, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_153, (2048, ), (1, ))
    assert_size_stride(primals_154, (2048, ), (1, ))
    assert_size_stride(primals_155, (2048, ), (1, ))
    assert_size_stride(primals_156, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_157, (8192, ), (1, ))
    assert_size_stride(primals_158, (8192, ), (1, ))
    assert_size_stride(primals_159, (2048, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_160, (2048, ), (1, ))
    assert_size_stride(primals_161, (2048, ), (1, ))
    assert_size_stride(primals_162, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_163, (2048, ), (1, ))
    assert_size_stride(primals_164, (2048, ), (1, ))
    assert_size_stride(primals_165, (2048, ), (1, ))
    assert_size_stride(primals_166, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_167, (8192, ), (1, ))
    assert_size_stride(primals_168, (8192, ), (1, ))
    assert_size_stride(primals_169, (21843, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_170, (21843, ), (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)
        # Unsorted Source Nodes: [], Original ATen: []
        stream0 = get_raw_stream(0)
        triton_poi_fused_0.run(primals_1, buf0, 768, 49, grid=grid(768, 49), stream=stream0)
        del primals_1
        buf1 = empty_strided_cuda((4, 3, 64, 64), (12288, 1, 192, 3), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_1.run(primals_2, buf1, 12, 4096, grid=grid(12, 4096), stream=stream0)
        del primals_2
        buf2 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_2.run(primals_9, buf2, 65536, 9, grid=grid(65536, 9), stream=stream0)
        del primals_9
        buf3 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_2.run(primals_19, buf3, 65536, 9, grid=grid(65536, 9), stream=stream0)
        del primals_19
        buf4 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_2.run(primals_29, buf4, 65536, 9, grid=grid(65536, 9), stream=stream0)
        del primals_29
        buf5 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_2.run(primals_39, buf5, 65536, 9, grid=grid(65536, 9), stream=stream0)
        del primals_39
        buf6 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_3.run(primals_50, buf6, 262144, 9, grid=grid(262144, 9), stream=stream0)
        del primals_50
        buf7 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_3.run(primals_60, buf7, 262144, 9, grid=grid(262144, 9), stream=stream0)
        del primals_60
        buf8 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_3.run(primals_70, buf8, 262144, 9, grid=grid(262144, 9), stream=stream0)
        del primals_70
        buf9 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_3.run(primals_80, buf9, 262144, 9, grid=grid(262144, 9), stream=stream0)
        del primals_80
        buf10 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_4.run(primals_91, buf10, 1048576, 9, grid=grid(1048576, 9), stream=stream0)
        del primals_91
        buf11 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_4.run(primals_101, buf11, 1048576, 9, grid=grid(1048576, 9), stream=stream0)
        del primals_101
        buf12 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_4.run(primals_111, buf12, 1048576, 9, grid=grid(1048576, 9), stream=stream0)
        del primals_111
        buf13 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_4.run(primals_121, buf13, 1048576, 9, grid=grid(1048576, 9), stream=stream0)
        del primals_121
        buf14 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 2048), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_5.run(primals_132, buf14, 4194304, 9, grid=grid(4194304, 9), stream=stream0)
        del primals_132
        buf15 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 2048), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_5.run(primals_142, buf15, 4194304, 9, grid=grid(4194304, 9), stream=stream0)
        del primals_142
        buf16 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 2048), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_5.run(primals_152, buf16, 4194304, 9, grid=grid(4194304, 9), stream=stream0)
        del primals_152
        buf17 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 2048), torch.float32)
        # Unsorted Source Nodes: [], Original ATen: []
        triton_poi_fused_5.run(primals_162, buf17, 4194304, 9, grid=grid(4194304, 9), stream=stream0)
        del primals_162
        buf19 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256), torch.float32)
        buf21 = reinterpret_tensor(buf19, (256, 1, 1, 1), (1, 1, 1, 1), 0); del buf19  # reuse
        buf22 = empty_strided_cuda((256, 3, 7, 7), (147, 1, 21, 3), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean, sub, add, sqrt, w], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_6.run(buf21, buf0, buf22, 256, 147, grid=grid(256), stream=stream0)
        # Topologically Sorted Source Nodes: [input_1], Original ATen: [aten.convolution]
        buf23 = extern_kernels.convolution(buf1, buf22, stride=(2, 2), padding=(3, 3), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf23, (4, 256, 32, 32), (262144, 1, 8192, 256))
        buf24 = empty_strided_cuda((4, 256, 34, 34), (295936, 1, 8704, 256), torch.float32)
        # Topologically Sorted Source Nodes: [input_2], Original ATen: [aten.constant_pad_nd]
        triton_poi_fused_constant_pad_nd_7.run(buf23, buf24, 1183744, grid=grid(1183744), stream=stream0)
        buf25 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        buf26 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.int8)
        # Topologically Sorted Source Nodes: [input_3], Original ATen: [aten.max_pool2d_with_indices]
        triton_poi_fused_max_pool2d_with_indices_8.run(buf24, buf25, buf26, 262144, grid=grid(262144), stream=stream0)
        buf27 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf28 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf30 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf25, buf27, buf28, buf30, 128, 2048, grid=grid(128), stream=stream0)
        buf31 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm, out], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf25, buf27, buf28, primals_3, primals_4, buf31, 262144, grid=grid(262144), stream=stream0)
        del primals_4
        buf33 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf35 = reinterpret_tensor(buf33, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf33  # reuse
        buf36 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_1, sub_1, add_1, sqrt_1, w_1], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_11.run(buf35, primals_5, buf36, 1024, 256, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [residual], Original ATen: [aten.convolution]
        buf37 = extern_kernels.convolution(buf31, buf36, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf37, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf39 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256), torch.float32)
        buf41 = reinterpret_tensor(buf39, (256, 1, 1, 1), (1, 1, 1, 1), 0); del buf39  # reuse
        buf42 = empty_strided_cuda((256, 256, 1, 1), (256, 1, 256, 256), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_2, sub_2, add_2, sqrt_2, w_2], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_12.run(buf41, primals_6, buf42, 256, 256, grid=grid(256), stream=stream0)
        # Topologically Sorted Source Nodes: [out_1], Original ATen: [aten.convolution]
        buf43 = extern_kernels.convolution(buf31, buf42, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf43, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf44 = buf28; del buf28  # reuse
        buf45 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf47 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_1], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf43, buf44, buf45, buf47, 128, 2048, grid=grid(128), stream=stream0)
        buf48 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_1, relu_1], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf43, buf44, buf45, primals_7, primals_8, buf48, 262144, grid=grid(262144), stream=stream0)
        del primals_8
        # Topologically Sorted Source Nodes: [out_2], Original ATen: [aten.convolution]
        buf49 = extern_kernels.convolution(buf48, buf2, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf49, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf50 = buf49; del buf49  # reuse
        # Topologically Sorted Source Nodes: [out_2], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_13.run(buf50, primals_10, 262144, grid=grid(262144), stream=stream0)
        del primals_10
        buf51 = buf45; del buf45  # reuse
        buf52 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf54 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_2], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf50, buf51, buf52, buf54, 128, 2048, grid=grid(128), stream=stream0)
        buf55 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_2, relu_2], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf50, buf51, buf52, primals_11, primals_12, buf55, 262144, grid=grid(262144), stream=stream0)
        del primals_12
        buf57 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf59 = reinterpret_tensor(buf57, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf57  # reuse
        buf60 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_3, sub_3, add_3, sqrt_3, w_3], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_11.run(buf59, primals_13, buf60, 1024, 256, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_3], Original ATen: [aten.convolution]
        buf61 = extern_kernels.convolution(buf55, buf60, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf61, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf62 = buf37; del buf37  # reuse
        # Topologically Sorted Source Nodes: [input_4], Original ATen: [aten.add]
        triton_poi_fused_add_14.run(buf62, buf61, 1048576, grid=grid(1048576), stream=stream0)
        buf63 = buf52; del buf52  # reuse
        buf64 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf66 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_3], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_15.run(buf62, buf63, buf64, buf66, 128, 8192, grid=grid(128), stream=stream0)
        buf67 = buf61; del buf61  # reuse
        # Topologically Sorted Source Nodes: [group_norm_3, out_4], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_16.run(buf62, buf63, buf64, primals_14, primals_15, buf67, 1048576, grid=grid(1048576), stream=stream0)
        del primals_15
        buf69 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256), torch.float32)
        buf71 = reinterpret_tensor(buf69, (256, 1, 1, 1), (1, 1, 1, 1), 0); del buf69  # reuse
        buf72 = empty_strided_cuda((256, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_4, sub_4, add_5, sqrt_4, w_4], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_17.run(buf71, primals_16, buf72, 256, 1024, grid=grid(256), stream=stream0)
        # Topologically Sorted Source Nodes: [out_5], Original ATen: [aten.convolution]
        buf73 = extern_kernels.convolution(buf67, buf72, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf73, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf74 = buf64; del buf64  # reuse
        buf75 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf77 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_4], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf73, buf74, buf75, buf77, 128, 2048, grid=grid(128), stream=stream0)
        buf78 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_4, relu_4], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf73, buf74, buf75, primals_17, primals_18, buf78, 262144, grid=grid(262144), stream=stream0)
        del primals_18
        # Topologically Sorted Source Nodes: [out_6], Original ATen: [aten.convolution]
        buf79 = extern_kernels.convolution(buf78, buf3, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf79, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf80 = buf79; del buf79  # reuse
        # Topologically Sorted Source Nodes: [out_6], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_13.run(buf80, primals_20, 262144, grid=grid(262144), stream=stream0)
        del primals_20
        buf81 = buf75; del buf75  # reuse
        buf82 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf84 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_5], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf80, buf81, buf82, buf84, 128, 2048, grid=grid(128), stream=stream0)
        buf85 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_5, relu_5], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf80, buf81, buf82, primals_21, primals_22, buf85, 262144, grid=grid(262144), stream=stream0)
        del primals_22
        buf87 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf89 = reinterpret_tensor(buf87, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf87  # reuse
        buf90 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_5, sub_5, add_6, sqrt_5, w_5], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_11.run(buf89, primals_23, buf90, 1024, 256, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_7], Original ATen: [aten.convolution]
        buf91 = extern_kernels.convolution(buf85, buf90, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf91, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf92 = buf91; del buf91  # reuse
        # Topologically Sorted Source Nodes: [input_5], Original ATen: [aten.add]
        triton_poi_fused_add_18.run(buf92, buf62, 1048576, grid=grid(1048576), stream=stream0)
        buf93 = buf82; del buf82  # reuse
        buf94 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf96 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_6], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_15.run(buf92, buf93, buf94, buf96, 128, 8192, grid=grid(128), stream=stream0)
        buf97 = reinterpret_tensor(buf23, (4, 1024, 16, 16), (262144, 1, 16384, 1024), 0); del buf23  # reuse
        # Topologically Sorted Source Nodes: [group_norm_6, out_8], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_16.run(buf92, buf93, buf94, primals_24, primals_25, buf97, 1048576, grid=grid(1048576), stream=stream0)
        del primals_25
        buf99 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256), torch.float32)
        buf101 = reinterpret_tensor(buf99, (256, 1, 1, 1), (1, 1, 1, 1), 0); del buf99  # reuse
        buf102 = empty_strided_cuda((256, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_6, sub_6, add_8, sqrt_6, w_6], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_17.run(buf101, primals_26, buf102, 256, 1024, grid=grid(256), stream=stream0)
        # Topologically Sorted Source Nodes: [out_9], Original ATen: [aten.convolution]
        buf103 = extern_kernels.convolution(buf97, buf102, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf103, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf104 = buf94; del buf94  # reuse
        buf105 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf107 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_7], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf103, buf104, buf105, buf107, 128, 2048, grid=grid(128), stream=stream0)
        buf108 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_7, relu_7], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf103, buf104, buf105, primals_27, primals_28, buf108, 262144, grid=grid(262144), stream=stream0)
        del primals_28
        # Topologically Sorted Source Nodes: [out_10], Original ATen: [aten.convolution]
        buf109 = extern_kernels.convolution(buf108, buf4, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf109, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf110 = buf109; del buf109  # reuse
        # Topologically Sorted Source Nodes: [out_10], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_13.run(buf110, primals_30, 262144, grid=grid(262144), stream=stream0)
        del primals_30
        buf111 = buf105; del buf105  # reuse
        buf112 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf114 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_8], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf110, buf111, buf112, buf114, 128, 2048, grid=grid(128), stream=stream0)
        buf115 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_8, relu_8], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf110, buf111, buf112, primals_31, primals_32, buf115, 262144, grid=grid(262144), stream=stream0)
        del primals_32
        buf117 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf119 = reinterpret_tensor(buf117, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf117  # reuse
        buf120 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_7, sub_7, add_9, sqrt_7, w_7], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_11.run(buf119, primals_33, buf120, 1024, 256, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_11], Original ATen: [aten.convolution]
        buf121 = extern_kernels.convolution(buf115, buf120, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf121, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf122 = buf121; del buf121  # reuse
        # Topologically Sorted Source Nodes: [input_6], Original ATen: [aten.add]
        triton_poi_fused_add_18.run(buf122, buf92, 1048576, grid=grid(1048576), stream=stream0)
        buf123 = buf112; del buf112  # reuse
        buf124 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf126 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_9], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_15.run(buf122, buf123, buf124, buf126, 128, 8192, grid=grid(128), stream=stream0)
        buf127 = empty_strided_cuda((4, 1024, 16, 16), (262144, 1, 16384, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_9, out_12], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_16.run(buf122, buf123, buf124, primals_34, primals_35, buf127, 1048576, grid=grid(1048576), stream=stream0)
        del primals_35
        buf129 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256), torch.float32)
        buf131 = reinterpret_tensor(buf129, (256, 1, 1, 1), (1, 1, 1, 1), 0); del buf129  # reuse
        buf132 = empty_strided_cuda((256, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_8, sub_8, add_11, sqrt_8, w_8], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_17.run(buf131, primals_36, buf132, 256, 1024, grid=grid(256), stream=stream0)
        # Topologically Sorted Source Nodes: [out_13], Original ATen: [aten.convolution]
        buf133 = extern_kernels.convolution(buf127, buf132, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf133, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf134 = buf124; del buf124  # reuse
        buf135 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf137 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_10], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf133, buf134, buf135, buf137, 128, 2048, grid=grid(128), stream=stream0)
        buf138 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_10, relu_10], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf133, buf134, buf135, primals_37, primals_38, buf138, 262144, grid=grid(262144), stream=stream0)
        del primals_38
        # Topologically Sorted Source Nodes: [out_14], Original ATen: [aten.convolution]
        buf139 = extern_kernels.convolution(buf138, buf5, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf139, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf140 = buf139; del buf139  # reuse
        # Topologically Sorted Source Nodes: [out_14], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_13.run(buf140, primals_40, 262144, grid=grid(262144), stream=stream0)
        del primals_40
        buf141 = buf135; del buf135  # reuse
        buf142 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf144 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_11], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_9.run(buf140, buf141, buf142, buf144, 128, 2048, grid=grid(128), stream=stream0)
        buf145 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_11, relu_11], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_10.run(buf140, buf141, buf142, primals_41, primals_42, buf145, 262144, grid=grid(262144), stream=stream0)
        del primals_42
        buf147 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf149 = reinterpret_tensor(buf147, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf147  # reuse
        buf150 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_9, sub_9, add_12, sqrt_9, w_9], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_11.run(buf149, primals_43, buf150, 1024, 256, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_15], Original ATen: [aten.convolution]
        buf151 = extern_kernels.convolution(buf145, buf150, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf151, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf152 = buf151; del buf151  # reuse
        # Topologically Sorted Source Nodes: [input_7], Original ATen: [aten.add]
        triton_poi_fused_add_18.run(buf152, buf122, 1048576, grid=grid(1048576), stream=stream0)
        buf153 = buf142; del buf142  # reuse
        buf154 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf156 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_12], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_15.run(buf152, buf153, buf154, buf156, 128, 8192, grid=grid(128), stream=stream0)
        buf157 = empty_strided_cuda((4, 1024, 16, 16), (262144, 1, 16384, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_12, out_16], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_16.run(buf152, buf153, buf154, primals_44, primals_45, buf157, 1048576, grid=grid(1048576), stream=stream0)
        del primals_45
        buf159 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf161 = reinterpret_tensor(buf159, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf159  # reuse
        buf162 = empty_strided_cuda((2048, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_10, sub_10, add_14, sqrt_10, w_10], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_19.run(buf161, primals_46, buf162, 2048, 1024, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [residual_1], Original ATen: [aten.convolution]
        buf163 = extern_kernels.convolution(buf157, buf162, stride=(2, 2), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf163, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf165 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512), torch.float32)
        buf167 = reinterpret_tensor(buf165, (512, 1, 1, 1), (1, 1, 1, 1), 0); del buf165  # reuse
        buf168 = empty_strided_cuda((512, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_11, sub_11, add_15, sqrt_11, w_11], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_20.run(buf167, primals_47, buf168, 512, 1024, grid=grid(512), stream=stream0)
        # Topologically Sorted Source Nodes: [out_17], Original ATen: [aten.convolution]
        buf169 = extern_kernels.convolution(buf157, buf168, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf169, (4, 512, 16, 16), (131072, 1, 8192, 512))
        buf170 = buf154; del buf154  # reuse
        buf171 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf173 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_13], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_21.run(buf169, buf170, buf171, buf173, 128, 4096, grid=grid(128), stream=stream0)
        buf174 = empty_strided_cuda((4, 512, 16, 16), (131072, 1, 8192, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_13, relu_13], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_22.run(buf169, buf170, buf171, primals_48, primals_49, buf174, 524288, grid=grid(524288), stream=stream0)
        del primals_49
        # Topologically Sorted Source Nodes: [out_18], Original ATen: [aten.convolution]
        buf175 = extern_kernels.convolution(buf174, buf6, stride=(2, 2), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf175, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf176 = buf175; del buf175  # reuse
        # Topologically Sorted Source Nodes: [out_18], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_23.run(buf176, primals_51, 131072, grid=grid(131072), stream=stream0)
        del primals_51
        buf177 = buf171; del buf171  # reuse
        buf178 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf180 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_14], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_24.run(buf176, buf177, buf178, buf180, 128, 1024, grid=grid(128), stream=stream0)
        buf181 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_14, relu_14], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_25.run(buf176, buf177, buf178, primals_52, primals_53, buf181, 131072, grid=grid(131072), stream=stream0)
        del primals_53
        buf183 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf185 = reinterpret_tensor(buf183, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf183  # reuse
        buf186 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_12, sub_12, add_16, sqrt_12, w_12], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_26.run(buf185, primals_54, buf186, 2048, 512, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_19], Original ATen: [aten.convolution]
        buf187 = extern_kernels.convolution(buf181, buf186, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf187, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf188 = buf163; del buf163  # reuse
        # Topologically Sorted Source Nodes: [input_8], Original ATen: [aten.add]
        triton_poi_fused_add_27.run(buf188, buf187, 524288, grid=grid(524288), stream=stream0)
        buf189 = buf178; del buf178  # reuse
        buf190 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf192 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_15], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_28.run(buf188, buf189, buf190, buf192, 128, 4096, grid=grid(128), stream=stream0)
        buf193 = buf187; del buf187  # reuse
        # Topologically Sorted Source Nodes: [group_norm_15, out_20], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_29.run(buf188, buf189, buf190, primals_55, primals_56, buf193, 524288, grid=grid(524288), stream=stream0)
        del primals_56
        buf195 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512), torch.float32)
        buf197 = reinterpret_tensor(buf195, (512, 1, 1, 1), (1, 1, 1, 1), 0); del buf195  # reuse
        buf198 = empty_strided_cuda((512, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_13, sub_13, add_18, sqrt_13, w_13], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_30.run(buf197, primals_57, buf198, 512, 2048, grid=grid(512), stream=stream0)
        # Topologically Sorted Source Nodes: [out_21], Original ATen: [aten.convolution]
        buf199 = extern_kernels.convolution(buf193, buf198, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf199, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf200 = buf190; del buf190  # reuse
        buf201 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf203 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_16], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_24.run(buf199, buf200, buf201, buf203, 128, 1024, grid=grid(128), stream=stream0)
        buf204 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_16, relu_16], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_25.run(buf199, buf200, buf201, primals_58, primals_59, buf204, 131072, grid=grid(131072), stream=stream0)
        del primals_59
        # Topologically Sorted Source Nodes: [out_22], Original ATen: [aten.convolution]
        buf205 = extern_kernels.convolution(buf204, buf7, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf205, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf206 = buf205; del buf205  # reuse
        # Topologically Sorted Source Nodes: [out_22], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_23.run(buf206, primals_61, 131072, grid=grid(131072), stream=stream0)
        del primals_61
        buf207 = buf201; del buf201  # reuse
        buf208 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf210 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_17], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_24.run(buf206, buf207, buf208, buf210, 128, 1024, grid=grid(128), stream=stream0)
        buf211 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_17, relu_17], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_25.run(buf206, buf207, buf208, primals_62, primals_63, buf211, 131072, grid=grid(131072), stream=stream0)
        del primals_63
        buf213 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf215 = reinterpret_tensor(buf213, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf213  # reuse
        buf216 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_14, sub_14, add_19, sqrt_14, w_14], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_26.run(buf215, primals_64, buf216, 2048, 512, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_23], Original ATen: [aten.convolution]
        buf217 = extern_kernels.convolution(buf211, buf216, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf217, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf218 = buf217; del buf217  # reuse
        # Topologically Sorted Source Nodes: [input_9], Original ATen: [aten.add]
        triton_poi_fused_add_31.run(buf218, buf188, 524288, grid=grid(524288), stream=stream0)
        buf219 = buf208; del buf208  # reuse
        buf220 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf222 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_18], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_28.run(buf218, buf219, buf220, buf222, 128, 4096, grid=grid(128), stream=stream0)
        buf223 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_18, out_24], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_29.run(buf218, buf219, buf220, primals_65, primals_66, buf223, 524288, grid=grid(524288), stream=stream0)
        del primals_66
        buf225 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512), torch.float32)
        buf227 = reinterpret_tensor(buf225, (512, 1, 1, 1), (1, 1, 1, 1), 0); del buf225  # reuse
        buf228 = empty_strided_cuda((512, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_15, sub_15, add_21, sqrt_15, w_15], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_30.run(buf227, primals_67, buf228, 512, 2048, grid=grid(512), stream=stream0)
        # Topologically Sorted Source Nodes: [out_25], Original ATen: [aten.convolution]
        buf229 = extern_kernels.convolution(buf223, buf228, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf229, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf230 = buf220; del buf220  # reuse
        buf231 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf233 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_19], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_24.run(buf229, buf230, buf231, buf233, 128, 1024, grid=grid(128), stream=stream0)
        buf234 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_19, relu_19], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_25.run(buf229, buf230, buf231, primals_68, primals_69, buf234, 131072, grid=grid(131072), stream=stream0)
        del primals_69
        # Topologically Sorted Source Nodes: [out_26], Original ATen: [aten.convolution]
        buf235 = extern_kernels.convolution(buf234, buf8, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf235, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf236 = buf235; del buf235  # reuse
        # Topologically Sorted Source Nodes: [out_26], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_23.run(buf236, primals_71, 131072, grid=grid(131072), stream=stream0)
        del primals_71
        buf237 = buf231; del buf231  # reuse
        buf238 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf240 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_20], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_24.run(buf236, buf237, buf238, buf240, 128, 1024, grid=grid(128), stream=stream0)
        buf241 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_20, relu_20], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_25.run(buf236, buf237, buf238, primals_72, primals_73, buf241, 131072, grid=grid(131072), stream=stream0)
        del primals_73
        buf243 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf245 = reinterpret_tensor(buf243, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf243  # reuse
        buf246 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_16, sub_16, add_22, sqrt_16, w_16], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_26.run(buf245, primals_74, buf246, 2048, 512, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_27], Original ATen: [aten.convolution]
        buf247 = extern_kernels.convolution(buf241, buf246, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf247, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf248 = buf247; del buf247  # reuse
        # Topologically Sorted Source Nodes: [input_10], Original ATen: [aten.add]
        triton_poi_fused_add_31.run(buf248, buf218, 524288, grid=grid(524288), stream=stream0)
        buf249 = buf238; del buf238  # reuse
        buf250 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf252 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_21], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_28.run(buf248, buf249, buf250, buf252, 128, 4096, grid=grid(128), stream=stream0)
        buf253 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_21, out_28], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_29.run(buf248, buf249, buf250, primals_75, primals_76, buf253, 524288, grid=grid(524288), stream=stream0)
        del primals_76
        buf255 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512), torch.float32)
        buf257 = reinterpret_tensor(buf255, (512, 1, 1, 1), (1, 1, 1, 1), 0); del buf255  # reuse
        buf258 = empty_strided_cuda((512, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_17, sub_17, add_24, sqrt_17, w_17], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_30.run(buf257, primals_77, buf258, 512, 2048, grid=grid(512), stream=stream0)
        # Topologically Sorted Source Nodes: [out_29], Original ATen: [aten.convolution]
        buf259 = extern_kernels.convolution(buf253, buf258, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf259, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf260 = buf250; del buf250  # reuse
        buf261 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf263 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_22], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_24.run(buf259, buf260, buf261, buf263, 128, 1024, grid=grid(128), stream=stream0)
        buf264 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_22, relu_22], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_25.run(buf259, buf260, buf261, primals_78, primals_79, buf264, 131072, grid=grid(131072), stream=stream0)
        del primals_79
        # Topologically Sorted Source Nodes: [out_30], Original ATen: [aten.convolution]
        buf265 = extern_kernels.convolution(buf264, buf9, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf265, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf266 = buf265; del buf265  # reuse
        # Topologically Sorted Source Nodes: [out_30], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_23.run(buf266, primals_81, 131072, grid=grid(131072), stream=stream0)
        del primals_81
        buf267 = buf261; del buf261  # reuse
        buf268 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf270 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_23], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_24.run(buf266, buf267, buf268, buf270, 128, 1024, grid=grid(128), stream=stream0)
        buf271 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_23, relu_23], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_25.run(buf266, buf267, buf268, primals_82, primals_83, buf271, 131072, grid=grid(131072), stream=stream0)
        del primals_83
        buf273 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf275 = reinterpret_tensor(buf273, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf273  # reuse
        buf276 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_18, sub_18, add_25, sqrt_18, w_18], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_26.run(buf275, primals_84, buf276, 2048, 512, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_31], Original ATen: [aten.convolution]
        buf277 = extern_kernels.convolution(buf271, buf276, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf277, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf278 = buf277; del buf277  # reuse
        # Topologically Sorted Source Nodes: [input_11], Original ATen: [aten.add]
        triton_poi_fused_add_31.run(buf278, buf248, 524288, grid=grid(524288), stream=stream0)
        buf279 = buf268; del buf268  # reuse
        buf280 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf282 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_24], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_28.run(buf278, buf279, buf280, buf282, 128, 4096, grid=grid(128), stream=stream0)
        buf283 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_24, out_32], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_29.run(buf278, buf279, buf280, primals_85, primals_86, buf283, 524288, grid=grid(524288), stream=stream0)
        del primals_86
        buf285 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096), torch.float32)
        buf287 = reinterpret_tensor(buf285, (4096, 1, 1, 1), (1, 1, 1, 1), 0); del buf285  # reuse
        buf288 = empty_strided_cuda((4096, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_19, sub_19, add_27, sqrt_19, w_19], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_32.run(buf287, primals_87, buf288, 4096, 2048, grid=grid(4096), stream=stream0)
        # Topologically Sorted Source Nodes: [residual_2], Original ATen: [aten.convolution]
        buf289 = extern_kernels.convolution(buf283, buf288, stride=(2, 2), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf289, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf291 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf293 = reinterpret_tensor(buf291, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf291  # reuse
        buf294 = empty_strided_cuda((1024, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_20, sub_20, add_28, sqrt_20, w_20], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_33.run(buf293, primals_88, buf294, 1024, 2048, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_33], Original ATen: [aten.convolution]
        buf295 = extern_kernels.convolution(buf283, buf294, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf295, (4, 1024, 8, 8), (65536, 1, 8192, 1024))
        buf296 = buf280; del buf280  # reuse
        buf297 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf299 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_25], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_34.run(buf295, buf296, buf297, buf299, 128, 2048, grid=grid(128), stream=stream0)
        buf300 = empty_strided_cuda((4, 1024, 8, 8), (65536, 1, 8192, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_25, relu_25], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_35.run(buf295, buf296, buf297, primals_89, primals_90, buf300, 262144, grid=grid(262144), stream=stream0)
        del primals_90
        # Topologically Sorted Source Nodes: [out_34], Original ATen: [aten.convolution]
        buf301 = extern_kernels.convolution(buf300, buf10, stride=(2, 2), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf301, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf302 = buf301; del buf301  # reuse
        # Topologically Sorted Source Nodes: [out_34], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_36.run(buf302, primals_92, 65536, grid=grid(65536), stream=stream0)
        del primals_92
        buf303 = buf297; del buf297  # reuse
        buf304 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf306 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_26], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_37.run(buf302, buf303, buf304, buf306, 128, 512, grid=grid(128), stream=stream0)
        buf307 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_26, relu_26], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_38.run(buf302, buf303, buf304, primals_93, primals_94, buf307, 65536, grid=grid(65536), stream=stream0)
        del primals_94
        buf309 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096), torch.float32)
        buf311 = reinterpret_tensor(buf309, (4096, 1, 1, 1), (1, 1, 1, 1), 0); del buf309  # reuse
        buf312 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_21, sub_21, add_29, sqrt_21, w_21], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_39.run(buf311, primals_95, buf312, 4096, 1024, grid=grid(4096), stream=stream0)
        # Topologically Sorted Source Nodes: [out_35], Original ATen: [aten.convolution]
        buf313 = extern_kernels.convolution(buf307, buf312, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf313, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf314 = buf289; del buf289  # reuse
        # Topologically Sorted Source Nodes: [input_12], Original ATen: [aten.add]
        triton_poi_fused_add_40.run(buf314, buf313, 262144, grid=grid(262144), stream=stream0)
        buf315 = buf304; del buf304  # reuse
        buf316 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf318 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_27], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_41.run(buf314, buf315, buf316, buf318, 128, 2048, grid=grid(128), stream=stream0)
        buf319 = buf313; del buf313  # reuse
        # Topologically Sorted Source Nodes: [group_norm_27, out_36], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_42.run(buf314, buf315, buf316, primals_96, primals_97, buf319, 262144, grid=grid(262144), stream=stream0)
        del primals_97
        buf321 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf323 = reinterpret_tensor(buf321, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf321  # reuse
        buf324 = empty_strided_cuda((1024, 4096, 1, 1), (4096, 1, 4096, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_22, sub_22, add_31, sqrt_22, w_22], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_43.run(buf323, primals_98, buf324, 1024, 4096, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_37], Original ATen: [aten.convolution]
        buf325 = extern_kernels.convolution(buf319, buf324, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf325, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf326 = buf316; del buf316  # reuse
        buf327 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf329 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_28], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_37.run(buf325, buf326, buf327, buf329, 128, 512, grid=grid(128), stream=stream0)
        buf330 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_28, relu_28], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_38.run(buf325, buf326, buf327, primals_99, primals_100, buf330, 65536, grid=grid(65536), stream=stream0)
        del primals_100
        # Topologically Sorted Source Nodes: [out_38], Original ATen: [aten.convolution]
        buf331 = extern_kernels.convolution(buf330, buf11, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf331, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf332 = buf331; del buf331  # reuse
        # Topologically Sorted Source Nodes: [out_38], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_36.run(buf332, primals_102, 65536, grid=grid(65536), stream=stream0)
        del primals_102
        buf333 = buf327; del buf327  # reuse
        buf334 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf336 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_29], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_37.run(buf332, buf333, buf334, buf336, 128, 512, grid=grid(128), stream=stream0)
        buf337 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_29, relu_29], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_38.run(buf332, buf333, buf334, primals_103, primals_104, buf337, 65536, grid=grid(65536), stream=stream0)
        del primals_104
        buf339 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096), torch.float32)
        buf341 = reinterpret_tensor(buf339, (4096, 1, 1, 1), (1, 1, 1, 1), 0); del buf339  # reuse
        buf342 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_23, sub_23, add_32, sqrt_23, w_23], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_39.run(buf341, primals_105, buf342, 4096, 1024, grid=grid(4096), stream=stream0)
        # Topologically Sorted Source Nodes: [out_39], Original ATen: [aten.convolution]
        buf343 = extern_kernels.convolution(buf337, buf342, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf343, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf344 = buf343; del buf343  # reuse
        # Topologically Sorted Source Nodes: [input_13], Original ATen: [aten.add]
        triton_poi_fused_add_44.run(buf344, buf314, 262144, grid=grid(262144), stream=stream0)
        buf345 = buf334; del buf334  # reuse
        buf346 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf348 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_30], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_41.run(buf344, buf345, buf346, buf348, 128, 2048, grid=grid(128), stream=stream0)
        buf349 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_30, out_40], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_42.run(buf344, buf345, buf346, primals_106, primals_107, buf349, 262144, grid=grid(262144), stream=stream0)
        del primals_107
        buf351 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf353 = reinterpret_tensor(buf351, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf351  # reuse
        buf354 = empty_strided_cuda((1024, 4096, 1, 1), (4096, 1, 4096, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_24, sub_24, add_34, sqrt_24, w_24], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_43.run(buf353, primals_108, buf354, 1024, 4096, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_41], Original ATen: [aten.convolution]
        buf355 = extern_kernels.convolution(buf349, buf354, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf355, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf356 = buf346; del buf346  # reuse
        buf357 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf359 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_31], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_37.run(buf355, buf356, buf357, buf359, 128, 512, grid=grid(128), stream=stream0)
        buf360 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_31, relu_31], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_38.run(buf355, buf356, buf357, primals_109, primals_110, buf360, 65536, grid=grid(65536), stream=stream0)
        del primals_110
        # Topologically Sorted Source Nodes: [out_42], Original ATen: [aten.convolution]
        buf361 = extern_kernels.convolution(buf360, buf12, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf361, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf362 = buf361; del buf361  # reuse
        # Topologically Sorted Source Nodes: [out_42], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_36.run(buf362, primals_112, 65536, grid=grid(65536), stream=stream0)
        del primals_112
        buf363 = buf357; del buf357  # reuse
        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)
        # Topologically Sorted Source Nodes: [group_norm_32], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_37.run(buf362, buf363, buf364, buf366, 128, 512, grid=grid(128), stream=stream0)
        buf367 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_32, relu_32], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_38.run(buf362, buf363, buf364, primals_113, primals_114, buf367, 65536, grid=grid(65536), stream=stream0)
        del primals_114
        buf369 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096), torch.float32)
        buf371 = reinterpret_tensor(buf369, (4096, 1, 1, 1), (1, 1, 1, 1), 0); del buf369  # reuse
        buf372 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_25, sub_25, add_35, sqrt_25, w_25], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_39.run(buf371, primals_115, buf372, 4096, 1024, grid=grid(4096), stream=stream0)
        # Topologically Sorted Source Nodes: [out_43], Original ATen: [aten.convolution]
        buf373 = extern_kernels.convolution(buf367, buf372, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf373, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf374 = buf373; del buf373  # reuse
        # Topologically Sorted Source Nodes: [input_14], Original ATen: [aten.add]
        triton_poi_fused_add_44.run(buf374, buf344, 262144, grid=grid(262144), stream=stream0)
        buf375 = buf364; del buf364  # reuse
        buf376 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf378 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_33], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_41.run(buf374, buf375, buf376, buf378, 128, 2048, grid=grid(128), stream=stream0)
        buf379 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_33, out_44], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_42.run(buf374, buf375, buf376, primals_116, primals_117, buf379, 262144, grid=grid(262144), stream=stream0)
        del primals_117
        buf381 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024), torch.float32)
        buf383 = reinterpret_tensor(buf381, (1024, 1, 1, 1), (1, 1, 1, 1), 0); del buf381  # reuse
        buf384 = empty_strided_cuda((1024, 4096, 1, 1), (4096, 1, 4096, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_26, sub_26, add_37, sqrt_26, w_26], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_43.run(buf383, primals_118, buf384, 1024, 4096, grid=grid(1024), stream=stream0)
        # Topologically Sorted Source Nodes: [out_45], Original ATen: [aten.convolution]
        buf385 = extern_kernels.convolution(buf379, buf384, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf385, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf386 = buf376; del buf376  # reuse
        buf387 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf389 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_34], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_37.run(buf385, buf386, buf387, buf389, 128, 512, grid=grid(128), stream=stream0)
        buf390 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_34, relu_34], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_38.run(buf385, buf386, buf387, primals_119, primals_120, buf390, 65536, grid=grid(65536), stream=stream0)
        del primals_120
        # Topologically Sorted Source Nodes: [out_46], Original ATen: [aten.convolution]
        buf391 = extern_kernels.convolution(buf390, buf13, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf391, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf392 = buf391; del buf391  # reuse
        # Topologically Sorted Source Nodes: [out_46], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_36.run(buf392, primals_122, 65536, grid=grid(65536), stream=stream0)
        del primals_122
        buf393 = buf387; del buf387  # reuse
        buf394 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf396 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_35], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_37.run(buf392, buf393, buf394, buf396, 128, 512, grid=grid(128), stream=stream0)
        buf397 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_35, relu_35], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_38.run(buf392, buf393, buf394, primals_123, primals_124, buf397, 65536, grid=grid(65536), stream=stream0)
        del primals_124
        buf399 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096), torch.float32)
        buf401 = reinterpret_tensor(buf399, (4096, 1, 1, 1), (1, 1, 1, 1), 0); del buf399  # reuse
        buf402 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 1024), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_27, sub_27, add_38, sqrt_27, w_27], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_per_fused_add_div_sqrt_sub_var_mean_39.run(buf401, primals_125, buf402, 4096, 1024, grid=grid(4096), stream=stream0)
        # Topologically Sorted Source Nodes: [out_47], Original ATen: [aten.convolution]
        buf403 = extern_kernels.convolution(buf397, buf402, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf403, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf404 = buf403; del buf403  # reuse
        # Topologically Sorted Source Nodes: [input_15], Original ATen: [aten.add]
        triton_poi_fused_add_44.run(buf404, buf374, 262144, grid=grid(262144), stream=stream0)
        buf405 = buf394; del buf394  # reuse
        buf406 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf408 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_36], Original ATen: [aten.native_group_norm]
        triton_red_fused_native_group_norm_41.run(buf404, buf405, buf406, buf408, 128, 2048, grid=grid(128), stream=stream0)
        buf409 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_36, out_48], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_42.run(buf404, buf405, buf406, primals_126, primals_127, buf409, 262144, grid=grid(262144), stream=stream0)
        del primals_127
        buf411 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192), torch.float32)
        buf413 = reinterpret_tensor(buf411, (8192, 1, 1, 1), (1, 1, 1, 1), 0); del buf411  # reuse
        buf414 = empty_strided_cuda((8192, 4096, 1, 1), (4096, 1, 4096, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_28, sub_28, add_40, sqrt_28, w_28], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_45.run(buf413, primals_128, buf414, 8192, 4096, grid=grid(8192), stream=stream0)
        # Topologically Sorted Source Nodes: [residual_3], Original ATen: [aten.convolution]
        buf415 = extern_kernels.convolution(buf409, buf414, stride=(2, 2), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf415, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf417 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf419 = reinterpret_tensor(buf417, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf417  # reuse
        buf420 = empty_strided_cuda((2048, 4096, 1, 1), (4096, 1, 4096, 4096), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_29, sub_29, add_41, sqrt_29, w_29], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_46.run(buf419, primals_129, buf420, 2048, 4096, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_49], Original ATen: [aten.convolution]
        buf421 = extern_kernels.convolution(buf409, buf420, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf421, (4, 2048, 4, 4), (32768, 1, 8192, 2048))
        buf422 = buf406; del buf406  # reuse
        buf423 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf425 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_37], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_47.run(buf421, buf422, buf423, buf425, 128, 1024, grid=grid(128), stream=stream0)
        buf426 = empty_strided_cuda((4, 2048, 4, 4), (32768, 1, 8192, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_37, relu_37], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_48.run(buf421, buf422, buf423, primals_130, primals_131, buf426, 131072, grid=grid(131072), stream=stream0)
        del primals_131
        # Topologically Sorted Source Nodes: [out_50], Original ATen: [aten.convolution]
        buf427 = extern_kernels.convolution(buf426, buf14, stride=(2, 2), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf427, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf428 = buf427; del buf427  # reuse
        # Topologically Sorted Source Nodes: [out_50], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_49.run(buf428, primals_133, 32768, grid=grid(32768), stream=stream0)
        del primals_133
        buf429 = buf423; del buf423  # reuse
        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)
        # Topologically Sorted Source Nodes: [group_norm_38], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_50.run(buf428, buf429, buf430, buf432, 128, 256, grid=grid(128), stream=stream0)
        buf433 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_38, relu_38], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_51.run(buf428, buf429, buf430, primals_134, primals_135, buf433, 32768, grid=grid(32768), stream=stream0)
        del primals_135
        buf435 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192), torch.float32)
        buf437 = reinterpret_tensor(buf435, (8192, 1, 1, 1), (1, 1, 1, 1), 0); del buf435  # reuse
        buf438 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_30, sub_30, add_42, sqrt_30, w_30], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_52.run(buf437, primals_136, buf438, 8192, 2048, grid=grid(8192), stream=stream0)
        # Topologically Sorted Source Nodes: [out_51], Original ATen: [aten.convolution]
        buf439 = extern_kernels.convolution(buf433, buf438, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf439, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf440 = buf415; del buf415  # reuse
        # Topologically Sorted Source Nodes: [input_16], Original ATen: [aten.add]
        triton_poi_fused_add_53.run(buf440, buf439, 131072, grid=grid(131072), stream=stream0)
        buf441 = buf430; del buf430  # reuse
        buf442 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf444 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_39], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_54.run(buf440, buf441, buf442, buf444, 128, 1024, grid=grid(128), stream=stream0)
        buf445 = buf439; del buf439  # reuse
        # Topologically Sorted Source Nodes: [group_norm_39, out_52], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_55.run(buf440, buf441, buf442, primals_137, primals_138, buf445, 131072, grid=grid(131072), stream=stream0)
        del primals_138
        buf447 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf449 = reinterpret_tensor(buf447, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf447  # reuse
        buf450 = empty_strided_cuda((2048, 8192, 1, 1), (8192, 1, 8192, 8192), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_31, sub_31, add_44, sqrt_31, w_31], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_56.run(buf449, primals_139, buf450, 2048, 8192, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_53], Original ATen: [aten.convolution]
        buf451 = extern_kernels.convolution(buf445, buf450, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf451, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf452 = buf442; del buf442  # reuse
        buf453 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf455 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_40], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_50.run(buf451, buf452, buf453, buf455, 128, 256, grid=grid(128), stream=stream0)
        buf456 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_40, relu_40], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_51.run(buf451, buf452, buf453, primals_140, primals_141, buf456, 32768, grid=grid(32768), stream=stream0)
        del primals_141
        # Topologically Sorted Source Nodes: [out_54], Original ATen: [aten.convolution]
        buf457 = extern_kernels.convolution(buf456, buf15, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf457, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf458 = buf457; del buf457  # reuse
        # Topologically Sorted Source Nodes: [out_54], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_49.run(buf458, primals_143, 32768, grid=grid(32768), stream=stream0)
        del primals_143
        buf459 = buf453; del buf453  # reuse
        buf460 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf462 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_41], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_50.run(buf458, buf459, buf460, buf462, 128, 256, grid=grid(128), stream=stream0)
        buf463 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_41, relu_41], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_51.run(buf458, buf459, buf460, primals_144, primals_145, buf463, 32768, grid=grid(32768), stream=stream0)
        del primals_145
        buf465 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192), torch.float32)
        buf467 = reinterpret_tensor(buf465, (8192, 1, 1, 1), (1, 1, 1, 1), 0); del buf465  # reuse
        buf468 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_32, sub_32, add_45, sqrt_32, w_32], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_52.run(buf467, primals_146, buf468, 8192, 2048, grid=grid(8192), stream=stream0)
        # Topologically Sorted Source Nodes: [out_55], Original ATen: [aten.convolution]
        buf469 = extern_kernels.convolution(buf463, buf468, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf469, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf470 = buf469; del buf469  # reuse
        # Topologically Sorted Source Nodes: [input_17], Original ATen: [aten.add]
        triton_poi_fused_add_57.run(buf470, buf440, 131072, grid=grid(131072), stream=stream0)
        buf471 = buf460; del buf460  # reuse
        buf472 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf474 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_42], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_54.run(buf470, buf471, buf472, buf474, 128, 1024, grid=grid(128), stream=stream0)
        buf475 = empty_strided_cuda((4, 8192, 2, 2), (32768, 1, 16384, 8192), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_42, out_56], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_55.run(buf470, buf471, buf472, primals_147, primals_148, buf475, 131072, grid=grid(131072), stream=stream0)
        del primals_148
        buf477 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf479 = reinterpret_tensor(buf477, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf477  # reuse
        buf480 = empty_strided_cuda((2048, 8192, 1, 1), (8192, 1, 8192, 8192), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_33, sub_33, add_47, sqrt_33, w_33], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_56.run(buf479, primals_149, buf480, 2048, 8192, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_57], Original ATen: [aten.convolution]
        buf481 = extern_kernels.convolution(buf475, buf480, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf481, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf482 = buf472; del buf472  # reuse
        buf483 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf485 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_43], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_50.run(buf481, buf482, buf483, buf485, 128, 256, grid=grid(128), stream=stream0)
        buf486 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_43, relu_43], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_51.run(buf481, buf482, buf483, primals_150, primals_151, buf486, 32768, grid=grid(32768), stream=stream0)
        del primals_151
        # Topologically Sorted Source Nodes: [out_58], Original ATen: [aten.convolution]
        buf487 = extern_kernels.convolution(buf486, buf16, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf487, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf488 = buf487; del buf487  # reuse
        # Topologically Sorted Source Nodes: [out_58], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_49.run(buf488, primals_153, 32768, grid=grid(32768), stream=stream0)
        del primals_153
        buf489 = buf483; del buf483  # reuse
        buf490 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf492 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_44], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_50.run(buf488, buf489, buf490, buf492, 128, 256, grid=grid(128), stream=stream0)
        buf493 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_44, relu_44], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_51.run(buf488, buf489, buf490, primals_154, primals_155, buf493, 32768, grid=grid(32768), stream=stream0)
        del primals_155
        buf495 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192), torch.float32)
        buf497 = reinterpret_tensor(buf495, (8192, 1, 1, 1), (1, 1, 1, 1), 0); del buf495  # reuse
        buf498 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_34, sub_34, add_48, sqrt_34, w_34], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_52.run(buf497, primals_156, buf498, 8192, 2048, grid=grid(8192), stream=stream0)
        # Topologically Sorted Source Nodes: [out_59], Original ATen: [aten.convolution]
        buf499 = extern_kernels.convolution(buf493, buf498, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf499, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf500 = buf499; del buf499  # reuse
        # Topologically Sorted Source Nodes: [input_18], Original ATen: [aten.add]
        triton_poi_fused_add_57.run(buf500, buf470, 131072, grid=grid(131072), stream=stream0)
        buf501 = buf490; del buf490  # reuse
        buf502 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf504 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_45], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_54.run(buf500, buf501, buf502, buf504, 128, 1024, grid=grid(128), stream=stream0)
        buf505 = empty_strided_cuda((4, 8192, 2, 2), (32768, 1, 16384, 8192), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_45, out_60], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_55.run(buf500, buf501, buf502, primals_157, primals_158, buf505, 131072, grid=grid(131072), stream=stream0)
        del primals_158
        buf507 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048), torch.float32)
        buf509 = reinterpret_tensor(buf507, (2048, 1, 1, 1), (1, 1, 1, 1), 0); del buf507  # reuse
        buf510 = empty_strided_cuda((2048, 8192, 1, 1), (8192, 1, 8192, 8192), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_35, sub_35, add_50, sqrt_35, w_35], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_56.run(buf509, primals_159, buf510, 2048, 8192, grid=grid(2048), stream=stream0)
        # Topologically Sorted Source Nodes: [out_61], Original ATen: [aten.convolution]
        buf511 = extern_kernels.convolution(buf505, buf510, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf511, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf512 = buf502; del buf502  # reuse
        buf513 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf515 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_46], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_50.run(buf511, buf512, buf513, buf515, 128, 256, grid=grid(128), stream=stream0)
        buf516 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_46, relu_46], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_51.run(buf511, buf512, buf513, primals_160, primals_161, buf516, 32768, grid=grid(32768), stream=stream0)
        del primals_161
        # Topologically Sorted Source Nodes: [out_62], Original ATen: [aten.convolution]
        buf517 = extern_kernels.convolution(buf516, buf17, stride=(1, 1), padding=(1, 1), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf517, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf518 = buf517; del buf517  # reuse
        # Topologically Sorted Source Nodes: [out_62], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_49.run(buf518, primals_163, 32768, grid=grid(32768), stream=stream0)
        del primals_163
        buf519 = buf513; del buf513  # reuse
        buf520 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf522 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_47], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_50.run(buf518, buf519, buf520, buf522, 128, 256, grid=grid(128), stream=stream0)
        buf523 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [group_norm_47, relu_47], Original ATen: [aten.native_group_norm, aten.relu]
        triton_poi_fused_native_group_norm_relu_51.run(buf518, buf519, buf520, primals_164, primals_165, buf523, 32768, grid=grid(32768), stream=stream0)
        del primals_165
        buf525 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192), torch.float32)
        buf527 = reinterpret_tensor(buf525, (8192, 1, 1, 1), (1, 1, 1, 1), 0); del buf525  # reuse
        buf528 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 2048), torch.float32)
        # Topologically Sorted Source Nodes: [var_mean_36, sub_36, add_51, sqrt_36, w_36], Original ATen: [aten.var_mean, aten.sub, aten.add, aten.sqrt, aten.div]
        triton_red_fused_add_div_sqrt_sub_var_mean_52.run(buf527, primals_166, buf528, 8192, 2048, grid=grid(8192), stream=stream0)
        # Topologically Sorted Source Nodes: [out_63], Original ATen: [aten.convolution]
        buf529 = extern_kernels.convolution(buf523, buf528, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf529, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf530 = buf529; del buf529  # reuse
        # Topologically Sorted Source Nodes: [input_19], Original ATen: [aten.add]
        triton_poi_fused_add_57.run(buf530, buf500, 131072, grid=grid(131072), stream=stream0)
        buf531 = reinterpret_tensor(buf520, (4, 32, 1, 1), (32, 1, 32, 32), 0); del buf520  # reuse
        buf532 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.float32)
        buf534 = reinterpret_tensor(buf532, (4, 32, 1, 1), (32, 1, 32, 32), 0); del buf532  # reuse
        # Topologically Sorted Source Nodes: [input_20], Original ATen: [aten.native_group_norm]
        triton_per_fused_native_group_norm_58.run(buf534, buf530, buf531, 128, 1024, grid=grid(128), stream=stream0)
        buf535 = empty_strided_cuda((4, 8192, 1, 1), (8192, 1, 8192, 8192), torch.float32)
        # Topologically Sorted Source Nodes: [input_20, input_21, input_22], Original ATen: [aten.native_group_norm, aten.relu, aten.mean]
        triton_poi_fused_mean_native_group_norm_relu_59.run(buf530, buf531, buf534, primals_167, primals_168, buf535, 32768, grid=grid(32768), stream=stream0)
        # Topologically Sorted Source Nodes: [input_23], Original ATen: [aten.convolution]
        buf536 = extern_kernels.convolution(buf535, primals_169, stride=(1, 1), padding=(0, 0), dilation=(1, 1), transposed=False, output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf536, (4, 21843, 1, 1), (21843, 1, 21843, 21843))
        buf537 = reinterpret_tensor(buf536, (4, 21843, 1, 1), (21843, 1, 1, 1), 0); del buf536  # reuse
        # Topologically Sorted Source Nodes: [input_23], Original ATen: [aten.convolution]
        triton_poi_fused_convolution_60.run(buf537, primals_170, 87372, grid=grid(87372), stream=stream0)
        del primals_170
    return (buf537, buf0, buf1, primals_3, primals_5, primals_6, primals_7, buf2, primals_11, primals_13, primals_14, primals_16, primals_17, buf3, primals_21, primals_23, primals_24, primals_26, primals_27, buf4, primals_31, primals_33, primals_34, primals_36, primals_37, buf5, primals_41, primals_43, primals_44, primals_46, primals_47, primals_48, buf6, primals_52, primals_54, primals_55, primals_57, primals_58, buf7, primals_62, primals_64, primals_65, primals_67, primals_68, buf8, primals_72, primals_74, primals_75, primals_77, primals_78, buf9, primals_82, primals_84, primals_85, primals_87, primals_88, primals_89, buf10, primals_93, primals_95, primals_96, primals_98, primals_99, buf11, primals_103, primals_105, primals_106, primals_108, primals_109, buf12, primals_113, primals_115, primals_116, primals_118, primals_119, buf13, primals_123, primals_125, primals_126, primals_128, primals_129, primals_130, buf14, primals_134, primals_136, primals_137, primals_139, primals_140, buf15, primals_144, primals_146, primals_147, primals_149, primals_150, buf16, primals_154, primals_156, primals_157, primals_159, primals_160, buf17, primals_164, primals_166, primals_167, primals_168, primals_169, buf21, buf22, buf24, buf25, buf26, reinterpret_tensor(buf27, (4, 32), (32, 1), 0), reinterpret_tensor(buf30, (4, 32), (32, 1), 0), buf31, buf35, buf36, buf41, buf42, buf43, reinterpret_tensor(buf44, (4, 32), (32, 1), 0), reinterpret_tensor(buf47, (4, 32), (32, 1), 0), buf48, buf50, reinterpret_tensor(buf51, (4, 32), (32, 1), 0), reinterpret_tensor(buf54, (4, 32), (32, 1), 0), buf55, buf59, buf60, buf62, reinterpret_tensor(buf63, (4, 32), (32, 1), 0), reinterpret_tensor(buf66, (4, 32), (32, 1), 0), buf67, buf71, buf72, buf73, reinterpret_tensor(buf74, (4, 32), (32, 1), 0), reinterpret_tensor(buf77, (4, 32), (32, 1), 0), buf78, buf80, reinterpret_tensor(buf81, (4, 32), (32, 1), 0), reinterpret_tensor(buf84, (4, 32), (32, 1), 0), buf85, buf89, buf90, buf92, reinterpret_tensor(buf93, (4, 32), (32, 1), 0), reinterpret_tensor(buf96, (4, 32), (32, 1), 0), buf97, buf101, buf102, buf103, reinterpret_tensor(buf104, (4, 32), (32, 1), 0), reinterpret_tensor(buf107, (4, 32), (32, 1), 0), buf108, buf110, reinterpret_tensor(buf111, (4, 32), (32, 1), 0), reinterpret_tensor(buf114, (4, 32), (32, 1), 0), buf115, buf119, buf120, buf122, reinterpret_tensor(buf123, (4, 32), (32, 1), 0), reinterpret_tensor(buf126, (4, 32), (32, 1), 0), buf127, buf131, buf132, buf133, reinterpret_tensor(buf134, (4, 32), (32, 1), 0), reinterpret_tensor(buf137, (4, 32), (32, 1), 0), buf138, buf140, reinterpret_tensor(buf141, (4, 32), (32, 1), 0), reinterpret_tensor(buf144, (4, 32), (32, 1), 0), buf145, buf149, buf150, buf152, reinterpret_tensor(buf153, (4, 32), (32, 1), 0), reinterpret_tensor(buf156, (4, 32), (32, 1), 0), buf157, buf161, buf162, buf167, buf168, buf169, reinterpret_tensor(buf170, (4, 32), (32, 1), 0), reinterpret_tensor(buf173, (4, 32), (32, 1), 0), buf174, buf176, reinterpret_tensor(buf177, (4, 32), (32, 1), 0), reinterpret_tensor(buf180, (4, 32), (32, 1), 0), buf181, buf185, buf186, buf188, reinterpret_tensor(buf189, (4, 32), (32, 1), 0), reinterpret_tensor(buf192, (4, 32), (32, 1), 0), buf193, buf197, buf198, buf199, reinterpret_tensor(buf200, (4, 32), (32, 1), 0), reinterpret_tensor(buf203, (4, 32), (32, 1), 0), buf204, buf206, reinterpret_tensor(buf207, (4, 32), (32, 1), 0), reinterpret_tensor(buf210, (4, 32), (32, 1), 0), buf211, buf215, buf216, buf218, reinterpret_tensor(buf219, (4, 32), (32, 1), 0), reinterpret_tensor(buf222, (4, 32), (32, 1), 0), buf223, buf227, buf228, buf229, reinterpret_tensor(buf230, (4, 32), (32, 1), 0), reinterpret_tensor(buf233, (4, 32), (32, 1), 0), buf234, buf236, reinterpret_tensor(buf237, (4, 32), (32, 1), 0), reinterpret_tensor(buf240, (4, 32), (32, 1), 0), buf241, buf245, buf246, buf248, reinterpret_tensor(buf249, (4, 32), (32, 1), 0), reinterpret_tensor(buf252, (4, 32), (32, 1), 0), buf253, buf257, buf258, buf259, reinterpret_tensor(buf260, (4, 32), (32, 1), 0), reinterpret_tensor(buf263, (4, 32), (32, 1), 0), buf264, buf266, reinterpret_tensor(buf267, (4, 32), (32, 1), 0), reinterpret_tensor(buf270, (4, 32), (32, 1), 0), buf271, buf275, buf276, buf278, reinterpret_tensor(buf279, (4, 32), (32, 1), 0), reinterpret_tensor(buf282, (4, 32), (32, 1), 0), buf283, buf287, buf288, buf293, buf294, buf295, reinterpret_tensor(buf296, (4, 32), (32, 1), 0), reinterpret_tensor(buf299, (4, 32), (32, 1), 0), buf300, buf302, reinterpret_tensor(buf303, (4, 32), (32, 1), 0), reinterpret_tensor(buf306, (4, 32), (32, 1), 0), buf307, buf311, buf312, buf314, reinterpret_tensor(buf315, (4, 32), (32, 1), 0), reinterpret_tensor(buf318, (4, 32), (32, 1), 0), buf319, buf323, buf324, buf325, reinterpret_tensor(buf326, (4, 32), (32, 1), 0), reinterpret_tensor(buf329, (4, 32), (32, 1), 0), buf330, buf332, reinterpret_tensor(buf333, (4, 32), (32, 1), 0), reinterpret_tensor(buf336, (4, 32), (32, 1), 0), buf337, buf341, buf342, buf344, reinterpret_tensor(buf345, (4, 32), (32, 1), 0), reinterpret_tensor(buf348, (4, 32), (32, 1), 0), buf349, buf353, buf354, buf355, reinterpret_tensor(buf356, (4, 32), (32, 1), 0), reinterpret_tensor(buf359, (4, 32), (32, 1), 0), buf360, buf362, reinterpret_tensor(buf363, (4, 32), (32, 1), 0), reinterpret_tensor(buf366, (4, 32), (32, 1), 0), buf367, buf371, buf372, buf374, reinterpret_tensor(buf375, (4, 32), (32, 1), 0), reinterpret_tensor(buf378, (4, 32), (32, 1), 0), buf379, buf383, buf384, buf385, reinterpret_tensor(buf386, (4, 32), (32, 1), 0), reinterpret_tensor(buf389, (4, 32), (32, 1), 0), buf390, buf392, reinterpret_tensor(buf393, (4, 32), (32, 1), 0), reinterpret_tensor(buf396, (4, 32), (32, 1), 0), buf397, buf401, buf402, buf404, reinterpret_tensor(buf405, (4, 32), (32, 1), 0), reinterpret_tensor(buf408, (4, 32), (32, 1), 0), buf409, buf413, buf414, buf419, buf420, buf421, reinterpret_tensor(buf422, (4, 32), (32, 1), 0), reinterpret_tensor(buf425, (4, 32), (32, 1), 0), buf426, buf428, reinterpret_tensor(buf429, (4, 32), (32, 1), 0), reinterpret_tensor(buf432, (4, 32), (32, 1), 0), buf433, buf437, buf438, buf440, reinterpret_tensor(buf441, (4, 32), (32, 1), 0), reinterpret_tensor(buf444, (4, 32), (32, 1), 0), buf445, buf449, buf450, buf451, reinterpret_tensor(buf452, (4, 32), (32, 1), 0), reinterpret_tensor(buf455, (4, 32), (32, 1), 0), buf456, buf458, reinterpret_tensor(buf459, (4, 32), (32, 1), 0), reinterpret_tensor(buf462, (4, 32), (32, 1), 0), buf463, buf467, buf468, buf470, reinterpret_tensor(buf471, (4, 32), (32, 1), 0), reinterpret_tensor(buf474, (4, 32), (32, 1), 0), buf475, buf479, buf480, buf481, reinterpret_tensor(buf482, (4, 32), (32, 1), 0), reinterpret_tensor(buf485, (4, 32), (32, 1), 0), buf486, buf488, reinterpret_tensor(buf489, (4, 32), (32, 1), 0), reinterpret_tensor(buf492, (4, 32), (32, 1), 0), buf493, buf497, buf498, buf500, reinterpret_tensor(buf501, (4, 32), (32, 1), 0), reinterpret_tensor(buf504, (4, 32), (32, 1), 0), buf505, buf509, buf510, buf511, reinterpret_tensor(buf512, (4, 32), (32, 1), 0), reinterpret_tensor(buf515, (4, 32), (32, 1), 0), buf516, buf518, reinterpret_tensor(buf519, (4, 32), (32, 1), 0), reinterpret_tensor(buf522, (4, 32), (32, 1), 0), buf523, buf527, buf528, buf530, buf531, buf534, buf535, )


def benchmark_compiled_module(times=10, repeat=10):
    from torch._dynamo.testing import rand_strided
    from torch._inductor.utils import print_performance
    primals_1 = rand_strided((256, 3, 7, 7), (147, 49, 7, 1), device='cuda:0', dtype=torch.float32)
    primals_2 = rand_strided((4, 3, 64, 64), (12288, 4096, 64, 1), device='cuda:0', dtype=torch.float32)
    primals_3 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_4 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_5 = rand_strided((1024, 256, 1, 1), (256, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_6 = rand_strided((256, 256, 1, 1), (256, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_7 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_8 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_9 = rand_strided((256, 256, 3, 3), (2304, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_10 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_11 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_12 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_13 = rand_strided((1024, 256, 1, 1), (256, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_14 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_15 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_16 = rand_strided((256, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_17 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_18 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_19 = rand_strided((256, 256, 3, 3), (2304, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_20 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_21 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_22 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_23 = rand_strided((1024, 256, 1, 1), (256, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_24 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_25 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_26 = rand_strided((256, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_27 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_28 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_29 = rand_strided((256, 256, 3, 3), (2304, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_30 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_31 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_32 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_33 = rand_strided((1024, 256, 1, 1), (256, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_34 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_35 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_36 = rand_strided((256, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_37 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_38 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_39 = rand_strided((256, 256, 3, 3), (2304, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_40 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_41 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_42 = rand_strided((256, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_43 = rand_strided((1024, 256, 1, 1), (256, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_44 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_45 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_46 = rand_strided((2048, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_47 = rand_strided((512, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_48 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_49 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_50 = rand_strided((512, 512, 3, 3), (4608, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_51 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_52 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_53 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_54 = rand_strided((2048, 512, 1, 1), (512, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_55 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_56 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_57 = rand_strided((512, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_58 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_59 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_60 = rand_strided((512, 512, 3, 3), (4608, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_61 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_62 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_63 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_64 = rand_strided((2048, 512, 1, 1), (512, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_65 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_66 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_67 = rand_strided((512, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_68 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_69 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_70 = rand_strided((512, 512, 3, 3), (4608, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_71 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_72 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_73 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_74 = rand_strided((2048, 512, 1, 1), (512, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_75 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_76 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_77 = rand_strided((512, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_78 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_79 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_80 = rand_strided((512, 512, 3, 3), (4608, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_81 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_82 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_83 = rand_strided((512, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_84 = rand_strided((2048, 512, 1, 1), (512, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_85 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_86 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_87 = rand_strided((4096, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_88 = rand_strided((1024, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_89 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_90 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_91 = rand_strided((1024, 1024, 3, 3), (9216, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_92 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_93 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_94 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_95 = rand_strided((4096, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_96 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_97 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_98 = rand_strided((1024, 4096, 1, 1), (4096, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_99 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_100 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_101 = rand_strided((1024, 1024, 3, 3), (9216, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_102 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_103 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_104 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_105 = rand_strided((4096, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_106 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_107 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_108 = rand_strided((1024, 4096, 1, 1), (4096, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_109 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_110 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_111 = rand_strided((1024, 1024, 3, 3), (9216, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_112 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_113 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_114 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_115 = rand_strided((4096, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_116 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_117 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_118 = rand_strided((1024, 4096, 1, 1), (4096, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_119 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_120 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_121 = rand_strided((1024, 1024, 3, 3), (9216, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_122 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_123 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_124 = rand_strided((1024, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_125 = rand_strided((4096, 1024, 1, 1), (1024, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_126 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_127 = rand_strided((4096, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_128 = rand_strided((8192, 4096, 1, 1), (4096, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_129 = rand_strided((2048, 4096, 1, 1), (4096, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_130 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_131 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_132 = rand_strided((2048, 2048, 3, 3), (18432, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_133 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_134 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_135 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_136 = rand_strided((8192, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_137 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_138 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_139 = rand_strided((2048, 8192, 1, 1), (8192, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_140 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_141 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_142 = rand_strided((2048, 2048, 3, 3), (18432, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_143 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_144 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_145 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_146 = rand_strided((8192, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_147 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_148 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_149 = rand_strided((2048, 8192, 1, 1), (8192, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_150 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_151 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_152 = rand_strided((2048, 2048, 3, 3), (18432, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_153 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_154 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_155 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_156 = rand_strided((8192, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_157 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_158 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_159 = rand_strided((2048, 8192, 1, 1), (8192, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_160 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_161 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_162 = rand_strided((2048, 2048, 3, 3), (18432, 9, 3, 1), device='cuda:0', dtype=torch.float32)
    primals_163 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_164 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_165 = rand_strided((2048, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_166 = rand_strided((8192, 2048, 1, 1), (2048, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_167 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_168 = rand_strided((8192, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_169 = rand_strided((21843, 8192, 1, 1), (8192, 1, 1, 1), device='cuda:0', dtype=torch.float32)
    primals_170 = rand_strided((21843, ), (1, ), device='cuda:0', dtype=torch.float32)
    fn = lambda: 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, primals_122, primals_123, primals_124, primals_125, primals_126, primals_127, primals_128, primals_129, primals_130, primals_131, primals_132, primals_133, primals_134, primals_135, primals_136, primals_137, primals_138, primals_139, primals_140, primals_141, primals_142, primals_143, primals_144, primals_145, primals_146, primals_147, primals_148, primals_149, primals_150, primals_151, primals_152, primals_153, primals_154, primals_155, primals_156, primals_157, primals_158, primals_159, primals_160, primals_161, primals_162, primals_163, primals_164, primals_165, primals_166, primals_167, primals_168, primals_169, primals_170])
    return print_performance(fn, times=times, repeat=repeat)


if __name__ == "__main__":
    from torch._inductor.wrapper_benchmark import compiled_module_main
    compiled_module_main('None', benchmark_compiled_module)

import torch
import torch.nn as nn
import torch.nn.functional as F
from collections import OrderedDict
import torch.utils.data


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


def conv3x3(in_planes, out_planes, stride=1):
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
        padding=1, bias=True)


def tf2th(conv_weights):
    """Possibly convert HWIO to OIHW."""
    if conv_weights.ndim == 4:
        conv_weights = conv_weights.transpose([3, 2, 0, 1])
    return torch.from_numpy(conv_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-10)
        return F.conv2d(x, w, self.bias, self.stride, self.padding, self.
            dilation, self.groups)


class PreActBottleneck(nn.Module):
    """Pre-activation (v2) bottleneck block.
  Follows the implementation of "Identity Mappings in Deep Residual Networks":
  https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua
  Except it puts the stride on 3x3 conv when available.
  """

    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, cin)
        self.conv1 = conv1x1(cin, cmid)
        self.gn2 = nn.GroupNorm(32, cmid)
        self.conv2 = conv3x3(cmid, cmid, stride)
        self.gn3 = nn.GroupNorm(32, cmid)
        self.conv3 = conv1x1(cmid, cout)
        self.relu = nn.ReLU(inplace=True)
        if stride != 1 or cin != cout:
            self.downsample = conv1x1(cin, cout, stride)

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

    def load_from(self, weights, prefix=''):
        convname = 'standardized_conv2d'
        with torch.no_grad():
            self.conv1.weight.copy_(tf2th(weights[
                f'{prefix}a/{convname}/kernel']))
            self.conv2.weight.copy_(tf2th(weights[
                f'{prefix}b/{convname}/kernel']))
            self.conv3.weight.copy_(tf2th(weights[
                f'{prefix}c/{convname}/kernel']))
            self.gn1.weight.copy_(tf2th(weights[f'{prefix}a/group_norm/gamma'])
                )
            self.gn2.weight.copy_(tf2th(weights[f'{prefix}b/group_norm/gamma'])
                )
            self.gn3.weight.copy_(tf2th(weights[f'{prefix}c/group_norm/gamma'])
                )
            self.gn1.bias.copy_(tf2th(weights[f'{prefix}a/group_norm/beta']))
            self.gn2.bias.copy_(tf2th(weights[f'{prefix}b/group_norm/beta']))
            self.gn3.bias.copy_(tf2th(weights[f'{prefix}c/group_norm/beta']))
            if hasattr(self, 'downsample'):
                w = weights[f'{prefix}a/proj/{convname}/kernel']
                self.downsample.weight.copy_(tf2th(w))


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

    def __init__(self, block_units, width_factor, head_size=21843,
        zero_head=False):
        super().__init__()
        wf = width_factor
        self.wf = wf
        self.root = nn.Sequential(OrderedDict([('conv', StdConv2d(3, 64 *
            wf, kernel_size=7, stride=2, padding=3, bias=False)), ('pad',
            nn.ConstantPad2d(1, 0)), ('pool', nn.MaxPool2d(kernel_size=3,
            stride=2, padding=0))]))
        self.body = nn.Sequential(OrderedDict([('block1', nn.Sequential(
            OrderedDict([('unit01', PreActBottleneck(cin=64 * wf, cout=256 *
            wf, cmid=64 * wf))] + [(f'unit{i:02d}', PreActBottleneck(cin=
            256 * wf, cout=256 * wf, cmid=64 * wf)) for i in range(2, 
            block_units[0] + 1)]))), ('block2', nn.Sequential(OrderedDict([
            ('unit01', PreActBottleneck(cin=256 * wf, cout=512 * wf, cmid=
            128 * wf, stride=2))] + [(f'unit{i:02d}', PreActBottleneck(cin=
            512 * wf, cout=512 * wf, cmid=128 * wf)) for i in range(2, 
            block_units[1] + 1)]))), ('block3', nn.Sequential(OrderedDict([
            ('unit01', PreActBottleneck(cin=512 * wf, cout=1024 * wf, cmid=
            256 * wf, stride=2))] + [(f'unit{i:02d}', PreActBottleneck(cin=
            1024 * wf, cout=1024 * wf, cmid=256 * wf)) for i in range(2, 
            block_units[2] + 1)]))), ('block4', nn.Sequential(OrderedDict([
            ('unit01', PreActBottleneck(cin=1024 * wf, cout=2048 * wf, cmid
            =512 * wf, stride=2))] + [(f'unit{i:02d}', PreActBottleneck(cin
            =2048 * wf, cout=2048 * wf, cmid=512 * wf)) for i in range(2, 
            block_units[3] + 1)])))]))
        self.zero_head = zero_head
        self.head = nn.Sequential(OrderedDict([('gn', nn.GroupNorm(32, 2048 *
            wf)), ('relu', nn.ReLU(inplace=True)), ('avg', nn.
            AdaptiveAvgPool2d(output_size=1)), ('conv', nn.Conv2d(2048 * wf,
            head_size, kernel_size=1, bias=True))]))

    def forward(self, x):
        x = self.head(self.body(self.root(x)))
        return x

    def load_from(self, weights, prefix='resnet/'):
        with torch.no_grad():
            self.root.conv.weight.copy_(tf2th(weights[
                f'{prefix}root_block/standardized_conv2d/kernel']))
            self.head.gn.weight.copy_(tf2th(weights[
                f'{prefix}group_norm/gamma']))
            self.head.gn.bias.copy_(tf2th(weights[f'{prefix}group_norm/beta']))
            if self.zero_head:
                nn.init.zeros_(self.head.conv.weight)
                nn.init.zeros_(self.head.conv.bias)
            else:
                self.head.conv.weight.copy_(tf2th(weights[
                    f'{prefix}head/conv2d/kernel']))
                self.head.conv.bias.copy_(tf2th(weights[
                    f'{prefix}head/conv2d/bias']))
            for bname, block in self.body.named_children():
                for uname, unit in block.named_children():
                    unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/')


def get_inputs():
    return [torch.rand([4, 3, 64, 64])]


def get_init_inputs():
    return [[], {'block_units': [4, 4, 4, 4], 'width_factor': 4}]

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
import torch.nn as nn
import torch.nn.functional as F
from collections import OrderedDict
import torch.utils.data
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_poi_fused_5(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 % 2048
    y1 = yindex // 2048
    tmp0 = tl.load(in_ptr0 + (x2 + 9 * y3), xmask, eviction_policy='evict_last'
        )
    tl.store(out_ptr0 + (y0 + 2048 * x2 + 18432 * y1), tmp0, xmask)


@triton.jit
def triton_per_fused_add_div_sqrt_sub_var_mean_6(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-10
    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_poi_fused_constant_pad_nd_7(in_ptr0, out_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x2 = xindex // 8704 % 34
    x1 = xindex // 256 % 34
    x3 = xindex // 295936
    x4 = xindex % 8704
    x6 = xindex
    tmp0 = -1 + x2
    tmp1 = tl.full([1], 0, tl.int64)
    tmp2 = tmp0 >= tmp1
    tmp3 = tl.full([1], 32, tl.int64)
    tmp4 = tmp0 < tmp3
    tmp5 = -1 + x1
    tmp6 = tmp5 >= tmp1
    tmp7 = tmp5 < tmp3
    tmp8 = tmp2 & tmp4
    tmp9 = tmp8 & tmp6
    tmp10 = tmp9 & tmp7
    tmp11 = tl.load(in_ptr0 + (-8448 + x4 + 8192 * x2 + 262144 * x3), tmp10,
        other=0.0)
    tl.store(out_ptr0 + x6, tmp11, None)


@triton.jit
def triton_poi_fused_max_pool2d_with_indices_8(in_ptr0, out_ptr0, out_ptr1,
    xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex % 256
    x1 = xindex // 256 % 16
    x2 = xindex // 4096 % 16
    x3 = xindex // 65536
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + 512 * x1 + 17408 * x2 + 295936 * x3), None)
    tmp1 = tl.load(in_ptr0 + (256 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    tmp3 = tl.load(in_ptr0 + (512 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    tmp5 = tl.load(in_ptr0 + (8704 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    tmp7 = tl.load(in_ptr0 + (8960 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    tmp9 = tl.load(in_ptr0 + (9216 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    tmp11 = tl.load(in_ptr0 + (17408 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    tmp13 = tl.load(in_ptr0 + (17664 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    tmp15 = tl.load(in_ptr0 + (17920 + x0 + 512 * x1 + 17408 * x2 + 295936 *
        x3), None)
    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, None)
    tl.store(out_ptr1 + x4, tmp41, None)


@triton.jit
def triton_red_fused_native_group_norm_9(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 % 8
        r3 = rindex // 8
        tmp0 = tl.load(in_ptr0 + (r2 + 8 * x0 + 256 * 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_10(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 // 65536
    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 = 2048.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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_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-10
    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_add_div_sqrt_sub_var_mean_12(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-10
    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_poi_fused_convolution_13(in_out_ptr0, in_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 256
    tmp0 = tl.load(in_out_ptr0 + x2, None)
    tmp1 = tl.load(in_ptr0 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x2, tmp2, None)


@triton.jit
def triton_poi_fused_add_14(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0, None)
    tmp1 = tl.load(in_out_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, None)


@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 = 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 % 32
        r3 = rindex // 32
        tmp0 = tl.load(in_ptr0 + (r2 + 32 * x0 + 1024 * 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_16(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 // 262144
    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 = 8192.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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_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-10
    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_18(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + x0, None)
    tmp1 = tl.load(in_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, 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-10
    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_add_div_sqrt_sub_var_mean_20(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-10
    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_21(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 % 16
        r3 = rindex // 16
        tmp0 = tl.load(in_ptr0 + (r2 + 16 * x0 + 512 * 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_22(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 // 131072
    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 = 4096.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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_convolution_23(in_out_ptr0, in_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 512
    tmp0 = tl.load(in_out_ptr0 + x2, None)
    tmp1 = tl.load(in_ptr0 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x2, tmp2, None)


@triton.jit
def triton_per_fused_native_group_norm_24(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-05
    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_25(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-05
    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_26(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-10
    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_poi_fused_add_27(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0, None)
    tmp1 = tl.load(in_out_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_29(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 % 2048
    x2 = xindex // 131072
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 64), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 64), 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 = 4096.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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_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-10
    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_31(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + x0, None)
    tmp1 = tl.load(in_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, 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-10
    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_red_fused_add_div_sqrt_sub_var_mean_33(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-10
    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_34(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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_35(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-05
    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_convolution_36(in_out_ptr0, in_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 1024
    tmp0 = tl.load(in_out_ptr0 + x2, None)
    tmp1 = tl.load(in_ptr0 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x2, tmp2, None)


@triton.jit
def triton_per_fused_native_group_norm_37(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-05
    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_38(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-05
    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_39(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-10
    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_40(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0, None)
    tmp1 = tl.load(in_out_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, 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-05
    tmp8 = tmp6 + tmp7
    tmp9 = libdevice.rsqrt(tmp8)
    tl.store(out_ptr2 + x4, tmp9, xmask)


@triton.jit
def triton_poi_fused_native_group_norm_relu_42(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 % 4096
    x2 = xindex // 65536
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 128), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 128), 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-05
    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_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-10
    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_44(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + x0, None)
    tmp1 = tl.load(in_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, None)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_45(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    rnumel = 4096
    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 + 4096 * 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 = 4096.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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 + 4096 * x0), rmask, eviction_policy=
            'evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 4096 * x0), tmp12, rmask)


@triton.jit
def triton_red_fused_add_div_sqrt_sub_var_mean_46(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    rnumel = 4096
    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 + 4096 * 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 = 4096.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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 + 4096 * x0), rmask, eviction_policy=
            'evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 4096 * x0), tmp12, rmask)


@triton.jit
def triton_per_fused_native_group_norm_47(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 % 64
    r3 = rindex // 64
    x0 = xindex % 32
    x1 = xindex // 32
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + 64 * x0 + 2048 * 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-05
    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_48(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 % 2048
    x2 = xindex // 32768
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 64), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 64), 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-05
    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_convolution_49(in_out_ptr0, in_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x2 = xindex
    x0 = xindex % 2048
    tmp0 = tl.load(in_out_ptr0 + x2, None)
    tmp1 = tl.load(in_ptr0 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x2, tmp2, None)


@triton.jit
def triton_per_fused_native_group_norm_50(in_ptr0, out_ptr0, out_ptr1,
    out_ptr2, 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)
    r2 = rindex % 64
    r3 = rindex // 64
    x0 = xindex % 32
    x1 = xindex // 32
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + 64 * x0 + 2048 * r3 + 8192 * 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], 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.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_51(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 % 2048
    x2 = xindex // 8192
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 64), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 64), 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 = 256.0
    tmp5 = tmp3 / tmp4
    tmp6 = 1e-05
    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_52(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-10
    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_poi_fused_add_53(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0, None)
    tmp1 = tl.load(in_out_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, None)


@triton.jit
def triton_per_fused_native_group_norm_54(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 % 256
    r3 = rindex // 256
    x0 = xindex % 32
    x1 = xindex // 32
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + 256 * x0 + 8192 * 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-05
    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_55(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 % 8192
    x2 = xindex // 32768
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + (32 * x2 + x0 // 256), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr2 + (32 * x2 + x0 // 256), 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-05
    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_56(in_out_ptr0, in_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    rnumel = 8192
    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 + 8192 * 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 = 8192.0
    tmp6 = tmp3 / tmp5
    tmp7 = 1e-10
    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 + 8192 * x0), rmask, eviction_policy=
            'evict_first', other=0.0)
        tmp11 = tmp10 - tmp2
        tmp12 = tmp11 / tmp9
        tl.store(out_ptr1 + (r1 + 8192 * x0), tmp12, rmask)


@triton.jit
def triton_poi_fused_add_57(in_out_ptr0, in_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x0 = xindex
    tmp0 = tl.load(in_out_ptr0 + x0, None)
    tmp1 = tl.load(in_ptr0 + x0, None)
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x0, tmp2, None)


@triton.jit
def triton_per_fused_native_group_norm_58(in_out_ptr0, in_ptr0, out_ptr0,
    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 % 256
    r3 = rindex // 256
    x0 = xindex % 32
    x1 = xindex // 32
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + (r2 + 256 * x0 + 8192 * 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-05
    tmp17 = tmp15 + tmp16
    tmp18 = libdevice.rsqrt(tmp17)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x4, tmp18, None)
    tl.store(out_ptr0 + x4, tmp8, None)


@triton.jit
def triton_poi_fused_mean_native_group_norm_relu_59(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)
    x0 = xindex % 8192
    x1 = xindex // 8192
    x2 = xindex
    tmp0 = tl.load(in_ptr0 + (x0 + 32768 * x1), None)
    tmp1 = tl.load(in_ptr1 + x2 // 256, None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + x2 // 256, None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr3 + x0, None, eviction_policy='evict_last')
    tmp7 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp11 = tl.load(in_ptr0 + (8192 + x0 + 32768 * x1), None)
    tmp18 = tl.load(in_ptr0 + (16384 + x0 + 32768 * x1), None)
    tmp25 = tl.load(in_ptr0 + (24576 + x0 + 32768 * x1), None)
    tmp2 = tmp0 - tmp1
    tmp4 = tmp2 * tmp3
    tmp6 = tmp4 * tmp5
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 0, tl.int32)
    tmp10 = triton_helpers.maximum(tmp9, tmp8)
    tmp12 = tmp11 - tmp1
    tmp13 = tmp12 * tmp3
    tmp14 = tmp13 * tmp5
    tmp15 = tmp14 + tmp7
    tmp16 = triton_helpers.maximum(tmp9, tmp15)
    tmp17 = tmp10 + tmp16
    tmp19 = tmp18 - tmp1
    tmp20 = tmp19 * tmp3
    tmp21 = tmp20 * tmp5
    tmp22 = tmp21 + tmp7
    tmp23 = triton_helpers.maximum(tmp9, tmp22)
    tmp24 = tmp17 + tmp23
    tmp26 = tmp25 - tmp1
    tmp27 = tmp26 * tmp3
    tmp28 = tmp27 * tmp5
    tmp29 = tmp28 + tmp7
    tmp30 = triton_helpers.maximum(tmp9, tmp29)
    tmp31 = tmp24 + tmp30
    tmp32 = 4.0
    tmp33 = tmp31 / tmp32
    tl.store(out_ptr0 + x2, tmp33, None)


@triton.jit
def triton_poi_fused_convolution_60(in_out_ptr0, in_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xnumel = 87372
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x2 = xindex
    x0 = xindex % 21843
    tmp0 = tl.load(in_out_ptr0 + x2, xmask)
    tmp1 = tl.load(in_ptr0 + x0, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x2, 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, primals_122,
        primals_123, primals_124, primals_125, primals_126, primals_127,
        primals_128, primals_129, primals_130, primals_131, primals_132,
        primals_133, primals_134, primals_135, primals_136, primals_137,
        primals_138, primals_139, primals_140, primals_141, primals_142,
        primals_143, primals_144, primals_145, primals_146, primals_147,
        primals_148, primals_149, primals_150, primals_151, primals_152,
        primals_153, primals_154, primals_155, primals_156, primals_157,
        primals_158, primals_159, primals_160, primals_161, primals_162,
        primals_163, primals_164, primals_165, primals_166, primals_167,
        primals_168, primals_169, primals_170) = 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, (256, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_7, (256,), (1,))
    assert_size_stride(primals_8, (256,), (1,))
    assert_size_stride(primals_9, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_10, (256,), (1,))
    assert_size_stride(primals_11, (256,), (1,))
    assert_size_stride(primals_12, (256,), (1,))
    assert_size_stride(primals_13, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_14, (1024,), (1,))
    assert_size_stride(primals_15, (1024,), (1,))
    assert_size_stride(primals_16, (256, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_17, (256,), (1,))
    assert_size_stride(primals_18, (256,), (1,))
    assert_size_stride(primals_19, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_20, (256,), (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, (256,), (1,))
    assert_size_stride(primals_33, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_34, (1024,), (1,))
    assert_size_stride(primals_35, (1024,), (1,))
    assert_size_stride(primals_36, (256, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_37, (256,), (1,))
    assert_size_stride(primals_38, (256,), (1,))
    assert_size_stride(primals_39, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_40, (256,), (1,))
    assert_size_stride(primals_41, (256,), (1,))
    assert_size_stride(primals_42, (256,), (1,))
    assert_size_stride(primals_43, (1024, 256, 1, 1), (256, 1, 1, 1))
    assert_size_stride(primals_44, (1024,), (1,))
    assert_size_stride(primals_45, (1024,), (1,))
    assert_size_stride(primals_46, (2048, 1024, 1, 1), (1024, 1, 1, 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, (512,), (1,))
    assert_size_stride(primals_54, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_55, (2048,), (1,))
    assert_size_stride(primals_56, (2048,), (1,))
    assert_size_stride(primals_57, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_58, (512,), (1,))
    assert_size_stride(primals_59, (512,), (1,))
    assert_size_stride(primals_60, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_61, (512,), (1,))
    assert_size_stride(primals_62, (512,), (1,))
    assert_size_stride(primals_63, (512,), (1,))
    assert_size_stride(primals_64, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_65, (2048,), (1,))
    assert_size_stride(primals_66, (2048,), (1,))
    assert_size_stride(primals_67, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_68, (512,), (1,))
    assert_size_stride(primals_69, (512,), (1,))
    assert_size_stride(primals_70, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_71, (512,), (1,))
    assert_size_stride(primals_72, (512,), (1,))
    assert_size_stride(primals_73, (512,), (1,))
    assert_size_stride(primals_74, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_75, (2048,), (1,))
    assert_size_stride(primals_76, (2048,), (1,))
    assert_size_stride(primals_77, (512, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_78, (512,), (1,))
    assert_size_stride(primals_79, (512,), (1,))
    assert_size_stride(primals_80, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_81, (512,), (1,))
    assert_size_stride(primals_82, (512,), (1,))
    assert_size_stride(primals_83, (512,), (1,))
    assert_size_stride(primals_84, (2048, 512, 1, 1), (512, 1, 1, 1))
    assert_size_stride(primals_85, (2048,), (1,))
    assert_size_stride(primals_86, (2048,), (1,))
    assert_size_stride(primals_87, (4096, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_88, (1024, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_89, (1024,), (1,))
    assert_size_stride(primals_90, (1024,), (1,))
    assert_size_stride(primals_91, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_92, (1024,), (1,))
    assert_size_stride(primals_93, (1024,), (1,))
    assert_size_stride(primals_94, (1024,), (1,))
    assert_size_stride(primals_95, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_96, (4096,), (1,))
    assert_size_stride(primals_97, (4096,), (1,))
    assert_size_stride(primals_98, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_99, (1024,), (1,))
    assert_size_stride(primals_100, (1024,), (1,))
    assert_size_stride(primals_101, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_102, (1024,), (1,))
    assert_size_stride(primals_103, (1024,), (1,))
    assert_size_stride(primals_104, (1024,), (1,))
    assert_size_stride(primals_105, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_106, (4096,), (1,))
    assert_size_stride(primals_107, (4096,), (1,))
    assert_size_stride(primals_108, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_109, (1024,), (1,))
    assert_size_stride(primals_110, (1024,), (1,))
    assert_size_stride(primals_111, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_112, (1024,), (1,))
    assert_size_stride(primals_113, (1024,), (1,))
    assert_size_stride(primals_114, (1024,), (1,))
    assert_size_stride(primals_115, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_116, (4096,), (1,))
    assert_size_stride(primals_117, (4096,), (1,))
    assert_size_stride(primals_118, (1024, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_119, (1024,), (1,))
    assert_size_stride(primals_120, (1024,), (1,))
    assert_size_stride(primals_121, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_122, (1024,), (1,))
    assert_size_stride(primals_123, (1024,), (1,))
    assert_size_stride(primals_124, (1024,), (1,))
    assert_size_stride(primals_125, (4096, 1024, 1, 1), (1024, 1, 1, 1))
    assert_size_stride(primals_126, (4096,), (1,))
    assert_size_stride(primals_127, (4096,), (1,))
    assert_size_stride(primals_128, (8192, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_129, (2048, 4096, 1, 1), (4096, 1, 1, 1))
    assert_size_stride(primals_130, (2048,), (1,))
    assert_size_stride(primals_131, (2048,), (1,))
    assert_size_stride(primals_132, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_133, (2048,), (1,))
    assert_size_stride(primals_134, (2048,), (1,))
    assert_size_stride(primals_135, (2048,), (1,))
    assert_size_stride(primals_136, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_137, (8192,), (1,))
    assert_size_stride(primals_138, (8192,), (1,))
    assert_size_stride(primals_139, (2048, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_140, (2048,), (1,))
    assert_size_stride(primals_141, (2048,), (1,))
    assert_size_stride(primals_142, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_143, (2048,), (1,))
    assert_size_stride(primals_144, (2048,), (1,))
    assert_size_stride(primals_145, (2048,), (1,))
    assert_size_stride(primals_146, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_147, (8192,), (1,))
    assert_size_stride(primals_148, (8192,), (1,))
    assert_size_stride(primals_149, (2048, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_150, (2048,), (1,))
    assert_size_stride(primals_151, (2048,), (1,))
    assert_size_stride(primals_152, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_153, (2048,), (1,))
    assert_size_stride(primals_154, (2048,), (1,))
    assert_size_stride(primals_155, (2048,), (1,))
    assert_size_stride(primals_156, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_157, (8192,), (1,))
    assert_size_stride(primals_158, (8192,), (1,))
    assert_size_stride(primals_159, (2048, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_160, (2048,), (1,))
    assert_size_stride(primals_161, (2048,), (1,))
    assert_size_stride(primals_162, (2048, 2048, 3, 3), (18432, 9, 3, 1))
    assert_size_stride(primals_163, (2048,), (1,))
    assert_size_stride(primals_164, (2048,), (1,))
    assert_size_stride(primals_165, (2048,), (1,))
    assert_size_stride(primals_166, (8192, 2048, 1, 1), (2048, 1, 1, 1))
    assert_size_stride(primals_167, (8192,), (1,))
    assert_size_stride(primals_168, (8192,), (1,))
    assert_size_stride(primals_169, (21843, 8192, 1, 1), (8192, 1, 1, 1))
    assert_size_stride(primals_170, (21843,), (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_9, buf2, 65536, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_9
        buf3 = empty_strided_cuda((256, 256, 3, 3), (2304, 1, 768, 256),
            torch.float32)
        triton_poi_fused_2[grid(65536, 9)](primals_19, buf3, 65536, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_19
        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_39, buf5, 65536, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_39
        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_60, buf7, 262144, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_60
        buf8 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_poi_fused_3[grid(262144, 9)](primals_70, buf8, 262144, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_70
        buf9 = empty_strided_cuda((512, 512, 3, 3), (4608, 1, 1536, 512),
            torch.float32)
        triton_poi_fused_3[grid(262144, 9)](primals_80, buf9, 262144, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_80
        buf10 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_91, buf10, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_91
        buf11 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_101, buf11, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_101
        buf12 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_111, buf12, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_111
        buf13 = empty_strided_cuda((1024, 1024, 3, 3), (9216, 1, 3072, 1024
            ), torch.float32)
        triton_poi_fused_4[grid(1048576, 9)](primals_121, buf13, 1048576, 9,
            XBLOCK=16, YBLOCK=64, num_warps=4, num_stages=1)
        del primals_121
        buf14 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 
            2048), torch.float32)
        triton_poi_fused_5[grid(4194304, 9)](primals_132, buf14, 4194304, 9,
            XBLOCK=16, YBLOCK=128, num_warps=8, num_stages=1)
        del primals_132
        buf15 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 
            2048), torch.float32)
        triton_poi_fused_5[grid(4194304, 9)](primals_142, buf15, 4194304, 9,
            XBLOCK=16, YBLOCK=128, num_warps=8, num_stages=1)
        del primals_142
        buf16 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 
            2048), torch.float32)
        triton_poi_fused_5[grid(4194304, 9)](primals_152, buf16, 4194304, 9,
            XBLOCK=16, YBLOCK=128, num_warps=8, num_stages=1)
        del primals_152
        buf17 = empty_strided_cuda((2048, 2048, 3, 3), (18432, 1, 6144, 
            2048), torch.float32)
        triton_poi_fused_5[grid(4194304, 9)](primals_162, buf17, 4194304, 9,
            XBLOCK=16, YBLOCK=128, num_warps=8, num_stages=1)
        del primals_162
        buf19 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf21 = reinterpret_tensor(buf19, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf19
        buf22 = empty_strided_cuda((256, 3, 7, 7), (147, 1, 21, 3), torch.
            float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_6[grid(256)](buf21, buf0,
            buf22, 256, 147, XBLOCK=1, num_warps=2, num_stages=1)
        buf23 = extern_kernels.convolution(buf1, buf22, stride=(2, 2),
            padding=(3, 3), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf23, (4, 256, 32, 32), (262144, 1, 8192, 256))
        buf24 = empty_strided_cuda((4, 256, 34, 34), (295936, 1, 8704, 256),
            torch.float32)
        triton_poi_fused_constant_pad_nd_7[grid(1183744)](buf23, buf24, 
            1183744, XBLOCK=512, num_warps=8, num_stages=1)
        buf25 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        buf26 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.int8)
        triton_poi_fused_max_pool2d_with_indices_8[grid(262144)](buf24,
            buf25, buf26, 262144, XBLOCK=512, num_warps=8, num_stages=1)
        buf27 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf28 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf30 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf25, buf27, buf28,
            buf30, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16, num_stages=1
            )
        buf31 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf25,
            buf27, buf28, primals_3, primals_4, buf31, 262144, XBLOCK=1024,
            num_warps=4, num_stages=1)
        del primals_4
        buf33 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf35 = reinterpret_tensor(buf33, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf33
        buf36 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_11[grid(1024)](buf35,
            primals_5, buf36, 1024, 256, num_warps=2, num_stages=1)
        buf37 = extern_kernels.convolution(buf31, buf36, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf37, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf39 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf41 = reinterpret_tensor(buf39, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf39
        buf42 = empty_strided_cuda((256, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_12[grid(256)](buf41,
            primals_6, buf42, 256, 256, num_warps=2, num_stages=1)
        buf43 = extern_kernels.convolution(buf31, buf42, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf43, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf44 = buf28
        del buf28
        buf45 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf47 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf43, buf44, buf45,
            buf47, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16, num_stages=1
            )
        buf48 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf43,
            buf44, buf45, primals_7, primals_8, buf48, 262144, XBLOCK=1024,
            num_warps=4, num_stages=1)
        del primals_8
        buf49 = extern_kernels.convolution(buf48, buf2, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf49, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf50 = buf49
        del buf49
        triton_poi_fused_convolution_13[grid(262144)](buf50, primals_10, 
            262144, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_10
        buf51 = buf45
        del buf45
        buf52 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf54 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf50, buf51, buf52,
            buf54, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16, num_stages=1
            )
        buf55 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf50,
            buf51, buf52, primals_11, primals_12, buf55, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_12
        buf57 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf59 = reinterpret_tensor(buf57, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf57
        buf60 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_11[grid(1024)](buf59,
            primals_13, buf60, 1024, 256, num_warps=2, num_stages=1)
        buf61 = extern_kernels.convolution(buf55, buf60, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf61, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf62 = buf37
        del buf37
        triton_poi_fused_add_14[grid(1048576)](buf62, buf61, 1048576,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf63 = buf52
        del buf52
        buf64 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf66 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf62, buf63,
            buf64, buf66, 128, 8192, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf67 = buf61
        del buf61
        triton_poi_fused_native_group_norm_relu_16[grid(1048576)](buf62,
            buf63, buf64, primals_14, primals_15, buf67, 1048576, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_15
        buf69 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf71 = reinterpret_tensor(buf69, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf69
        buf72 = 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)](buf71,
            primals_16, buf72, 256, 1024, num_warps=8, num_stages=1)
        buf73 = extern_kernels.convolution(buf67, buf72, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf73, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf74 = buf64
        del buf64
        buf75 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf77 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf73, buf74, buf75,
            buf77, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16, num_stages=1
            )
        buf78 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf73,
            buf74, buf75, primals_17, primals_18, buf78, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_18
        buf79 = extern_kernels.convolution(buf78, buf3, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf79, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf80 = buf79
        del buf79
        triton_poi_fused_convolution_13[grid(262144)](buf80, primals_20, 
            262144, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_20
        buf81 = buf75
        del buf75
        buf82 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf84 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf80, buf81, buf82,
            buf84, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16, num_stages=1
            )
        buf85 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf80,
            buf81, buf82, primals_21, primals_22, buf85, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_22
        buf87 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf89 = reinterpret_tensor(buf87, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf87
        buf90 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_11[grid(1024)](buf89,
            primals_23, buf90, 1024, 256, num_warps=2, num_stages=1)
        buf91 = extern_kernels.convolution(buf85, buf90, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf91, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf92 = buf91
        del buf91
        triton_poi_fused_add_18[grid(1048576)](buf92, buf62, 1048576,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf93 = buf82
        del buf82
        buf94 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        buf96 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch.
            float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf92, buf93,
            buf94, buf96, 128, 8192, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf97 = reinterpret_tensor(buf23, (4, 1024, 16, 16), (262144, 1, 
            16384, 1024), 0)
        del buf23
        triton_poi_fused_native_group_norm_relu_16[grid(1048576)](buf92,
            buf93, buf94, primals_24, primals_25, buf97, 1048576, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_25
        buf99 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf101 = reinterpret_tensor(buf99, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf99
        buf102 = 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)](buf101,
            primals_26, buf102, 256, 1024, num_warps=8, num_stages=1)
        buf103 = extern_kernels.convolution(buf97, buf102, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf103, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf104 = buf94
        del buf94
        buf105 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf107 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf103, buf104,
            buf105, buf107, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf108 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf103,
            buf104, buf105, primals_27, primals_28, buf108, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_28
        buf109 = extern_kernels.convolution(buf108, buf4, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf109, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf110 = buf109
        del buf109
        triton_poi_fused_convolution_13[grid(262144)](buf110, primals_30, 
            262144, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_30
        buf111 = buf105
        del buf105
        buf112 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf114 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf110, buf111,
            buf112, buf114, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf115 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf110,
            buf111, buf112, primals_31, primals_32, buf115, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_32
        buf117 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf119 = reinterpret_tensor(buf117, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf117
        buf120 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_11[grid(1024)](buf119,
            primals_33, buf120, 1024, 256, num_warps=2, num_stages=1)
        buf121 = extern_kernels.convolution(buf115, buf120, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf121, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf122 = buf121
        del buf121
        triton_poi_fused_add_18[grid(1048576)](buf122, buf92, 1048576,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf123 = buf112
        del buf112
        buf124 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf126 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf122, buf123,
            buf124, buf126, 128, 8192, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf127 = empty_strided_cuda((4, 1024, 16, 16), (262144, 1, 16384, 
            1024), torch.float32)
        triton_poi_fused_native_group_norm_relu_16[grid(1048576)](buf122,
            buf123, buf124, primals_34, primals_35, buf127, 1048576, XBLOCK
            =1024, num_warps=4, num_stages=1)
        del primals_35
        buf129 = empty_strided_cuda((256, 1, 1, 1), (1, 256, 256, 256),
            torch.float32)
        buf131 = reinterpret_tensor(buf129, (256, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf129
        buf132 = 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)](buf131,
            primals_36, buf132, 256, 1024, num_warps=8, num_stages=1)
        buf133 = extern_kernels.convolution(buf127, buf132, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf133, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf134 = buf124
        del buf124
        buf135 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf137 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf133, buf134,
            buf135, buf137, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf138 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf133,
            buf134, buf135, primals_37, primals_38, buf138, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_38
        buf139 = extern_kernels.convolution(buf138, buf5, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf139, (4, 256, 16, 16), (65536, 1, 4096, 256))
        buf140 = buf139
        del buf139
        triton_poi_fused_convolution_13[grid(262144)](buf140, primals_40, 
            262144, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_40
        buf141 = buf135
        del buf135
        buf142 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf144 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_9[grid(128)](buf140, buf141,
            buf142, buf144, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf145 = empty_strided_cuda((4, 256, 16, 16), (65536, 1, 4096, 256),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_10[grid(262144)](buf140,
            buf141, buf142, primals_41, primals_42, buf145, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_42
        buf147 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf149 = reinterpret_tensor(buf147, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf147
        buf150 = empty_strided_cuda((1024, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_11[grid(1024)](buf149,
            primals_43, buf150, 1024, 256, num_warps=2, num_stages=1)
        buf151 = extern_kernels.convolution(buf145, buf150, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf151, (4, 1024, 16, 16), (262144, 1, 16384, 1024))
        buf152 = buf151
        del buf151
        triton_poi_fused_add_18[grid(1048576)](buf152, buf122, 1048576,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf153 = buf142
        del buf142
        buf154 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf156 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_15[grid(128)](buf152, buf153,
            buf154, buf156, 128, 8192, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf157 = empty_strided_cuda((4, 1024, 16, 16), (262144, 1, 16384, 
            1024), torch.float32)
        triton_poi_fused_native_group_norm_relu_16[grid(1048576)](buf152,
            buf153, buf154, primals_44, primals_45, buf157, 1048576, XBLOCK
            =1024, num_warps=4, num_stages=1)
        del primals_45
        buf159 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf161 = reinterpret_tensor(buf159, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf159
        buf162 = 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)](buf161,
            primals_46, buf162, 2048, 1024, num_warps=8, num_stages=1)
        buf163 = extern_kernels.convolution(buf157, buf162, stride=(2, 2),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf163, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf165 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf167 = reinterpret_tensor(buf165, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf165
        buf168 = empty_strided_cuda((512, 1024, 1, 1), (1024, 1, 1024, 1024
            ), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_20[grid(512)](buf167,
            primals_47, buf168, 512, 1024, num_warps=8, num_stages=1)
        buf169 = extern_kernels.convolution(buf157, buf168, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf169, (4, 512, 16, 16), (131072, 1, 8192, 512))
        buf170 = buf154
        del buf154
        buf171 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf173 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_21[grid(128)](buf169, buf170,
            buf171, buf173, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf174 = empty_strided_cuda((4, 512, 16, 16), (131072, 1, 8192, 512
            ), torch.float32)
        triton_poi_fused_native_group_norm_relu_22[grid(524288)](buf169,
            buf170, buf171, primals_48, primals_49, buf174, 524288, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_49
        buf175 = extern_kernels.convolution(buf174, buf6, stride=(2, 2),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf175, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf176 = buf175
        del buf175
        triton_poi_fused_convolution_23[grid(131072)](buf176, primals_51, 
            131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_51
        buf177 = buf171
        del buf171
        buf178 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf180 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_24[grid(128)](buf176, buf177,
            buf178, buf180, 128, 1024, num_warps=8, num_stages=1)
        buf181 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_25[grid(131072)](buf176,
            buf177, buf178, primals_52, primals_53, buf181, 131072, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_53
        buf183 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf185 = reinterpret_tensor(buf183, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf183
        buf186 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_26[grid(2048)](buf185,
            primals_54, buf186, 2048, 512, num_warps=4, num_stages=1)
        buf187 = extern_kernels.convolution(buf181, buf186, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf187, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf188 = buf163
        del buf163
        triton_poi_fused_add_27[grid(524288)](buf188, buf187, 524288,
            XBLOCK=1024, num_warps=4, num_stages=1)
        buf189 = buf178
        del buf178
        buf190 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf192 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf188, buf189,
            buf190, buf192, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf193 = buf187
        del buf187
        triton_poi_fused_native_group_norm_relu_29[grid(524288)](buf188,
            buf189, buf190, primals_55, primals_56, buf193, 524288, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_56
        buf195 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf197 = reinterpret_tensor(buf195, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf195
        buf198 = 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)](buf197,
            primals_57, buf198, 512, 2048, XBLOCK=1, RBLOCK=2048, num_warps
            =16, num_stages=1)
        buf199 = extern_kernels.convolution(buf193, buf198, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf199, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf200 = buf190
        del buf190
        buf201 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf203 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_24[grid(128)](buf199, buf200,
            buf201, buf203, 128, 1024, num_warps=8, num_stages=1)
        buf204 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_25[grid(131072)](buf199,
            buf200, buf201, primals_58, primals_59, buf204, 131072, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_59
        buf205 = extern_kernels.convolution(buf204, buf7, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf205, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf206 = buf205
        del buf205
        triton_poi_fused_convolution_23[grid(131072)](buf206, primals_61, 
            131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_61
        buf207 = buf201
        del buf201
        buf208 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf210 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_24[grid(128)](buf206, buf207,
            buf208, buf210, 128, 1024, num_warps=8, num_stages=1)
        buf211 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_25[grid(131072)](buf206,
            buf207, buf208, primals_62, primals_63, buf211, 131072, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_63
        buf213 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf215 = reinterpret_tensor(buf213, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf213
        buf216 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_26[grid(2048)](buf215,
            primals_64, buf216, 2048, 512, num_warps=4, num_stages=1)
        buf217 = extern_kernels.convolution(buf211, buf216, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf217, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf218 = buf217
        del buf217
        triton_poi_fused_add_31[grid(524288)](buf218, buf188, 524288,
            XBLOCK=1024, num_warps=4, num_stages=1)
        buf219 = buf208
        del buf208
        buf220 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf222 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf218, buf219,
            buf220, buf222, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf223 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 
            2048), torch.float32)
        triton_poi_fused_native_group_norm_relu_29[grid(524288)](buf218,
            buf219, buf220, primals_65, primals_66, buf223, 524288, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_66
        buf225 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf227 = reinterpret_tensor(buf225, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf225
        buf228 = 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)](buf227,
            primals_67, buf228, 512, 2048, XBLOCK=1, RBLOCK=2048, num_warps
            =16, num_stages=1)
        buf229 = extern_kernels.convolution(buf223, buf228, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf229, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf230 = buf220
        del buf220
        buf231 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf233 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_24[grid(128)](buf229, buf230,
            buf231, buf233, 128, 1024, num_warps=8, num_stages=1)
        buf234 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_25[grid(131072)](buf229,
            buf230, buf231, primals_68, primals_69, buf234, 131072, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_69
        buf235 = extern_kernels.convolution(buf234, buf8, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf235, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf236 = buf235
        del buf235
        triton_poi_fused_convolution_23[grid(131072)](buf236, primals_71, 
            131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_71
        buf237 = buf231
        del buf231
        buf238 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf240 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_24[grid(128)](buf236, buf237,
            buf238, buf240, 128, 1024, num_warps=8, num_stages=1)
        buf241 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_25[grid(131072)](buf236,
            buf237, buf238, primals_72, primals_73, buf241, 131072, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_73
        buf243 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf245 = reinterpret_tensor(buf243, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf243
        buf246 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_26[grid(2048)](buf245,
            primals_74, buf246, 2048, 512, num_warps=4, num_stages=1)
        buf247 = extern_kernels.convolution(buf241, buf246, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf247, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf248 = buf247
        del buf247
        triton_poi_fused_add_31[grid(524288)](buf248, buf218, 524288,
            XBLOCK=1024, num_warps=4, num_stages=1)
        buf249 = buf238
        del buf238
        buf250 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf252 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf248, buf249,
            buf250, buf252, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf253 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 
            2048), torch.float32)
        triton_poi_fused_native_group_norm_relu_29[grid(524288)](buf248,
            buf249, buf250, primals_75, primals_76, buf253, 524288, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_76
        buf255 = empty_strided_cuda((512, 1, 1, 1), (1, 512, 512, 512),
            torch.float32)
        buf257 = reinterpret_tensor(buf255, (512, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf255
        buf258 = 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)](buf257,
            primals_77, buf258, 512, 2048, XBLOCK=1, RBLOCK=2048, num_warps
            =16, num_stages=1)
        buf259 = extern_kernels.convolution(buf253, buf258, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf259, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf260 = buf250
        del buf250
        buf261 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf263 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_24[grid(128)](buf259, buf260,
            buf261, buf263, 128, 1024, num_warps=8, num_stages=1)
        buf264 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_25[grid(131072)](buf259,
            buf260, buf261, primals_78, primals_79, buf264, 131072, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_79
        buf265 = extern_kernels.convolution(buf264, buf9, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf265, (4, 512, 8, 8), (32768, 1, 4096, 512))
        buf266 = buf265
        del buf265
        triton_poi_fused_convolution_23[grid(131072)](buf266, primals_81, 
            131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_81
        buf267 = buf261
        del buf261
        buf268 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf270 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_24[grid(128)](buf266, buf267,
            buf268, buf270, 128, 1024, num_warps=8, num_stages=1)
        buf271 = empty_strided_cuda((4, 512, 8, 8), (32768, 1, 4096, 512),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_25[grid(131072)](buf266,
            buf267, buf268, primals_82, primals_83, buf271, 131072, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_83
        buf273 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf275 = reinterpret_tensor(buf273, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf273
        buf276 = empty_strided_cuda((2048, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_26[grid(2048)](buf275,
            primals_84, buf276, 2048, 512, num_warps=4, num_stages=1)
        buf277 = extern_kernels.convolution(buf271, buf276, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf277, (4, 2048, 8, 8), (131072, 1, 16384, 2048))
        buf278 = buf277
        del buf277
        triton_poi_fused_add_31[grid(524288)](buf278, buf248, 524288,
            XBLOCK=1024, num_warps=4, num_stages=1)
        buf279 = buf268
        del buf268
        buf280 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf282 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_28[grid(128)](buf278, buf279,
            buf280, buf282, 128, 4096, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf283 = empty_strided_cuda((4, 2048, 8, 8), (131072, 1, 16384, 
            2048), torch.float32)
        triton_poi_fused_native_group_norm_relu_29[grid(524288)](buf278,
            buf279, buf280, primals_85, primals_86, buf283, 524288, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_86
        buf285 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf287 = reinterpret_tensor(buf285, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf285
        buf288 = 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)](buf287,
            primals_87, buf288, 4096, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf289 = extern_kernels.convolution(buf283, buf288, stride=(2, 2),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf289, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf291 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf293 = reinterpret_tensor(buf291, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf291
        buf294 = empty_strided_cuda((1024, 2048, 1, 1), (2048, 1, 2048, 
            2048), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_33[grid(1024)](buf293,
            primals_88, buf294, 1024, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf295 = extern_kernels.convolution(buf283, buf294, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf295, (4, 1024, 8, 8), (65536, 1, 8192, 1024))
        buf296 = buf280
        del buf280
        buf297 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf299 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_34[grid(128)](buf295, buf296,
            buf297, buf299, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf300 = empty_strided_cuda((4, 1024, 8, 8), (65536, 1, 8192, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_35[grid(262144)](buf295,
            buf296, buf297, primals_89, primals_90, buf300, 262144, XBLOCK=
            1024, num_warps=4, num_stages=1)
        del primals_90
        buf301 = extern_kernels.convolution(buf300, buf10, stride=(2, 2),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf301, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf302 = buf301
        del buf301
        triton_poi_fused_convolution_36[grid(65536)](buf302, primals_92, 
            65536, XBLOCK=512, num_warps=4, num_stages=1)
        del primals_92
        buf303 = buf297
        del buf297
        buf304 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf306 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_37[grid(128)](buf302, buf303,
            buf304, buf306, 128, 512, num_warps=4, num_stages=1)
        buf307 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_38[grid(65536)](buf302,
            buf303, buf304, primals_93, primals_94, buf307, 65536, XBLOCK=
            512, num_warps=4, num_stages=1)
        del primals_94
        buf309 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf311 = reinterpret_tensor(buf309, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf309
        buf312 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_39[grid(4096)](buf311,
            primals_95, buf312, 4096, 1024, num_warps=8, num_stages=1)
        buf313 = extern_kernels.convolution(buf307, buf312, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf313, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf314 = buf289
        del buf289
        triton_poi_fused_add_40[grid(262144)](buf314, buf313, 262144,
            XBLOCK=1024, num_warps=4, num_stages=1)
        buf315 = buf304
        del buf304
        buf316 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf318 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf314, buf315,
            buf316, buf318, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf319 = buf313
        del buf313
        triton_poi_fused_native_group_norm_relu_42[grid(262144)](buf314,
            buf315, buf316, primals_96, primals_97, buf319, 262144, XBLOCK=
            512, num_warps=8, num_stages=1)
        del primals_97
        buf321 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf323 = reinterpret_tensor(buf321, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf321
        buf324 = 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)](buf323,
            primals_98, buf324, 1024, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf325 = extern_kernels.convolution(buf319, buf324, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf325, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf326 = buf316
        del buf316
        buf327 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf329 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_37[grid(128)](buf325, buf326,
            buf327, buf329, 128, 512, num_warps=4, num_stages=1)
        buf330 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_38[grid(65536)](buf325,
            buf326, buf327, primals_99, primals_100, buf330, 65536, XBLOCK=
            512, num_warps=4, num_stages=1)
        del primals_100
        buf331 = extern_kernels.convolution(buf330, buf11, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf331, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf332 = buf331
        del buf331
        triton_poi_fused_convolution_36[grid(65536)](buf332, primals_102, 
            65536, XBLOCK=512, num_warps=4, num_stages=1)
        del primals_102
        buf333 = buf327
        del buf327
        buf334 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf336 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_37[grid(128)](buf332, buf333,
            buf334, buf336, 128, 512, num_warps=4, num_stages=1)
        buf337 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_38[grid(65536)](buf332,
            buf333, buf334, primals_103, primals_104, buf337, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_104
        buf339 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf341 = reinterpret_tensor(buf339, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf339
        buf342 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_39[grid(4096)](buf341,
            primals_105, buf342, 4096, 1024, num_warps=8, num_stages=1)
        buf343 = extern_kernels.convolution(buf337, buf342, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf343, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf344 = buf343
        del buf343
        triton_poi_fused_add_44[grid(262144)](buf344, buf314, 262144,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf345 = buf334
        del buf334
        buf346 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf348 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf344, buf345,
            buf346, buf348, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf349 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096
            ), torch.float32)
        triton_poi_fused_native_group_norm_relu_42[grid(262144)](buf344,
            buf345, buf346, primals_106, primals_107, buf349, 262144,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_107
        buf351 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf353 = reinterpret_tensor(buf351, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf351
        buf354 = 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)](buf353,
            primals_108, buf354, 1024, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf355 = extern_kernels.convolution(buf349, buf354, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf355, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf356 = buf346
        del buf346
        buf357 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf359 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_37[grid(128)](buf355, buf356,
            buf357, buf359, 128, 512, num_warps=4, num_stages=1)
        buf360 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_38[grid(65536)](buf355,
            buf356, buf357, primals_109, primals_110, buf360, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_110
        buf361 = extern_kernels.convolution(buf360, buf12, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf361, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf362 = buf361
        del buf361
        triton_poi_fused_convolution_36[grid(65536)](buf362, primals_112, 
            65536, XBLOCK=512, num_warps=4, num_stages=1)
        del primals_112
        buf363 = buf357
        del buf357
        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_37[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_38[grid(65536)](buf362,
            buf363, buf364, primals_113, primals_114, buf367, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_114
        buf369 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf371 = reinterpret_tensor(buf369, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf369
        buf372 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_39[grid(4096)](buf371,
            primals_115, buf372, 4096, 1024, num_warps=8, num_stages=1)
        buf373 = extern_kernels.convolution(buf367, buf372, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf373, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf374 = buf373
        del buf373
        triton_poi_fused_add_44[grid(262144)](buf374, buf344, 262144,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf375 = buf364
        del buf364
        buf376 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf378 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf374, buf375,
            buf376, buf378, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf379 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096
            ), torch.float32)
        triton_poi_fused_native_group_norm_relu_42[grid(262144)](buf374,
            buf375, buf376, primals_116, primals_117, buf379, 262144,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_117
        buf381 = empty_strided_cuda((1024, 1, 1, 1), (1, 1024, 1024, 1024),
            torch.float32)
        buf383 = reinterpret_tensor(buf381, (1024, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf381
        buf384 = 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)](buf383,
            primals_118, buf384, 1024, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf385 = extern_kernels.convolution(buf379, buf384, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf385, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf386 = buf376
        del buf376
        buf387 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf389 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_37[grid(128)](buf385, buf386,
            buf387, buf389, 128, 512, num_warps=4, num_stages=1)
        buf390 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_38[grid(65536)](buf385,
            buf386, buf387, primals_119, primals_120, buf390, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_120
        buf391 = extern_kernels.convolution(buf390, buf13, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf391, (4, 1024, 4, 4), (16384, 1, 4096, 1024))
        buf392 = buf391
        del buf391
        triton_poi_fused_convolution_36[grid(65536)](buf392, primals_122, 
            65536, XBLOCK=512, num_warps=4, num_stages=1)
        del primals_122
        buf393 = buf387
        del buf387
        buf394 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf396 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_37[grid(128)](buf392, buf393,
            buf394, buf396, 128, 512, num_warps=4, num_stages=1)
        buf397 = empty_strided_cuda((4, 1024, 4, 4), (16384, 1, 4096, 1024),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_38[grid(65536)](buf392,
            buf393, buf394, primals_123, primals_124, buf397, 65536, XBLOCK
            =512, num_warps=4, num_stages=1)
        del primals_124
        buf399 = empty_strided_cuda((4096, 1, 1, 1), (1, 4096, 4096, 4096),
            torch.float32)
        buf401 = reinterpret_tensor(buf399, (4096, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf399
        buf402 = empty_strided_cuda((4096, 1024, 1, 1), (1024, 1, 1024, 
            1024), torch.float32)
        triton_per_fused_add_div_sqrt_sub_var_mean_39[grid(4096)](buf401,
            primals_125, buf402, 4096, 1024, num_warps=8, num_stages=1)
        buf403 = extern_kernels.convolution(buf397, buf402, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf403, (4, 4096, 4, 4), (65536, 1, 16384, 4096))
        buf404 = buf403
        del buf403
        triton_poi_fused_add_44[grid(262144)](buf404, buf374, 262144,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf405 = buf394
        del buf394
        buf406 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf408 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_red_fused_native_group_norm_41[grid(128)](buf404, buf405,
            buf406, buf408, 128, 2048, XBLOCK=1, RBLOCK=2048, num_warps=16,
            num_stages=1)
        buf409 = empty_strided_cuda((4, 4096, 4, 4), (65536, 1, 16384, 4096
            ), torch.float32)
        triton_poi_fused_native_group_norm_relu_42[grid(262144)](buf404,
            buf405, buf406, primals_126, primals_127, buf409, 262144,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_127
        buf411 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192),
            torch.float32)
        buf413 = reinterpret_tensor(buf411, (8192, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf411
        buf414 = empty_strided_cuda((8192, 4096, 1, 1), (4096, 1, 4096, 
            4096), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_45[grid(8192)](buf413,
            primals_128, buf414, 8192, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf415 = extern_kernels.convolution(buf409, buf414, stride=(2, 2),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf415, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf417 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf419 = reinterpret_tensor(buf417, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf417
        buf420 = empty_strided_cuda((2048, 4096, 1, 1), (4096, 1, 4096, 
            4096), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_46[grid(2048)](buf419,
            primals_129, buf420, 2048, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf421 = extern_kernels.convolution(buf409, buf420, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf421, (4, 2048, 4, 4), (32768, 1, 8192, 2048))
        buf422 = buf406
        del buf406
        buf423 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf425 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_47[grid(128)](buf421, buf422,
            buf423, buf425, 128, 1024, num_warps=8, num_stages=1)
        buf426 = empty_strided_cuda((4, 2048, 4, 4), (32768, 1, 8192, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_48[grid(131072)](buf421,
            buf422, buf423, primals_130, primals_131, buf426, 131072,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_131
        buf427 = extern_kernels.convolution(buf426, buf14, stride=(2, 2),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf427, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf428 = buf427
        del buf427
        triton_poi_fused_convolution_49[grid(32768)](buf428, primals_133, 
            32768, XBLOCK=256, num_warps=4, num_stages=1)
        del primals_133
        buf429 = buf423
        del buf423
        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_50[grid(128)](buf428, buf429,
            buf430, buf432, 128, 256, num_warps=2, num_stages=1)
        buf433 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_51[grid(32768)](buf428,
            buf429, buf430, primals_134, primals_135, buf433, 32768, XBLOCK
            =256, num_warps=4, num_stages=1)
        del primals_135
        buf435 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192),
            torch.float32)
        buf437 = reinterpret_tensor(buf435, (8192, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf435
        buf438 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 
            2048), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_52[grid(8192)](buf437,
            primals_136, buf438, 8192, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf439 = extern_kernels.convolution(buf433, buf438, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf439, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf440 = buf415
        del buf415
        triton_poi_fused_add_53[grid(131072)](buf440, buf439, 131072,
            XBLOCK=1024, num_warps=4, num_stages=1)
        buf441 = buf430
        del buf430
        buf442 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf444 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_54[grid(128)](buf440, buf441,
            buf442, buf444, 128, 1024, num_warps=8, num_stages=1)
        buf445 = buf439
        del buf439
        triton_poi_fused_native_group_norm_relu_55[grid(131072)](buf440,
            buf441, buf442, primals_137, primals_138, buf445, 131072,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_138
        buf447 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf449 = reinterpret_tensor(buf447, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf447
        buf450 = empty_strided_cuda((2048, 8192, 1, 1), (8192, 1, 8192, 
            8192), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_56[grid(2048)](buf449,
            primals_139, buf450, 2048, 8192, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf451 = extern_kernels.convolution(buf445, buf450, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf451, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf452 = buf442
        del buf442
        buf453 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf455 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_50[grid(128)](buf451, buf452,
            buf453, buf455, 128, 256, num_warps=2, num_stages=1)
        buf456 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_51[grid(32768)](buf451,
            buf452, buf453, primals_140, primals_141, buf456, 32768, XBLOCK
            =256, num_warps=4, num_stages=1)
        del primals_141
        buf457 = extern_kernels.convolution(buf456, buf15, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf457, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf458 = buf457
        del buf457
        triton_poi_fused_convolution_49[grid(32768)](buf458, primals_143, 
            32768, XBLOCK=256, num_warps=4, num_stages=1)
        del primals_143
        buf459 = buf453
        del buf453
        buf460 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf462 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_50[grid(128)](buf458, buf459,
            buf460, buf462, 128, 256, num_warps=2, num_stages=1)
        buf463 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_51[grid(32768)](buf458,
            buf459, buf460, primals_144, primals_145, buf463, 32768, XBLOCK
            =256, num_warps=4, num_stages=1)
        del primals_145
        buf465 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192),
            torch.float32)
        buf467 = reinterpret_tensor(buf465, (8192, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf465
        buf468 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 
            2048), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_52[grid(8192)](buf467,
            primals_146, buf468, 8192, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf469 = extern_kernels.convolution(buf463, buf468, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf469, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf470 = buf469
        del buf469
        triton_poi_fused_add_57[grid(131072)](buf470, buf440, 131072,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf471 = buf460
        del buf460
        buf472 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf474 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_54[grid(128)](buf470, buf471,
            buf472, buf474, 128, 1024, num_warps=8, num_stages=1)
        buf475 = empty_strided_cuda((4, 8192, 2, 2), (32768, 1, 16384, 8192
            ), torch.float32)
        triton_poi_fused_native_group_norm_relu_55[grid(131072)](buf470,
            buf471, buf472, primals_147, primals_148, buf475, 131072,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_148
        buf477 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf479 = reinterpret_tensor(buf477, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf477
        buf480 = empty_strided_cuda((2048, 8192, 1, 1), (8192, 1, 8192, 
            8192), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_56[grid(2048)](buf479,
            primals_149, buf480, 2048, 8192, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf481 = extern_kernels.convolution(buf475, buf480, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf481, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf482 = buf472
        del buf472
        buf483 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf485 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_50[grid(128)](buf481, buf482,
            buf483, buf485, 128, 256, num_warps=2, num_stages=1)
        buf486 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_51[grid(32768)](buf481,
            buf482, buf483, primals_150, primals_151, buf486, 32768, XBLOCK
            =256, num_warps=4, num_stages=1)
        del primals_151
        buf487 = extern_kernels.convolution(buf486, buf16, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf487, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf488 = buf487
        del buf487
        triton_poi_fused_convolution_49[grid(32768)](buf488, primals_153, 
            32768, XBLOCK=256, num_warps=4, num_stages=1)
        del primals_153
        buf489 = buf483
        del buf483
        buf490 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf492 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_50[grid(128)](buf488, buf489,
            buf490, buf492, 128, 256, num_warps=2, num_stages=1)
        buf493 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_51[grid(32768)](buf488,
            buf489, buf490, primals_154, primals_155, buf493, 32768, XBLOCK
            =256, num_warps=4, num_stages=1)
        del primals_155
        buf495 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192),
            torch.float32)
        buf497 = reinterpret_tensor(buf495, (8192, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf495
        buf498 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 
            2048), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_52[grid(8192)](buf497,
            primals_156, buf498, 8192, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf499 = extern_kernels.convolution(buf493, buf498, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf499, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf500 = buf499
        del buf499
        triton_poi_fused_add_57[grid(131072)](buf500, buf470, 131072,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf501 = buf490
        del buf490
        buf502 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf504 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_54[grid(128)](buf500, buf501,
            buf502, buf504, 128, 1024, num_warps=8, num_stages=1)
        buf505 = empty_strided_cuda((4, 8192, 2, 2), (32768, 1, 16384, 8192
            ), torch.float32)
        triton_poi_fused_native_group_norm_relu_55[grid(131072)](buf500,
            buf501, buf502, primals_157, primals_158, buf505, 131072,
            XBLOCK=512, num_warps=8, num_stages=1)
        del primals_158
        buf507 = empty_strided_cuda((2048, 1, 1, 1), (1, 2048, 2048, 2048),
            torch.float32)
        buf509 = reinterpret_tensor(buf507, (2048, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf507
        buf510 = empty_strided_cuda((2048, 8192, 1, 1), (8192, 1, 8192, 
            8192), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_56[grid(2048)](buf509,
            primals_159, buf510, 2048, 8192, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf511 = extern_kernels.convolution(buf505, buf510, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf511, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf512 = buf502
        del buf502
        buf513 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf515 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_50[grid(128)](buf511, buf512,
            buf513, buf515, 128, 256, num_warps=2, num_stages=1)
        buf516 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_51[grid(32768)](buf511,
            buf512, buf513, primals_160, primals_161, buf516, 32768, XBLOCK
            =256, num_warps=4, num_stages=1)
        del primals_161
        buf517 = extern_kernels.convolution(buf516, buf17, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf517, (4, 2048, 2, 2), (8192, 1, 4096, 2048))
        buf518 = buf517
        del buf517
        triton_poi_fused_convolution_49[grid(32768)](buf518, primals_163, 
            32768, XBLOCK=256, num_warps=4, num_stages=1)
        del primals_163
        buf519 = buf513
        del buf513
        buf520 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf522 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        triton_per_fused_native_group_norm_50[grid(128)](buf518, buf519,
            buf520, buf522, 128, 256, num_warps=2, num_stages=1)
        buf523 = empty_strided_cuda((4, 2048, 2, 2), (8192, 1, 4096, 2048),
            torch.float32)
        triton_poi_fused_native_group_norm_relu_51[grid(32768)](buf518,
            buf519, buf520, primals_164, primals_165, buf523, 32768, XBLOCK
            =256, num_warps=4, num_stages=1)
        del primals_165
        buf525 = empty_strided_cuda((8192, 1, 1, 1), (1, 8192, 8192, 8192),
            torch.float32)
        buf527 = reinterpret_tensor(buf525, (8192, 1, 1, 1), (1, 1, 1, 1), 0)
        del buf525
        buf528 = empty_strided_cuda((8192, 2048, 1, 1), (2048, 1, 2048, 
            2048), torch.float32)
        triton_red_fused_add_div_sqrt_sub_var_mean_52[grid(8192)](buf527,
            primals_166, buf528, 8192, 2048, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        buf529 = extern_kernels.convolution(buf523, buf528, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf529, (4, 8192, 2, 2), (32768, 1, 16384, 8192))
        buf530 = buf529
        del buf529
        triton_poi_fused_add_57[grid(131072)](buf530, buf500, 131072,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf531 = reinterpret_tensor(buf520, (4, 32, 1, 1), (32, 1, 32, 32), 0)
        del buf520
        buf532 = empty_strided_cuda((4, 32, 1, 1), (32, 1, 128, 128), torch
            .float32)
        buf534 = reinterpret_tensor(buf532, (4, 32, 1, 1), (32, 1, 32, 32), 0)
        del buf532
        triton_per_fused_native_group_norm_58[grid(128)](buf534, buf530,
            buf531, 128, 1024, num_warps=8, num_stages=1)
        buf535 = empty_strided_cuda((4, 8192, 1, 1), (8192, 1, 8192, 8192),
            torch.float32)
        triton_poi_fused_mean_native_group_norm_relu_59[grid(32768)](buf530,
            buf531, buf534, primals_167, primals_168, buf535, 32768, XBLOCK
            =128, num_warps=4, num_stages=1)
        buf536 = extern_kernels.convolution(buf535, primals_169, stride=(1,
            1), padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf536, (4, 21843, 1, 1), (21843, 1, 21843, 21843))
        buf537 = reinterpret_tensor(buf536, (4, 21843, 1, 1), (21843, 1, 1,
            1), 0)
        del buf536
        triton_poi_fused_convolution_60[grid(87372)](buf537, primals_170, 
            87372, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_170
    return (buf537, buf0, buf1, primals_3, primals_5, primals_6, primals_7,
        buf2, primals_11, primals_13, primals_14, primals_16, primals_17,
        buf3, primals_21, primals_23, primals_24, primals_26, primals_27,
        buf4, primals_31, primals_33, primals_34, primals_36, primals_37,
        buf5, primals_41, primals_43, primals_44, primals_46, primals_47,
        primals_48, buf6, primals_52, primals_54, primals_55, primals_57,
        primals_58, buf7, primals_62, primals_64, primals_65, primals_67,
        primals_68, buf8, primals_72, primals_74, primals_75, primals_77,
        primals_78, buf9, primals_82, primals_84, primals_85, primals_87,
        primals_88, primals_89, buf10, primals_93, primals_95, primals_96,
        primals_98, primals_99, buf11, primals_103, primals_105,
        primals_106, primals_108, primals_109, buf12, primals_113,
        primals_115, primals_116, primals_118, primals_119, buf13,
        primals_123, primals_125, primals_126, primals_128, primals_129,
        primals_130, buf14, primals_134, primals_136, primals_137,
        primals_139, primals_140, buf15, primals_144, primals_146,
        primals_147, primals_149, primals_150, buf16, primals_154,
        primals_156, primals_157, primals_159, primals_160, buf17,
        primals_164, primals_166, primals_167, primals_168, primals_169,
        buf21, buf22, buf24, buf25, buf26, reinterpret_tensor(buf27, (4, 32
        ), (32, 1), 0), reinterpret_tensor(buf30, (4, 32), (32, 1), 0),
        buf31, buf35, buf36, buf41, buf42, buf43, reinterpret_tensor(buf44,
        (4, 32), (32, 1), 0), reinterpret_tensor(buf47, (4, 32), (32, 1), 0
        ), buf48, buf50, reinterpret_tensor(buf51, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf54, (4, 32), (32, 1), 0), buf55, buf59, buf60,
        buf62, reinterpret_tensor(buf63, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf66, (4, 32), (32, 1), 0), buf67, buf71, buf72,
        buf73, reinterpret_tensor(buf74, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf77, (4, 32), (32, 1), 0), buf78, buf80,
        reinterpret_tensor(buf81, (4, 32), (32, 1), 0), reinterpret_tensor(
        buf84, (4, 32), (32, 1), 0), buf85, buf89, buf90, buf92,
        reinterpret_tensor(buf93, (4, 32), (32, 1), 0), reinterpret_tensor(
        buf96, (4, 32), (32, 1), 0), buf97, buf101, buf102, buf103,
        reinterpret_tensor(buf104, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf107, (4, 32), (32, 1), 0), buf108, buf110, reinterpret_tensor(
        buf111, (4, 32), (32, 1), 0), reinterpret_tensor(buf114, (4, 32), (
        32, 1), 0), buf115, buf119, buf120, buf122, reinterpret_tensor(
        buf123, (4, 32), (32, 1), 0), reinterpret_tensor(buf126, (4, 32), (
        32, 1), 0), buf127, buf131, buf132, buf133, reinterpret_tensor(
        buf134, (4, 32), (32, 1), 0), reinterpret_tensor(buf137, (4, 32), (
        32, 1), 0), buf138, buf140, reinterpret_tensor(buf141, (4, 32), (32,
        1), 0), reinterpret_tensor(buf144, (4, 32), (32, 1), 0), buf145,
        buf149, buf150, buf152, reinterpret_tensor(buf153, (4, 32), (32, 1),
        0), reinterpret_tensor(buf156, (4, 32), (32, 1), 0), buf157, buf161,
        buf162, buf167, buf168, buf169, reinterpret_tensor(buf170, (4, 32),
        (32, 1), 0), reinterpret_tensor(buf173, (4, 32), (32, 1), 0),
        buf174, buf176, reinterpret_tensor(buf177, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf180, (4, 32), (32, 1), 0), buf181, buf185,
        buf186, buf188, reinterpret_tensor(buf189, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf192, (4, 32), (32, 1), 0), buf193, buf197,
        buf198, buf199, reinterpret_tensor(buf200, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf203, (4, 32), (32, 1), 0), buf204, buf206,
        reinterpret_tensor(buf207, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf210, (4, 32), (32, 1), 0), buf211, buf215, buf216, buf218,
        reinterpret_tensor(buf219, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf222, (4, 32), (32, 1), 0), buf223, buf227, buf228, buf229,
        reinterpret_tensor(buf230, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf233, (4, 32), (32, 1), 0), buf234, buf236, reinterpret_tensor(
        buf237, (4, 32), (32, 1), 0), reinterpret_tensor(buf240, (4, 32), (
        32, 1), 0), buf241, buf245, buf246, buf248, reinterpret_tensor(
        buf249, (4, 32), (32, 1), 0), reinterpret_tensor(buf252, (4, 32), (
        32, 1), 0), buf253, buf257, buf258, buf259, reinterpret_tensor(
        buf260, (4, 32), (32, 1), 0), reinterpret_tensor(buf263, (4, 32), (
        32, 1), 0), buf264, buf266, reinterpret_tensor(buf267, (4, 32), (32,
        1), 0), reinterpret_tensor(buf270, (4, 32), (32, 1), 0), buf271,
        buf275, buf276, buf278, reinterpret_tensor(buf279, (4, 32), (32, 1),
        0), reinterpret_tensor(buf282, (4, 32), (32, 1), 0), buf283, buf287,
        buf288, buf293, buf294, buf295, reinterpret_tensor(buf296, (4, 32),
        (32, 1), 0), reinterpret_tensor(buf299, (4, 32), (32, 1), 0),
        buf300, buf302, reinterpret_tensor(buf303, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf306, (4, 32), (32, 1), 0), buf307, buf311,
        buf312, buf314, reinterpret_tensor(buf315, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf318, (4, 32), (32, 1), 0), buf319, buf323,
        buf324, buf325, reinterpret_tensor(buf326, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf329, (4, 32), (32, 1), 0), buf330, buf332,
        reinterpret_tensor(buf333, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf336, (4, 32), (32, 1), 0), buf337, buf341, buf342, buf344,
        reinterpret_tensor(buf345, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf348, (4, 32), (32, 1), 0), buf349, buf353, buf354, buf355,
        reinterpret_tensor(buf356, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf359, (4, 32), (32, 1), 0), buf360, buf362, reinterpret_tensor(
        buf363, (4, 32), (32, 1), 0), reinterpret_tensor(buf366, (4, 32), (
        32, 1), 0), buf367, buf371, buf372, buf374, reinterpret_tensor(
        buf375, (4, 32), (32, 1), 0), reinterpret_tensor(buf378, (4, 32), (
        32, 1), 0), buf379, buf383, buf384, buf385, reinterpret_tensor(
        buf386, (4, 32), (32, 1), 0), reinterpret_tensor(buf389, (4, 32), (
        32, 1), 0), buf390, buf392, reinterpret_tensor(buf393, (4, 32), (32,
        1), 0), reinterpret_tensor(buf396, (4, 32), (32, 1), 0), buf397,
        buf401, buf402, buf404, reinterpret_tensor(buf405, (4, 32), (32, 1),
        0), reinterpret_tensor(buf408, (4, 32), (32, 1), 0), buf409, buf413,
        buf414, buf419, buf420, buf421, reinterpret_tensor(buf422, (4, 32),
        (32, 1), 0), reinterpret_tensor(buf425, (4, 32), (32, 1), 0),
        buf426, buf428, reinterpret_tensor(buf429, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf432, (4, 32), (32, 1), 0), buf433, buf437,
        buf438, buf440, reinterpret_tensor(buf441, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf444, (4, 32), (32, 1), 0), buf445, buf449,
        buf450, buf451, reinterpret_tensor(buf452, (4, 32), (32, 1), 0),
        reinterpret_tensor(buf455, (4, 32), (32, 1), 0), buf456, buf458,
        reinterpret_tensor(buf459, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf462, (4, 32), (32, 1), 0), buf463, buf467, buf468, buf470,
        reinterpret_tensor(buf471, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf474, (4, 32), (32, 1), 0), buf475, buf479, buf480, buf481,
        reinterpret_tensor(buf482, (4, 32), (32, 1), 0), reinterpret_tensor
        (buf485, (4, 32), (32, 1), 0), buf486, buf488, reinterpret_tensor(
        buf489, (4, 32), (32, 1), 0), reinterpret_tensor(buf492, (4, 32), (
        32, 1), 0), buf493, buf497, buf498, buf500, reinterpret_tensor(
        buf501, (4, 32), (32, 1), 0), reinterpret_tensor(buf504, (4, 32), (
        32, 1), 0), buf505, buf509, buf510, buf511, reinterpret_tensor(
        buf512, (4, 32), (32, 1), 0), reinterpret_tensor(buf515, (4, 32), (
        32, 1), 0), buf516, buf518, reinterpret_tensor(buf519, (4, 32), (32,
        1), 0), reinterpret_tensor(buf522, (4, 32), (32, 1), 0), buf523,
        buf527, buf528, buf530, buf531, buf534, buf535)


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


def conv3x3(in_planes, out_planes, stride=1):
    return nn.Conv2d(in_planes, out_planes, kernel_size=3, stride=stride,
        padding=1, bias=True)


def tf2th(conv_weights):
    """Possibly convert HWIO to OIHW."""
    if conv_weights.ndim == 4:
        conv_weights = conv_weights.transpose([3, 2, 0, 1])
    return torch.from_numpy(conv_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-10)
        return F.conv2d(x, w, self.bias, self.stride, self.padding, self.
            dilation, self.groups)


class PreActBottleneck(nn.Module):
    """Pre-activation (v2) bottleneck block.
  Follows the implementation of "Identity Mappings in Deep Residual Networks":
  https://github.com/KaimingHe/resnet-1k-layers/blob/master/resnet-pre-act.lua
  Except it puts the stride on 3x3 conv when available.
  """

    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, cin)
        self.conv1 = conv1x1(cin, cmid)
        self.gn2 = nn.GroupNorm(32, cmid)
        self.conv2 = conv3x3(cmid, cmid, stride)
        self.gn3 = nn.GroupNorm(32, cmid)
        self.conv3 = conv1x1(cmid, cout)
        self.relu = nn.ReLU(inplace=True)
        if stride != 1 or cin != cout:
            self.downsample = conv1x1(cin, cout, stride)

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

    def load_from(self, weights, prefix=''):
        convname = 'standardized_conv2d'
        with torch.no_grad():
            self.conv1.weight.copy_(tf2th(weights[
                f'{prefix}a/{convname}/kernel']))
            self.conv2.weight.copy_(tf2th(weights[
                f'{prefix}b/{convname}/kernel']))
            self.conv3.weight.copy_(tf2th(weights[
                f'{prefix}c/{convname}/kernel']))
            self.gn1.weight.copy_(tf2th(weights[f'{prefix}a/group_norm/gamma'])
                )
            self.gn2.weight.copy_(tf2th(weights[f'{prefix}b/group_norm/gamma'])
                )
            self.gn3.weight.copy_(tf2th(weights[f'{prefix}c/group_norm/gamma'])
                )
            self.gn1.bias.copy_(tf2th(weights[f'{prefix}a/group_norm/beta']))
            self.gn2.bias.copy_(tf2th(weights[f'{prefix}b/group_norm/beta']))
            self.gn3.bias.copy_(tf2th(weights[f'{prefix}c/group_norm/beta']))
            if hasattr(self, 'downsample'):
                w = weights[f'{prefix}a/proj/{convname}/kernel']
                self.downsample.weight.copy_(tf2th(w))


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

    def __init__(self, block_units, width_factor, head_size=21843,
        zero_head=False):
        super().__init__()
        wf = width_factor
        self.wf = wf
        self.root = nn.Sequential(OrderedDict([('conv', StdConv2d(3, 64 *
            wf, kernel_size=7, stride=2, padding=3, bias=False)), ('pad',
            nn.ConstantPad2d(1, 0)), ('pool', nn.MaxPool2d(kernel_size=3,
            stride=2, padding=0))]))
        self.body = nn.Sequential(OrderedDict([('block1', nn.Sequential(
            OrderedDict([('unit01', PreActBottleneck(cin=64 * wf, cout=256 *
            wf, cmid=64 * wf))] + [(f'unit{i:02d}', PreActBottleneck(cin=
            256 * wf, cout=256 * wf, cmid=64 * wf)) for i in range(2, 
            block_units[0] + 1)]))), ('block2', nn.Sequential(OrderedDict([
            ('unit01', PreActBottleneck(cin=256 * wf, cout=512 * wf, cmid=
            128 * wf, stride=2))] + [(f'unit{i:02d}', PreActBottleneck(cin=
            512 * wf, cout=512 * wf, cmid=128 * wf)) for i in range(2, 
            block_units[1] + 1)]))), ('block3', nn.Sequential(OrderedDict([
            ('unit01', PreActBottleneck(cin=512 * wf, cout=1024 * wf, cmid=
            256 * wf, stride=2))] + [(f'unit{i:02d}', PreActBottleneck(cin=
            1024 * wf, cout=1024 * wf, cmid=256 * wf)) for i in range(2, 
            block_units[2] + 1)]))), ('block4', nn.Sequential(OrderedDict([
            ('unit01', PreActBottleneck(cin=1024 * wf, cout=2048 * wf, cmid
            =512 * wf, stride=2))] + [(f'unit{i:02d}', PreActBottleneck(cin
            =2048 * wf, cout=2048 * wf, cmid=512 * wf)) for i in range(2, 
            block_units[3] + 1)])))]))
        self.zero_head = zero_head
        self.head = nn.Sequential(OrderedDict([('gn', nn.GroupNorm(32, 2048 *
            wf)), ('relu', nn.ReLU(inplace=True)), ('avg', nn.
            AdaptiveAvgPool2d(output_size=1)), ('conv', nn.Conv2d(2048 * wf,
            head_size, kernel_size=1, bias=True))]))

    def load_from(self, weights, prefix='resnet/'):
        with torch.no_grad():
            self.root.conv.weight.copy_(tf2th(weights[
                f'{prefix}root_block/standardized_conv2d/kernel']))
            self.head.gn.weight.copy_(tf2th(weights[
                f'{prefix}group_norm/gamma']))
            self.head.gn.bias.copy_(tf2th(weights[f'{prefix}group_norm/beta']))
            if self.zero_head:
                nn.init.zeros_(self.head.conv.weight)
                nn.init.zeros_(self.head.conv.bias)
            else:
                self.head.conv.weight.copy_(tf2th(weights[
                    f'{prefix}head/conv2d/kernel']))
                self.head.conv.bias.copy_(tf2th(weights[
                    f'{prefix}head/conv2d/bias']))
            for bname, block in self.body.named_children():
                for uname, unit in block.named_children():
                    unit.load_from(weights, prefix=f'{prefix}{bname}/{uname}/')

    def forward(self, input_0):
        primals_1 = self.root.conv.weight
        primals_3 = self.body.block1.unit01.gn1.weight
        primals_4 = self.body.block1.unit01.gn1.bias
        primals_6 = self.body.block1.unit01.conv1.weight
        primals_7 = self.body.block1.unit01.gn2.weight
        primals_8 = self.body.block1.unit01.gn2.bias
        primals_9 = self.body.block1.unit01.conv2.weight
        primals_10 = self.body.block1.unit01.conv2.bias
        primals_11 = self.body.block1.unit01.gn3.weight
        primals_12 = self.body.block1.unit01.gn3.bias
        primals_5 = self.body.block1.unit01.conv3.weight
        primals_13 = self.body.block1.unit01.downsample.weight
        primals_14 = self.body.block1.unit02.gn1.weight
        primals_15 = self.body.block1.unit02.gn1.bias
        primals_16 = self.body.block1.unit02.conv1.weight
        primals_17 = self.body.block1.unit02.gn2.weight
        primals_18 = self.body.block1.unit02.gn2.bias
        primals_19 = self.body.block1.unit02.conv2.weight
        primals_20 = self.body.block1.unit02.conv2.bias
        primals_21 = self.body.block1.unit02.gn3.weight
        primals_22 = self.body.block1.unit02.gn3.bias
        primals_23 = self.body.block1.unit02.conv3.weight
        primals_24 = self.body.block1.unit03.gn1.weight
        primals_25 = self.body.block1.unit03.gn1.bias
        primals_26 = self.body.block1.unit03.conv1.weight
        primals_27 = self.body.block1.unit03.gn2.weight
        primals_28 = self.body.block1.unit03.gn2.bias
        primals_29 = self.body.block1.unit03.conv2.weight
        primals_30 = self.body.block1.unit03.conv2.bias
        primals_31 = self.body.block1.unit03.gn3.weight
        primals_32 = self.body.block1.unit03.gn3.bias
        primals_33 = self.body.block1.unit03.conv3.weight
        primals_34 = self.body.block1.unit04.gn1.weight
        primals_35 = self.body.block1.unit04.gn1.bias
        primals_36 = self.body.block1.unit04.conv1.weight
        primals_37 = self.body.block1.unit04.gn2.weight
        primals_38 = self.body.block1.unit04.gn2.bias
        primals_39 = self.body.block1.unit04.conv2.weight
        primals_40 = self.body.block1.unit04.conv2.bias
        primals_41 = self.body.block1.unit04.gn3.weight
        primals_42 = self.body.block1.unit04.gn3.bias
        primals_43 = self.body.block1.unit04.conv3.weight
        primals_44 = self.body.block2.unit01.gn1.weight
        primals_45 = self.body.block2.unit01.gn1.bias
        primals_47 = self.body.block2.unit01.conv1.weight
        primals_48 = self.body.block2.unit01.gn2.weight
        primals_49 = self.body.block2.unit01.gn2.bias
        primals_50 = self.body.block2.unit01.conv2.weight
        primals_51 = self.body.block2.unit01.conv2.bias
        primals_52 = self.body.block2.unit01.gn3.weight
        primals_53 = self.body.block2.unit01.gn3.bias
        primals_54 = self.body.block2.unit01.conv3.weight
        primals_46 = self.body.block2.unit01.downsample.weight
        primals_55 = self.body.block2.unit02.gn1.weight
        primals_56 = self.body.block2.unit02.gn1.bias
        primals_57 = self.body.block2.unit02.conv1.weight
        primals_58 = self.body.block2.unit02.gn2.weight
        primals_59 = self.body.block2.unit02.gn2.bias
        primals_60 = self.body.block2.unit02.conv2.weight
        primals_61 = self.body.block2.unit02.conv2.bias
        primals_62 = self.body.block2.unit02.gn3.weight
        primals_63 = self.body.block2.unit02.gn3.bias
        primals_64 = self.body.block2.unit02.conv3.weight
        primals_65 = self.body.block2.unit03.gn1.weight
        primals_66 = self.body.block2.unit03.gn1.bias
        primals_67 = self.body.block2.unit03.conv1.weight
        primals_68 = self.body.block2.unit03.gn2.weight
        primals_69 = self.body.block2.unit03.gn2.bias
        primals_70 = self.body.block2.unit03.conv2.weight
        primals_71 = self.body.block2.unit03.conv2.bias
        primals_72 = self.body.block2.unit03.gn3.weight
        primals_73 = self.body.block2.unit03.gn3.bias
        primals_74 = self.body.block2.unit03.conv3.weight
        primals_75 = self.body.block2.unit04.gn1.weight
        primals_76 = self.body.block2.unit04.gn1.bias
        primals_77 = self.body.block2.unit04.conv1.weight
        primals_78 = self.body.block2.unit04.gn2.weight
        primals_79 = self.body.block2.unit04.gn2.bias
        primals_80 = self.body.block2.unit04.conv2.weight
        primals_81 = self.body.block2.unit04.conv2.bias
        primals_82 = self.body.block2.unit04.gn3.weight
        primals_83 = self.body.block2.unit04.gn3.bias
        primals_84 = self.body.block2.unit04.conv3.weight
        primals_85 = self.body.block3.unit01.gn1.weight
        primals_86 = self.body.block3.unit01.gn1.bias
        primals_88 = self.body.block3.unit01.conv1.weight
        primals_89 = self.body.block3.unit01.gn2.weight
        primals_90 = self.body.block3.unit01.gn2.bias
        primals_91 = self.body.block3.unit01.conv2.weight
        primals_92 = self.body.block3.unit01.conv2.bias
        primals_93 = self.body.block3.unit01.gn3.weight
        primals_94 = self.body.block3.unit01.gn3.bias
        primals_95 = self.body.block3.unit01.conv3.weight
        primals_87 = self.body.block3.unit01.downsample.weight
        primals_96 = self.body.block3.unit02.gn1.weight
        primals_97 = self.body.block3.unit02.gn1.bias
        primals_98 = self.body.block3.unit02.conv1.weight
        primals_99 = self.body.block3.unit02.gn2.weight
        primals_100 = self.body.block3.unit02.gn2.bias
        primals_101 = self.body.block3.unit02.conv2.weight
        primals_102 = self.body.block3.unit02.conv2.bias
        primals_103 = self.body.block3.unit02.gn3.weight
        primals_104 = self.body.block3.unit02.gn3.bias
        primals_105 = self.body.block3.unit02.conv3.weight
        primals_106 = self.body.block3.unit03.gn1.weight
        primals_107 = self.body.block3.unit03.gn1.bias
        primals_108 = self.body.block3.unit03.conv1.weight
        primals_109 = self.body.block3.unit03.gn2.weight
        primals_110 = self.body.block3.unit03.gn2.bias
        primals_111 = self.body.block3.unit03.conv2.weight
        primals_112 = self.body.block3.unit03.conv2.bias
        primals_113 = self.body.block3.unit03.gn3.weight
        primals_114 = self.body.block3.unit03.gn3.bias
        primals_115 = self.body.block3.unit03.conv3.weight
        primals_116 = self.body.block3.unit04.gn1.weight
        primals_117 = self.body.block3.unit04.gn1.bias
        primals_118 = self.body.block3.unit04.conv1.weight
        primals_119 = self.body.block3.unit04.gn2.weight
        primals_120 = self.body.block3.unit04.gn2.bias
        primals_121 = self.body.block3.unit04.conv2.weight
        primals_122 = self.body.block3.unit04.conv2.bias
        primals_123 = self.body.block3.unit04.gn3.weight
        primals_124 = self.body.block3.unit04.gn3.bias
        primals_125 = self.body.block3.unit04.conv3.weight
        primals_126 = self.body.block4.unit01.gn1.weight
        primals_127 = self.body.block4.unit01.gn1.bias
        primals_129 = self.body.block4.unit01.conv1.weight
        primals_130 = self.body.block4.unit01.gn2.weight
        primals_131 = self.body.block4.unit01.gn2.bias
        primals_132 = self.body.block4.unit01.conv2.weight
        primals_133 = self.body.block4.unit01.conv2.bias
        primals_134 = self.body.block4.unit01.gn3.weight
        primals_135 = self.body.block4.unit01.gn3.bias
        primals_136 = self.body.block4.unit01.conv3.weight
        primals_128 = self.body.block4.unit01.downsample.weight
        primals_137 = self.body.block4.unit02.gn1.weight
        primals_138 = self.body.block4.unit02.gn1.bias
        primals_139 = self.body.block4.unit02.conv1.weight
        primals_140 = self.body.block4.unit02.gn2.weight
        primals_141 = self.body.block4.unit02.gn2.bias
        primals_142 = self.body.block4.unit02.conv2.weight
        primals_143 = self.body.block4.unit02.conv2.bias
        primals_144 = self.body.block4.unit02.gn3.weight
        primals_145 = self.body.block4.unit02.gn3.bias
        primals_146 = self.body.block4.unit02.conv3.weight
        primals_147 = self.body.block4.unit03.gn1.weight
        primals_148 = self.body.block4.unit03.gn1.bias
        primals_149 = self.body.block4.unit03.conv1.weight
        primals_150 = self.body.block4.unit03.gn2.weight
        primals_151 = self.body.block4.unit03.gn2.bias
        primals_152 = self.body.block4.unit03.conv2.weight
        primals_153 = self.body.block4.unit03.conv2.bias
        primals_154 = self.body.block4.unit03.gn3.weight
        primals_155 = self.body.block4.unit03.gn3.bias
        primals_156 = self.body.block4.unit03.conv3.weight
        primals_157 = self.body.block4.unit04.gn1.weight
        primals_158 = self.body.block4.unit04.gn1.bias
        primals_159 = self.body.block4.unit04.conv1.weight
        primals_160 = self.body.block4.unit04.gn2.weight
        primals_161 = self.body.block4.unit04.gn2.bias
        primals_162 = self.body.block4.unit04.conv2.weight
        primals_163 = self.body.block4.unit04.conv2.bias
        primals_164 = self.body.block4.unit04.gn3.weight
        primals_165 = self.body.block4.unit04.gn3.bias
        primals_166 = self.body.block4.unit04.conv3.weight
        primals_167 = self.head.gn.weight
        primals_168 = self.head.gn.bias
        primals_169 = self.head.conv.weight
        primals_170 = self.head.conv.bias
        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, primals_122, primals_123, primals_124,
            primals_125, primals_126, primals_127, primals_128, primals_129,
            primals_130, primals_131, primals_132, primals_133, primals_134,
            primals_135, primals_136, primals_137, primals_138, primals_139,
            primals_140, primals_141, primals_142, primals_143, primals_144,
            primals_145, primals_146, primals_147, primals_148, primals_149,
            primals_150, primals_151, primals_152, primals_153, primals_154,
            primals_155, primals_156, primals_157, primals_158, primals_159,
            primals_160, primals_161, primals_162, primals_163, primals_164,
            primals_165, primals_166, primals_167, primals_168, primals_169,
            primals_170])
        return output[0]
