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
import torch.nn as nn
import torch.nn.functional as F
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda


@triton.jit
def triton_poi_fused_convolution_relu_0(in_out_ptr0, in_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 16516096
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x3 = xindex
    x1 = xindex // 64516 % 64
    tmp0 = tl.load(in_out_ptr0 + x3, xmask)
    tmp1 = tl.load(in_ptr0 + x1, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, xmask)


@triton.jit
def triton_poi_fused_convolution_relu_1(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)
    x3 = xindex
    x1 = xindex // 63504 % 64
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused_max_pool2d_with_indices_2(in_ptr0, out_ptr0, out_ptr1,
    xnumel, XBLOCK: tl.constexpr):
    xnumel = 4064256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex % 126
    x3 = xindex // 126
    x2 = xindex // 15876
    x4 = xindex % 15876
    tmp0 = tl.load(in_ptr0 + (2 * x0 + 504 * x3), xmask, eviction_policy=
        'evict_last')
    tmp1 = tl.load(in_ptr0 + (1 + 2 * x0 + 504 * x3), xmask,
        eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr0 + (252 + 2 * x0 + 504 * x3), xmask,
        eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr0 + (253 + 2 * x0 + 504 * x3), xmask,
        eviction_policy='evict_last')
    tmp2 = triton_helpers.maximum(tmp1, tmp0)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp6 = triton_helpers.maximum(tmp5, tmp4)
    tmp7 = tmp1 > tmp0
    tmp8 = tl.full([1], 1, tl.int8)
    tmp9 = tl.full([1], 0, tl.int8)
    tmp10 = tl.where(tmp7, tmp8, tmp9)
    tmp11 = tmp3 > tmp2
    tmp12 = tl.full([1], 2, tl.int8)
    tmp13 = tl.where(tmp11, tmp12, tmp10)
    tmp14 = tmp5 > tmp4
    tmp15 = tl.full([1], 3, tl.int8)
    tmp16 = tl.where(tmp14, tmp15, tmp13)
    tl.store(out_ptr0 + (x4 + 15904 * x2), tmp6, xmask)
    tl.store(out_ptr1 + (x4 + 16000 * x2), tmp16, xmask)


@triton.jit
def triton_poi_fused_convolution_relu_3(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)
    x3 = xindex
    x1 = xindex // 15376 % 128
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused_convolution_relu_4(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)
    x3 = xindex
    x1 = xindex // 14884 % 128
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused_max_pool2d_with_indices_5(in_ptr0, out_ptr0, out_ptr1,
    xnumel, XBLOCK: tl.constexpr):
    xnumel = 1905152
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex % 61
    x3 = xindex // 61
    x2 = xindex // 3721
    x4 = xindex % 3721
    tmp0 = tl.load(in_ptr0 + (2 * x0 + 244 * x3), xmask, eviction_policy=
        'evict_last')
    tmp1 = tl.load(in_ptr0 + (1 + 2 * x0 + 244 * x3), xmask,
        eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr0 + (122 + 2 * x0 + 244 * x3), xmask,
        eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr0 + (123 + 2 * x0 + 244 * x3), xmask,
        eviction_policy='evict_last')
    tmp2 = triton_helpers.maximum(tmp1, tmp0)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp6 = triton_helpers.maximum(tmp5, tmp4)
    tmp7 = tmp1 > tmp0
    tmp8 = tl.full([1], 1, tl.int8)
    tmp9 = tl.full([1], 0, tl.int8)
    tmp10 = tl.where(tmp7, tmp8, tmp9)
    tmp11 = tmp3 > tmp2
    tmp12 = tl.full([1], 2, tl.int8)
    tmp13 = tl.where(tmp11, tmp12, tmp10)
    tmp14 = tmp5 > tmp4
    tmp15 = tl.full([1], 3, tl.int8)
    tmp16 = tl.where(tmp14, tmp15, tmp13)
    tl.store(out_ptr0 + (x4 + 3744 * x2), tmp6, xmask)
    tl.store(out_ptr1 + (x4 + 3840 * x2), tmp16, xmask)


@triton.jit
def triton_poi_fused_convolution_relu_6(in_out_ptr0, in_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 3564544
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x3 = xindex
    x1 = xindex // 3481 % 256
    tmp0 = tl.load(in_out_ptr0 + x3, xmask)
    tmp1 = tl.load(in_ptr0 + x1, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, xmask)


@triton.jit
def triton_poi_fused_convolution_relu_7(in_out_ptr0, in_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 3326976
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x3 = xindex
    x1 = xindex // 3249 % 256
    tmp0 = tl.load(in_out_ptr0 + x3, xmask)
    tmp1 = tl.load(in_ptr0 + x1, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, xmask)


@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 % 28
    x1 = xindex // 28 % 28
    x2 = xindex // 784
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (2 * x0 + 114 * x1 + 3249 * x2), None,
        eviction_policy='evict_last')
    tmp1 = tl.load(in_ptr0 + (1 + 2 * x0 + 114 * x1 + 3249 * x2), None,
        eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr0 + (57 + 2 * x0 + 114 * x1 + 3249 * x2), None,
        eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr0 + (58 + 2 * x0 + 114 * x1 + 3249 * x2), None,
        eviction_policy='evict_last')
    tmp2 = triton_helpers.maximum(tmp1, tmp0)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp6 = triton_helpers.maximum(tmp5, tmp4)
    tmp7 = tmp1 > tmp0
    tmp8 = tl.full([1], 1, tl.int8)
    tmp9 = tl.full([1], 0, tl.int8)
    tmp10 = tl.where(tmp7, tmp8, tmp9)
    tmp11 = tmp3 > tmp2
    tmp12 = tl.full([1], 2, tl.int8)
    tmp13 = tl.where(tmp11, tmp12, tmp10)
    tmp14 = tmp5 > tmp4
    tmp15 = tl.full([1], 3, tl.int8)
    tmp16 = tl.where(tmp14, tmp15, tmp13)
    tl.store(out_ptr0 + x3, tmp6, None)
    tl.store(out_ptr1 + x3, tmp16, None)


@triton.jit
def triton_poi_fused_convolution_relu_9(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)
    x3 = xindex
    x1 = xindex // 676 % 512
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused_convolution_relu_10(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)
    x3 = xindex
    x1 = xindex // 576 % 512
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused_max_pool2d_with_indices_11(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 % 12
    x1 = xindex // 12
    x2 = xindex
    tmp0 = tl.load(in_ptr0 + (2 * x0 + 48 * x1), None, eviction_policy=
        'evict_last')
    tmp1 = tl.load(in_ptr0 + (1 + 2 * x0 + 48 * x1), None, eviction_policy=
        'evict_last')
    tmp3 = tl.load(in_ptr0 + (24 + 2 * x0 + 48 * x1), None, eviction_policy
        ='evict_last')
    tmp5 = tl.load(in_ptr0 + (25 + 2 * x0 + 48 * x1), None, eviction_policy
        ='evict_last')
    tmp2 = triton_helpers.maximum(tmp1, tmp0)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp6 = triton_helpers.maximum(tmp5, tmp4)
    tmp7 = tmp1 > tmp0
    tmp8 = tl.full([1], 1, tl.int8)
    tmp9 = tl.full([1], 0, tl.int8)
    tmp10 = tl.where(tmp7, tmp8, tmp9)
    tmp11 = tmp3 > tmp2
    tmp12 = tl.full([1], 2, tl.int8)
    tmp13 = tl.where(tmp11, tmp12, tmp10)
    tmp14 = tmp5 > tmp4
    tmp15 = tl.full([1], 3, tl.int8)
    tmp16 = tl.where(tmp14, tmp15, tmp13)
    tl.store(out_ptr0 + x2, tmp6, None)
    tl.store(out_ptr1 + x2, tmp16, None)


@triton.jit
def triton_poi_fused_convolution_relu_12(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)
    x3 = xindex
    x1 = xindex // 100 % 1024
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused_convolution_relu_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)
    x3 = xindex
    x1 = xindex // 64 % 1024
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused__to_copy_14(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 16
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.4666666666666667
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp6, xmask)


@triton.jit
def triton_poi_fused_add_clamp_15(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 16
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.4666666666666667
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tl.full([1], 1, tl.int64)
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 7, tl.int64)
    tmp10 = triton_helpers.minimum(tmp8, tmp9)
    tl.store(out_ptr0 + x0, tmp10, xmask)


@triton.jit
def triton_poi_fused__to_copy_arange_clamp_mul_sub_16(out_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 16
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.4666666666666667
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 - tmp7
    tmp9 = triton_helpers.maximum(tmp8, tmp4)
    tmp10 = 1.0
    tmp11 = triton_helpers.minimum(tmp9, tmp10)
    tl.store(out_ptr0 + x0, tmp11, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_add_convolution_mul_sub_17(in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, 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)
    x1 = xindex // 16 % 16
    x0 = xindex % 16
    x5 = xindex // 256
    x2 = xindex // 256 % 512
    x6 = xindex
    tmp0 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr1 + x0, None, eviction_policy='evict_last')
    tmp10 = tl.load(in_ptr3 + x2, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp19 = tl.load(in_ptr5 + x0, None, eviction_policy='evict_last')
    tmp22 = tl.load(in_ptr6 + x1, None, eviction_policy='evict_last')
    tmp34 = tl.load(in_ptr7 + x1, None, eviction_policy='evict_last')
    tmp1 = tl.full([XBLOCK], 8, tl.int32)
    tmp2 = tmp0 + tmp1
    tmp3 = tmp0 < 0
    tmp4 = tl.where(tmp3, tmp2, tmp0)
    tmp6 = tmp5 + tmp1
    tmp7 = tmp5 < 0
    tmp8 = tl.where(tmp7, tmp6, tmp5)
    tmp9 = tl.load(in_ptr2 + (tmp8 + 8 * tmp4 + 64 * x5), None,
        eviction_policy='evict_last')
    tmp11 = tmp9 + tmp10
    tmp13 = tmp12 + tmp1
    tmp14 = tmp12 < 0
    tmp15 = tl.where(tmp14, tmp13, tmp12)
    tmp16 = tl.load(in_ptr2 + (tmp15 + 8 * tmp4 + 64 * x5), None,
        eviction_policy='evict_last')
    tmp17 = tmp16 + tmp10
    tmp18 = tmp17 - tmp11
    tmp20 = tmp18 * tmp19
    tmp21 = tmp11 + tmp20
    tmp23 = tmp22 + tmp1
    tmp24 = tmp22 < 0
    tmp25 = tl.where(tmp24, tmp23, tmp22)
    tmp26 = tl.load(in_ptr2 + (tmp8 + 8 * tmp25 + 64 * x5), None,
        eviction_policy='evict_last')
    tmp27 = tmp26 + tmp10
    tmp28 = tl.load(in_ptr2 + (tmp15 + 8 * tmp25 + 64 * x5), None,
        eviction_policy='evict_last')
    tmp29 = tmp28 + tmp10
    tmp30 = tmp29 - tmp27
    tmp31 = tmp30 * tmp19
    tmp32 = tmp27 + tmp31
    tmp33 = tmp32 - tmp21
    tmp35 = tmp33 * tmp34
    tl.store(out_ptr0 + x6, tmp21, None)
    tl.store(out_ptr1 + x6, tmp35, None)


@triton.jit
def triton_poi_fused_cat_18(in_ptr0, in_ptr1, in_ptr2, 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 // 784 % 1024
    x1 = xindex // 28 % 28
    x0 = xindex % 28
    x3 = xindex // 802816
    x6 = xindex
    tmp0 = x2
    tmp1 = tl.full([1], 0, tl.int64)
    tmp3 = tl.full([1], 512, tl.int64)
    tmp4 = tmp0 < tmp3
    tmp5 = -2 + x1
    tmp6 = tmp5 >= tmp1
    tmp7 = tl.full([1], 24, tl.int64)
    tmp8 = tmp5 < tmp7
    tmp9 = -2 + x0
    tmp10 = tmp9 >= tmp1
    tmp11 = tmp9 < tmp7
    tmp12 = tmp6 & tmp8
    tmp13 = tmp12 & tmp10
    tmp14 = tmp13 & tmp11
    tmp15 = tmp14 & tmp4
    tmp16 = tl.load(in_ptr0 + (-50 + x0 + 24 * x1 + 576 * x2 + 294912 * x3),
        tmp15, other=0.0)
    tmp17 = tl.full(tmp16.shape, 0.0, tmp16.dtype)
    tmp18 = tl.where(tmp4, tmp16, tmp17)
    tmp19 = tmp0 >= tmp3
    tl.full([1], 1024, tl.int64)
    tmp22 = -6 + x1
    tmp23 = tmp22 >= tmp1
    tmp24 = tl.full([1], 16, tl.int64)
    tmp25 = tmp22 < tmp24
    tmp26 = -6 + x0
    tmp27 = tmp26 >= tmp1
    tmp28 = tmp26 < tmp24
    tmp29 = tmp23 & tmp25
    tmp30 = tmp29 & tmp27
    tmp31 = tmp30 & tmp28
    tmp32 = tmp31 & tmp19
    tmp33 = tl.load(in_ptr1 + (-102 + x0 + 16 * x1 + 256 * (-512 + x2) + 
        131072 * x3), tmp32, other=0.0)
    tmp34 = tl.load(in_ptr2 + (-102 + x0 + 16 * x1 + 256 * (-512 + x2) + 
        131072 * x3), tmp32, other=0.0)
    tmp35 = tmp33 + tmp34
    tmp36 = tl.full(tmp35.shape, 0.0, tmp35.dtype)
    tmp37 = tl.where(tmp32, tmp35, tmp36)
    tmp38 = tl.full(tmp37.shape, 0.0, tmp37.dtype)
    tmp39 = tl.where(tmp19, tmp37, tmp38)
    tmp40 = tl.where(tmp4, tmp18, tmp39)
    tl.store(out_ptr0 + x6, tmp40, None)


@triton.jit
def triton_poi_fused__to_copy_19(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 48
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.48936170212765956
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp6, xmask)


@triton.jit
def triton_poi_fused_add_clamp_20(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 48
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.48936170212765956
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tl.full([1], 1, tl.int64)
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 23, tl.int64)
    tmp10 = triton_helpers.minimum(tmp8, tmp9)
    tl.store(out_ptr0 + x0, tmp10, xmask)


@triton.jit
def triton_poi_fused__to_copy_arange_clamp_mul_sub_21(out_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 48
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.48936170212765956
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 - tmp7
    tmp9 = triton_helpers.maximum(tmp8, tmp4)
    tmp10 = 1.0
    tmp11 = triton_helpers.minimum(tmp9, tmp10)
    tl.store(out_ptr0 + x0, tmp11, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_add_convolution_mul_sub_22(in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, 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)
    x1 = xindex // 48 % 48
    x0 = xindex % 48
    x5 = xindex // 2304
    x2 = xindex // 2304 % 256
    x6 = xindex
    tmp0 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr1 + x0, None, eviction_policy='evict_last')
    tmp10 = tl.load(in_ptr3 + x2, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp19 = tl.load(in_ptr5 + x0, None, eviction_policy='evict_last')
    tmp22 = tl.load(in_ptr6 + x1, None, eviction_policy='evict_last')
    tmp34 = tl.load(in_ptr7 + x1, None, eviction_policy='evict_last')
    tmp1 = tl.full([XBLOCK], 24, tl.int32)
    tmp2 = tmp0 + tmp1
    tmp3 = tmp0 < 0
    tmp4 = tl.where(tmp3, tmp2, tmp0)
    tmp6 = tmp5 + tmp1
    tmp7 = tmp5 < 0
    tmp8 = tl.where(tmp7, tmp6, tmp5)
    tmp9 = tl.load(in_ptr2 + (tmp8 + 24 * tmp4 + 576 * x5), None,
        eviction_policy='evict_last')
    tmp11 = tmp9 + tmp10
    tmp13 = tmp12 + tmp1
    tmp14 = tmp12 < 0
    tmp15 = tl.where(tmp14, tmp13, tmp12)
    tmp16 = tl.load(in_ptr2 + (tmp15 + 24 * tmp4 + 576 * x5), None,
        eviction_policy='evict_last')
    tmp17 = tmp16 + tmp10
    tmp18 = tmp17 - tmp11
    tmp20 = tmp18 * tmp19
    tmp21 = tmp11 + tmp20
    tmp23 = tmp22 + tmp1
    tmp24 = tmp22 < 0
    tmp25 = tl.where(tmp24, tmp23, tmp22)
    tmp26 = tl.load(in_ptr2 + (tmp8 + 24 * tmp25 + 576 * x5), None,
        eviction_policy='evict_last')
    tmp27 = tmp26 + tmp10
    tmp28 = tl.load(in_ptr2 + (tmp15 + 24 * tmp25 + 576 * x5), None,
        eviction_policy='evict_last')
    tmp29 = tmp28 + tmp10
    tmp30 = tmp29 - tmp27
    tmp31 = tmp30 * tmp19
    tmp32 = tmp27 + tmp31
    tmp33 = tmp32 - tmp21
    tmp35 = tmp33 * tmp34
    tl.store(out_ptr0 + x6, tmp21, None)
    tl.store(out_ptr1 + x6, tmp35, None)


@triton.jit
def triton_poi_fused_cat_23(in_ptr0, in_ptr1, in_ptr2, 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 // 3721 % 512
    x1 = xindex // 61 % 61
    x0 = xindex % 61
    x3 = xindex // 1905152
    x6 = xindex
    tmp0 = x2
    tmp1 = tl.full([1], 0, tl.int64)
    tmp3 = tl.full([1], 256, tl.int64)
    tmp4 = tmp0 < tmp3
    tmp5 = -2 + x1
    tmp6 = tmp5 >= tmp1
    tmp7 = tl.full([1], 57, tl.int64)
    tmp8 = tmp5 < tmp7
    tmp9 = -2 + x0
    tmp10 = tmp9 >= tmp1
    tmp11 = tmp9 < tmp7
    tmp12 = tmp6 & tmp8
    tmp13 = tmp12 & tmp10
    tmp14 = tmp13 & tmp11
    tmp15 = tmp14 & tmp4
    tmp16 = tl.load(in_ptr0 + (-116 + x0 + 57 * x1 + 3249 * x2 + 831744 *
        x3), tmp15, other=0.0)
    tmp17 = tl.full(tmp16.shape, 0.0, tmp16.dtype)
    tmp18 = tl.where(tmp4, tmp16, tmp17)
    tmp19 = tmp0 >= tmp3
    tl.full([1], 512, tl.int64)
    tmp22 = -6 + x1
    tmp23 = tmp22 >= tmp1
    tmp24 = tl.full([1], 48, tl.int64)
    tmp25 = tmp22 < tmp24
    tmp26 = -6 + x0
    tmp27 = tmp26 >= tmp1
    tmp28 = tmp26 < tmp24
    tmp29 = tmp23 & tmp25
    tmp30 = tmp29 & tmp27
    tmp31 = tmp30 & tmp28
    tmp32 = tmp31 & tmp19
    tmp33 = tl.load(in_ptr1 + (-294 + x0 + 48 * x1 + 2304 * (-256 + x2) + 
        589824 * x3), tmp32, other=0.0)
    tmp34 = tl.load(in_ptr2 + (-294 + x0 + 48 * x1 + 2304 * (-256 + x2) + 
        589824 * x3), tmp32, other=0.0)
    tmp35 = tmp33 + tmp34
    tmp36 = tl.full(tmp35.shape, 0.0, tmp35.dtype)
    tmp37 = tl.where(tmp32, tmp35, tmp36)
    tmp38 = tl.full(tmp37.shape, 0.0, tmp37.dtype)
    tmp39 = tl.where(tmp19, tmp37, tmp38)
    tmp40 = tl.where(tmp4, tmp18, tmp39)
    tl.store(out_ptr0 + x6, tmp40, None)


@triton.jit
def triton_poi_fused__to_copy_24(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 114
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.49557522123893805
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp6, xmask)


@triton.jit
def triton_poi_fused_add_clamp_25(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 114
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.49557522123893805
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tl.full([1], 1, tl.int64)
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 56, tl.int64)
    tmp10 = triton_helpers.minimum(tmp8, tmp9)
    tl.store(out_ptr0 + x0, tmp10, xmask)


@triton.jit
def triton_poi_fused__to_copy_arange_clamp_mul_sub_26(out_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 114
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.49557522123893805
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 - tmp7
    tmp9 = triton_helpers.maximum(tmp8, tmp4)
    tmp10 = 1.0
    tmp11 = triton_helpers.minimum(tmp9, tmp10)
    tl.store(out_ptr0 + x0, tmp11, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_add_convolution_mul_sub_27(in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, 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)
    x1 = xindex // 114 % 114
    x0 = xindex % 114
    x5 = xindex // 12996
    x2 = xindex // 12996 % 128
    x4 = xindex % 12996
    tmp0 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr1 + x0, None, eviction_policy='evict_last')
    tmp10 = tl.load(in_ptr3 + x2, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp19 = tl.load(in_ptr5 + x0, None, eviction_policy='evict_last')
    tmp22 = tl.load(in_ptr6 + x1, None, eviction_policy='evict_last')
    tmp34 = tl.load(in_ptr7 + x1, None, eviction_policy='evict_last')
    tmp1 = tl.full([XBLOCK], 57, tl.int32)
    tmp2 = tmp0 + tmp1
    tmp3 = tmp0 < 0
    tmp4 = tl.where(tmp3, tmp2, tmp0)
    tmp6 = tmp5 + tmp1
    tmp7 = tmp5 < 0
    tmp8 = tl.where(tmp7, tmp6, tmp5)
    tmp9 = tl.load(in_ptr2 + (tmp8 + 57 * tmp4 + 3249 * x5), None,
        eviction_policy='evict_last')
    tmp11 = tmp9 + tmp10
    tmp13 = tmp12 + tmp1
    tmp14 = tmp12 < 0
    tmp15 = tl.where(tmp14, tmp13, tmp12)
    tmp16 = tl.load(in_ptr2 + (tmp15 + 57 * tmp4 + 3249 * x5), None,
        eviction_policy='evict_last')
    tmp17 = tmp16 + tmp10
    tmp18 = tmp17 - tmp11
    tmp20 = tmp18 * tmp19
    tmp21 = tmp11 + tmp20
    tmp23 = tmp22 + tmp1
    tmp24 = tmp22 < 0
    tmp25 = tl.where(tmp24, tmp23, tmp22)
    tmp26 = tl.load(in_ptr2 + (tmp8 + 57 * tmp25 + 3249 * x5), None,
        eviction_policy='evict_last')
    tmp27 = tmp26 + tmp10
    tmp28 = tl.load(in_ptr2 + (tmp15 + 57 * tmp25 + 3249 * x5), None,
        eviction_policy='evict_last')
    tmp29 = tmp28 + tmp10
    tmp30 = tmp29 - tmp27
    tmp31 = tmp30 * tmp19
    tmp32 = tmp27 + tmp31
    tmp33 = tmp32 - tmp21
    tmp35 = tmp33 * tmp34
    tl.store(out_ptr0 + (x4 + 13024 * x5), tmp21, None)
    tl.store(out_ptr1 + (x4 + 13024 * x5), tmp35, None)


@triton.jit
def triton_poi_fused_cat_28(in_ptr0, in_ptr1, in_ptr2, 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 // 15876 % 256
    x1 = xindex // 126 % 126
    x0 = xindex % 126
    x3 = xindex // 4064256
    x6 = xindex
    tmp0 = x2
    tmp1 = tl.full([1], 0, tl.int64)
    tmp3 = tl.full([1], 128, tl.int64)
    tmp4 = tmp0 < tmp3
    tmp5 = -2 + x1
    tmp6 = tmp5 >= tmp1
    tmp7 = tl.full([1], 122, tl.int64)
    tmp8 = tmp5 < tmp7
    tmp9 = -2 + x0
    tmp10 = tmp9 >= tmp1
    tmp11 = tmp9 < tmp7
    tmp12 = tmp6 & tmp8
    tmp13 = tmp12 & tmp10
    tmp14 = tmp13 & tmp11
    tmp15 = tmp14 & tmp4
    tmp16 = tl.load(in_ptr0 + (-246 + x0 + 122 * x1 + 14884 * x2 + 1905152 *
        x3), tmp15, other=0.0)
    tmp17 = tl.full(tmp16.shape, 0.0, tmp16.dtype)
    tmp18 = tl.where(tmp4, tmp16, tmp17)
    tmp19 = tmp0 >= tmp3
    tl.full([1], 256, tl.int64)
    tmp22 = -6 + x1
    tmp23 = tmp22 >= tmp1
    tmp24 = tl.full([1], 114, tl.int64)
    tmp25 = tmp22 < tmp24
    tmp26 = -6 + x0
    tmp27 = tmp26 >= tmp1
    tmp28 = tmp26 < tmp24
    tmp29 = tmp23 & tmp25
    tmp30 = tmp29 & tmp27
    tmp31 = tmp30 & tmp28
    tmp32 = tmp31 & tmp19
    tmp33 = tl.load(in_ptr1 + (-690 + x0 + 114 * x1 + 13024 * (-128 + x2) +
        1667072 * x3), tmp32, other=0.0)
    tmp34 = tl.load(in_ptr2 + (-690 + x0 + 114 * x1 + 13024 * (-128 + x2) +
        1667072 * x3), tmp32, other=0.0)
    tmp35 = tmp33 + tmp34
    tmp36 = tl.full(tmp35.shape, 0.0, tmp35.dtype)
    tmp37 = tl.where(tmp32, tmp35, tmp36)
    tmp38 = tl.full(tmp37.shape, 0.0, tmp37.dtype)
    tmp39 = tl.where(tmp19, tmp37, tmp38)
    tmp40 = tl.where(tmp4, tmp18, tmp39)
    tl.store(out_ptr0 + x6, tmp40, None)


@triton.jit
def triton_poi_fused__to_copy_29(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 244
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.49794238683127573
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp6, xmask)


@triton.jit
def triton_poi_fused_add_clamp_30(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 244
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.49794238683127573
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tl.full([1], 1, tl.int64)
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 121, tl.int64)
    tmp10 = triton_helpers.minimum(tmp8, tmp9)
    tl.store(out_ptr0 + x0, tmp10, xmask)


@triton.jit
def triton_poi_fused__to_copy_arange_clamp_mul_sub_31(out_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 244
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = x0
    tmp1 = tmp0.to(tl.float32)
    tmp2 = 0.49794238683127573
    tmp3 = tmp1 * tmp2
    tmp4 = 0.0
    tmp5 = triton_helpers.maximum(tmp3, tmp4)
    tmp6 = tmp5.to(tl.int32)
    tmp7 = tmp6.to(tl.float32)
    tmp8 = tmp5 - tmp7
    tmp9 = triton_helpers.maximum(tmp8, tmp4)
    tmp10 = 1.0
    tmp11 = triton_helpers.minimum(tmp9, tmp10)
    tl.store(out_ptr0 + x0, tmp11, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_add_convolution_mul_sub_32(in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, 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)
    x1 = xindex // 244 % 244
    x0 = xindex % 244
    x5 = xindex // 59536
    x2 = xindex // 59536 % 64
    x4 = xindex % 59536
    tmp0 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr1 + x0, None, eviction_policy='evict_last')
    tmp10 = tl.load(in_ptr3 + x2, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr4 + x0, None, eviction_policy='evict_last')
    tmp19 = tl.load(in_ptr5 + x0, None, eviction_policy='evict_last')
    tmp22 = tl.load(in_ptr6 + x1, None, eviction_policy='evict_last')
    tmp34 = tl.load(in_ptr7 + x1, None, eviction_policy='evict_last')
    tmp1 = tl.full([XBLOCK], 122, tl.int32)
    tmp2 = tmp0 + tmp1
    tmp3 = tmp0 < 0
    tmp4 = tl.where(tmp3, tmp2, tmp0)
    tmp6 = tmp5 + tmp1
    tmp7 = tmp5 < 0
    tmp8 = tl.where(tmp7, tmp6, tmp5)
    tmp9 = tl.load(in_ptr2 + (tmp8 + 122 * tmp4 + 14884 * x5), None,
        eviction_policy='evict_last')
    tmp11 = tmp9 + tmp10
    tmp13 = tmp12 + tmp1
    tmp14 = tmp12 < 0
    tmp15 = tl.where(tmp14, tmp13, tmp12)
    tmp16 = tl.load(in_ptr2 + (tmp15 + 122 * tmp4 + 14884 * x5), None,
        eviction_policy='evict_last')
    tmp17 = tmp16 + tmp10
    tmp18 = tmp17 - tmp11
    tmp20 = tmp18 * tmp19
    tmp21 = tmp11 + tmp20
    tmp23 = tmp22 + tmp1
    tmp24 = tmp22 < 0
    tmp25 = tl.where(tmp24, tmp23, tmp22)
    tmp26 = tl.load(in_ptr2 + (tmp8 + 122 * tmp25 + 14884 * x5), None,
        eviction_policy='evict_last')
    tmp27 = tmp26 + tmp10
    tmp28 = tl.load(in_ptr2 + (tmp15 + 122 * tmp25 + 14884 * x5), None,
        eviction_policy='evict_last')
    tmp29 = tmp28 + tmp10
    tmp30 = tmp29 - tmp27
    tmp31 = tmp30 * tmp19
    tmp32 = tmp27 + tmp31
    tmp33 = tmp32 - tmp21
    tmp35 = tmp33 * tmp34
    tl.store(out_ptr0 + (x4 + 59552 * x5), tmp21, None)
    tl.store(out_ptr1 + (x4 + 59552 * x5), tmp35, None)


@triton.jit
def triton_poi_fused_cat_33(in_ptr0, in_ptr1, in_ptr2, 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 // 65536 % 128
    x1 = xindex // 256 % 256
    x0 = xindex % 256
    x3 = xindex // 8388608
    x6 = xindex
    tmp0 = x2
    tmp1 = tl.full([1], 0, tl.int64)
    tmp3 = tl.full([1], 64, tl.int64)
    tmp4 = tmp0 < tmp3
    tmp5 = -2 + x1
    tmp6 = tmp5 >= tmp1
    tmp7 = tl.full([1], 252, tl.int64)
    tmp8 = tmp5 < tmp7
    tmp9 = -2 + x0
    tmp10 = tmp9 >= tmp1
    tmp11 = tmp9 < tmp7
    tmp12 = tmp6 & tmp8
    tmp13 = tmp12 & tmp10
    tmp14 = tmp13 & tmp11
    tmp15 = tmp14 & tmp4
    tmp16 = tl.load(in_ptr0 + (-506 + x0 + 252 * x1 + 63504 * x2 + 4064256 *
        x3), tmp15, other=0.0)
    tmp17 = tl.full(tmp16.shape, 0.0, tmp16.dtype)
    tmp18 = tl.where(tmp4, tmp16, tmp17)
    tmp19 = tmp0 >= tmp3
    tl.full([1], 128, tl.int64)
    tmp22 = -6 + x1
    tmp23 = tmp22 >= tmp1
    tmp24 = tl.full([1], 244, tl.int64)
    tmp25 = tmp22 < tmp24
    tmp26 = -6 + x0
    tmp27 = tmp26 >= tmp1
    tmp28 = tmp26 < tmp24
    tmp29 = tmp23 & tmp25
    tmp30 = tmp29 & tmp27
    tmp31 = tmp30 & tmp28
    tmp32 = tmp31 & tmp19
    tmp33 = tl.load(in_ptr1 + (-1470 + x0 + 244 * x1 + 59552 * (-64 + x2) +
        3811328 * x3), tmp32, other=0.0)
    tmp34 = tl.load(in_ptr2 + (-1470 + x0 + 244 * x1 + 59552 * (-64 + x2) +
        3811328 * x3), tmp32, other=0.0)
    tmp35 = tmp33 + tmp34
    tmp36 = tl.full(tmp35.shape, 0.0, tmp35.dtype)
    tmp37 = tl.where(tmp32, tmp35, tmp36)
    tmp38 = tl.full(tmp37.shape, 0.0, tmp37.dtype)
    tmp39 = tl.where(tmp19, tmp37, tmp38)
    tmp40 = tl.where(tmp4, tmp18, tmp39)
    tl.store(out_ptr0 + x6, tmp40, None)


@triton.jit
def triton_poi_fused_constant_pad_nd_convolution_relu_34(in_ptr0, in_ptr1,
    out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x1 = xindex // 256 % 256
    x0 = xindex % 256
    x4 = xindex // 65536
    x2 = xindex // 65536 % 64
    x6 = xindex
    tmp0 = -2 + x1
    tmp1 = tl.full([1], 0, tl.int64)
    tmp2 = tmp0 >= tmp1
    tmp3 = tl.full([1], 252, tl.int64)
    tmp4 = tmp0 < tmp3
    tmp5 = -2 + x0
    tmp6 = tmp5 >= tmp1
    tmp7 = tmp5 < tmp3
    tmp8 = tmp2 & tmp4
    tmp9 = tmp8 & tmp6
    tmp10 = tmp9 & tmp7
    tmp11 = tl.load(in_ptr0 + (-506 + x0 + 252 * x1 + 63504 * x4), tmp10,
        other=0.0)
    tmp12 = tl.load(in_ptr1 + x2, tmp10, eviction_policy='evict_last',
        other=0.0)
    tmp13 = tmp11 + tmp12
    tmp14 = tl.full([1], 0, tl.int32)
    tmp15 = triton_helpers.maximum(tmp14, tmp13)
    tmp16 = tl.full(tmp15.shape, 0.0, tmp15.dtype)
    tmp17 = tl.where(tmp10, tmp15, tmp16)
    tl.store(out_ptr0 + x6, tmp17, None)


@triton.jit
def triton_poi_fused_convolution_35(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)
    x3 = xindex
    x1 = xindex // 65536 % 4
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tl.store(in_out_ptr0 + x3, tmp2, None)


@triton.jit
def triton_poi_fused_convolution_relu_threshold_backward_36(in_ptr0,
    in_ptr1, 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
    x1 = xindex // 63504 % 64
    x0 = xindex % 63504
    x4 = xindex // 63504
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp5 = 0.0
    tmp6 = tmp4 <= tmp5
    tl.store(out_ptr0 + (x0 + 63616 * x4), tmp6, None)


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) = args
    args.clear()
    assert_size_stride(primals_1, (64, 4, 3, 3), (36, 9, 3, 1))
    assert_size_stride(primals_2, (64,), (1,))
    assert_size_stride(primals_3, (4, 4, 256, 256), (262144, 65536, 256, 1))
    assert_size_stride(primals_4, (64, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_5, (64,), (1,))
    assert_size_stride(primals_6, (128, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_7, (128,), (1,))
    assert_size_stride(primals_8, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_9, (128,), (1,))
    assert_size_stride(primals_10, (256, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_11, (256,), (1,))
    assert_size_stride(primals_12, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_13, (256,), (1,))
    assert_size_stride(primals_14, (512, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_15, (512,), (1,))
    assert_size_stride(primals_16, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_17, (512,), (1,))
    assert_size_stride(primals_18, (1024, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_19, (1024,), (1,))
    assert_size_stride(primals_20, (1024, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_21, (1024,), (1,))
    assert_size_stride(primals_22, (512, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_23, (512,), (1,))
    assert_size_stride(primals_24, (512, 1024, 3, 3), (9216, 9, 3, 1))
    assert_size_stride(primals_25, (512,), (1,))
    assert_size_stride(primals_26, (512, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_27, (512,), (1,))
    assert_size_stride(primals_28, (256, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_29, (256,), (1,))
    assert_size_stride(primals_30, (256, 512, 3, 3), (4608, 9, 3, 1))
    assert_size_stride(primals_31, (256,), (1,))
    assert_size_stride(primals_32, (256, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_33, (256,), (1,))
    assert_size_stride(primals_34, (128, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_35, (128,), (1,))
    assert_size_stride(primals_36, (128, 256, 3, 3), (2304, 9, 3, 1))
    assert_size_stride(primals_37, (128,), (1,))
    assert_size_stride(primals_38, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_39, (128,), (1,))
    assert_size_stride(primals_40, (64, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_41, (64,), (1,))
    assert_size_stride(primals_42, (64, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_43, (64,), (1,))
    assert_size_stride(primals_44, (64, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_45, (64,), (1,))
    assert_size_stride(primals_46, (4, 64, 1, 1), (64, 1, 1, 1))
    assert_size_stride(primals_47, (4,), (1,))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = extern_kernels.convolution(primals_3, primals_1, stride=(1, 
            1), padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf0, (4, 64, 254, 254), (4129024, 64516, 254, 1))
        buf1 = buf0
        del buf0
        get_raw_stream(0)
        triton_poi_fused_convolution_relu_0[grid(16516096)](buf1, primals_2,
            16516096, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_2
        buf2 = extern_kernels.convolution(buf1, primals_4, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf2, (4, 64, 252, 252), (4064256, 63504, 252, 1))
        buf3 = buf2
        del buf2
        triton_poi_fused_convolution_relu_1[grid(16257024)](buf3, primals_5,
            16257024, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_5
        buf4 = empty_strided_cuda((4, 64, 126, 126), (1017856, 15904, 126, 
            1), torch.float32)
        buf5 = empty_strided_cuda((4, 64, 126, 126), (1024000, 16000, 126, 
            1), torch.int8)
        triton_poi_fused_max_pool2d_with_indices_2[grid(4064256)](buf3,
            buf4, buf5, 4064256, XBLOCK=512, num_warps=8, num_stages=1)
        buf6 = extern_kernels.convolution(buf4, primals_6, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf6, (4, 128, 124, 124), (1968128, 15376, 124, 1))
        buf7 = buf6
        del buf6
        triton_poi_fused_convolution_relu_3[grid(7872512)](buf7, primals_7,
            7872512, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_7
        buf8 = extern_kernels.convolution(buf7, primals_8, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf8, (4, 128, 122, 122), (1905152, 14884, 122, 1))
        buf9 = buf8
        del buf8
        triton_poi_fused_convolution_relu_4[grid(7620608)](buf9, primals_9,
            7620608, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_9
        buf10 = empty_strided_cuda((4, 128, 61, 61), (479232, 3744, 61, 1),
            torch.float32)
        buf11 = empty_strided_cuda((4, 128, 61, 61), (491520, 3840, 61, 1),
            torch.int8)
        triton_poi_fused_max_pool2d_with_indices_5[grid(1905152)](buf9,
            buf10, buf11, 1905152, XBLOCK=512, num_warps=8, num_stages=1)
        buf12 = extern_kernels.convolution(buf10, primals_10, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf12, (4, 256, 59, 59), (891136, 3481, 59, 1))
        buf13 = buf12
        del buf12
        triton_poi_fused_convolution_relu_6[grid(3564544)](buf13,
            primals_11, 3564544, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_11
        buf14 = extern_kernels.convolution(buf13, primals_12, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf14, (4, 256, 57, 57), (831744, 3249, 57, 1))
        buf15 = buf14
        del buf14
        triton_poi_fused_convolution_relu_7[grid(3326976)](buf15,
            primals_13, 3326976, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_13
        buf16 = empty_strided_cuda((4, 256, 28, 28), (200704, 784, 28, 1),
            torch.float32)
        buf17 = empty_strided_cuda((4, 256, 28, 28), (200704, 784, 28, 1),
            torch.int8)
        triton_poi_fused_max_pool2d_with_indices_8[grid(802816)](buf15,
            buf16, buf17, 802816, XBLOCK=512, num_warps=8, num_stages=1)
        buf18 = extern_kernels.convolution(buf16, primals_14, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf18, (4, 512, 26, 26), (346112, 676, 26, 1))
        buf19 = buf18
        del buf18
        triton_poi_fused_convolution_relu_9[grid(1384448)](buf19,
            primals_15, 1384448, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_15
        buf20 = extern_kernels.convolution(buf19, primals_16, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf20, (4, 512, 24, 24), (294912, 576, 24, 1))
        buf21 = buf20
        del buf20
        triton_poi_fused_convolution_relu_10[grid(1179648)](buf21,
            primals_17, 1179648, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_17
        buf22 = empty_strided_cuda((4, 512, 12, 12), (73728, 144, 12, 1),
            torch.float32)
        buf23 = empty_strided_cuda((4, 512, 12, 12), (73728, 144, 12, 1),
            torch.int8)
        triton_poi_fused_max_pool2d_with_indices_11[grid(294912)](buf21,
            buf22, buf23, 294912, XBLOCK=512, num_warps=8, num_stages=1)
        buf24 = extern_kernels.convolution(buf22, primals_18, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf24, (4, 1024, 10, 10), (102400, 100, 10, 1))
        buf25 = buf24
        del buf24
        triton_poi_fused_convolution_relu_12[grid(409600)](buf25,
            primals_19, 409600, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_19
        buf26 = extern_kernels.convolution(buf25, primals_20, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf26, (4, 1024, 8, 8), (65536, 64, 8, 1))
        buf27 = buf26
        del buf26
        triton_poi_fused_convolution_relu_13[grid(262144)](buf27,
            primals_21, 262144, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_21
        buf28 = extern_kernels.convolution(buf27, primals_22, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf28, (4, 512, 8, 8), (32768, 64, 8, 1))
        buf29 = empty_strided_cuda((16, 1), (1, 1), torch.int64)
        triton_poi_fused__to_copy_14[grid(16)](buf29, 16, XBLOCK=16,
            num_warps=1, num_stages=1)
        buf30 = empty_strided_cuda((16, 1), (1, 1), torch.int64)
        triton_poi_fused_add_clamp_15[grid(16)](buf30, 16, XBLOCK=16,
            num_warps=1, num_stages=1)
        buf31 = empty_strided_cuda((16,), (1,), torch.int64)
        triton_poi_fused__to_copy_14[grid(16)](buf31, 16, XBLOCK=16,
            num_warps=1, num_stages=1)
        buf32 = empty_strided_cuda((16,), (1,), torch.int64)
        triton_poi_fused_add_clamp_15[grid(16)](buf32, 16, XBLOCK=16,
            num_warps=1, num_stages=1)
        buf33 = empty_strided_cuda((16,), (1,), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_16[grid(16)](buf33, 
            16, XBLOCK=16, num_warps=1, num_stages=1)
        buf35 = empty_strided_cuda((16, 1), (1, 1), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_16[grid(16)](buf35, 
            16, XBLOCK=16, num_warps=1, num_stages=1)
        buf34 = empty_strided_cuda((4, 512, 16, 16), (131072, 256, 16, 1),
            torch.float32)
        buf36 = empty_strided_cuda((4, 512, 16, 16), (131072, 256, 16, 1),
            torch.float32)
        triton_poi_fused__unsafe_index_add_convolution_mul_sub_17[grid(524288)
            ](buf29, buf31, buf28, primals_23, buf32, buf33, buf30, buf35,
            buf34, buf36, 524288, XBLOCK=1024, num_warps=4, num_stages=1)
        del buf28
        del primals_23
        buf37 = empty_strided_cuda((4, 1024, 28, 28), (802816, 784, 28, 1),
            torch.float32)
        triton_poi_fused_cat_18[grid(3211264)](buf21, buf34, buf36, buf37, 
            3211264, XBLOCK=512, num_warps=8, num_stages=1)
        del buf34
        del buf36
        buf38 = extern_kernels.convolution(buf37, primals_24, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf38, (4, 512, 26, 26), (346112, 676, 26, 1))
        buf39 = buf38
        del buf38
        triton_poi_fused_convolution_relu_9[grid(1384448)](buf39,
            primals_25, 1384448, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_25
        buf40 = extern_kernels.convolution(buf39, primals_26, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf40, (4, 512, 24, 24), (294912, 576, 24, 1))
        buf41 = buf40
        del buf40
        triton_poi_fused_convolution_relu_10[grid(1179648)](buf41,
            primals_27, 1179648, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_27
        buf42 = extern_kernels.convolution(buf41, primals_28, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf42, (4, 256, 24, 24), (147456, 576, 24, 1))
        buf43 = empty_strided_cuda((48, 1), (1, 1), torch.int64)
        triton_poi_fused__to_copy_19[grid(48)](buf43, 48, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf44 = empty_strided_cuda((48, 1), (1, 1), torch.int64)
        triton_poi_fused_add_clamp_20[grid(48)](buf44, 48, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf45 = empty_strided_cuda((48,), (1,), torch.int64)
        triton_poi_fused__to_copy_19[grid(48)](buf45, 48, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf46 = empty_strided_cuda((48,), (1,), torch.int64)
        triton_poi_fused_add_clamp_20[grid(48)](buf46, 48, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf47 = empty_strided_cuda((48,), (1,), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_21[grid(48)](buf47, 
            48, XBLOCK=64, num_warps=1, num_stages=1)
        buf49 = empty_strided_cuda((48, 1), (1, 1), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_21[grid(48)](buf49, 
            48, XBLOCK=64, num_warps=1, num_stages=1)
        buf48 = empty_strided_cuda((4, 256, 48, 48), (589824, 2304, 48, 1),
            torch.float32)
        buf50 = empty_strided_cuda((4, 256, 48, 48), (589824, 2304, 48, 1),
            torch.float32)
        triton_poi_fused__unsafe_index_add_convolution_mul_sub_22[grid(2359296)
            ](buf43, buf45, buf42, primals_29, buf46, buf47, buf44, buf49,
            buf48, buf50, 2359296, XBLOCK=512, num_warps=8, num_stages=1)
        del buf42
        del primals_29
        buf51 = empty_strided_cuda((4, 512, 61, 61), (1905152, 3721, 61, 1),
            torch.float32)
        triton_poi_fused_cat_23[grid(7620608)](buf15, buf48, buf50, buf51, 
            7620608, XBLOCK=1024, num_warps=4, num_stages=1)
        del buf48
        del buf50
        buf52 = extern_kernels.convolution(buf51, primals_30, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf52, (4, 256, 59, 59), (891136, 3481, 59, 1))
        buf53 = buf52
        del buf52
        triton_poi_fused_convolution_relu_6[grid(3564544)](buf53,
            primals_31, 3564544, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_31
        buf54 = extern_kernels.convolution(buf53, primals_32, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf54, (4, 256, 57, 57), (831744, 3249, 57, 1))
        buf55 = buf54
        del buf54
        triton_poi_fused_convolution_relu_7[grid(3326976)](buf55,
            primals_33, 3326976, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_33
        buf56 = extern_kernels.convolution(buf55, primals_34, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf56, (4, 128, 57, 57), (415872, 3249, 57, 1))
        buf57 = empty_strided_cuda((114, 1), (1, 1), torch.int64)
        triton_poi_fused__to_copy_24[grid(114)](buf57, 114, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf58 = empty_strided_cuda((114, 1), (1, 1), torch.int64)
        triton_poi_fused_add_clamp_25[grid(114)](buf58, 114, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf59 = empty_strided_cuda((114,), (1,), torch.int64)
        triton_poi_fused__to_copy_24[grid(114)](buf59, 114, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf60 = empty_strided_cuda((114,), (1,), torch.int64)
        triton_poi_fused_add_clamp_25[grid(114)](buf60, 114, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf61 = empty_strided_cuda((114,), (1,), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_26[grid(114)](buf61,
            114, XBLOCK=128, num_warps=4, num_stages=1)
        buf63 = empty_strided_cuda((114, 1), (1, 1), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_26[grid(114)](buf63,
            114, XBLOCK=128, num_warps=4, num_stages=1)
        buf62 = empty_strided_cuda((4, 128, 114, 114), (1667072, 13024, 114,
            1), torch.float32)
        buf64 = empty_strided_cuda((4, 128, 114, 114), (1667072, 13024, 114,
            1), torch.float32)
        triton_poi_fused__unsafe_index_add_convolution_mul_sub_27[grid(6653952)
            ](buf57, buf59, buf56, primals_35, buf60, buf61, buf58, buf63,
            buf62, buf64, 6653952, XBLOCK=512, num_warps=8, num_stages=1)
        del buf56
        del primals_35
        buf65 = empty_strided_cuda((4, 256, 126, 126), (4064256, 15876, 126,
            1), torch.float32)
        triton_poi_fused_cat_28[grid(16257024)](buf9, buf62, buf64, buf65, 
            16257024, XBLOCK=1024, num_warps=4, num_stages=1)
        del buf62
        del buf64
        buf66 = extern_kernels.convolution(buf65, primals_36, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf66, (4, 128, 124, 124), (1968128, 15376, 124, 1))
        buf67 = buf66
        del buf66
        triton_poi_fused_convolution_relu_3[grid(7872512)](buf67,
            primals_37, 7872512, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_37
        buf68 = extern_kernels.convolution(buf67, primals_38, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf68, (4, 128, 122, 122), (1905152, 14884, 122, 1))
        buf69 = buf68
        del buf68
        triton_poi_fused_convolution_relu_4[grid(7620608)](buf69,
            primals_39, 7620608, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_39
        buf70 = extern_kernels.convolution(buf69, primals_40, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf70, (4, 64, 122, 122), (952576, 14884, 122, 1))
        buf71 = empty_strided_cuda((244, 1), (1, 1), torch.int64)
        triton_poi_fused__to_copy_29[grid(244)](buf71, 244, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf72 = empty_strided_cuda((244, 1), (1, 1), torch.int64)
        triton_poi_fused_add_clamp_30[grid(244)](buf72, 244, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf73 = empty_strided_cuda((244,), (1,), torch.int64)
        triton_poi_fused__to_copy_29[grid(244)](buf73, 244, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf74 = empty_strided_cuda((244,), (1,), torch.int64)
        triton_poi_fused_add_clamp_30[grid(244)](buf74, 244, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf75 = empty_strided_cuda((244,), (1,), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_31[grid(244)](buf75,
            244, XBLOCK=256, num_warps=4, num_stages=1)
        buf77 = empty_strided_cuda((244, 1), (1, 1), torch.float32)
        triton_poi_fused__to_copy_arange_clamp_mul_sub_31[grid(244)](buf77,
            244, XBLOCK=256, num_warps=4, num_stages=1)
        buf76 = empty_strided_cuda((4, 64, 244, 244), (3811328, 59552, 244,
            1), torch.float32)
        buf78 = empty_strided_cuda((4, 64, 244, 244), (3811328, 59552, 244,
            1), torch.float32)
        triton_poi_fused__unsafe_index_add_convolution_mul_sub_32[grid(
            15241216)](buf71, buf73, buf70, primals_41, buf74, buf75, buf72,
            buf77, buf76, buf78, 15241216, XBLOCK=512, num_warps=8,
            num_stages=1)
        del buf70
        del primals_41
        buf79 = empty_strided_cuda((4, 128, 256, 256), (8388608, 65536, 256,
            1), torch.float32)
        triton_poi_fused_cat_33[grid(33554432)](buf3, buf76, buf78, buf79, 
            33554432, XBLOCK=1024, num_warps=4, num_stages=1)
        del buf76
        del buf78
        buf80 = extern_kernels.convolution(buf79, primals_42, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf80, (4, 64, 254, 254), (4129024, 64516, 254, 1))
        buf81 = buf80
        del buf80
        triton_poi_fused_convolution_relu_0[grid(16516096)](buf81,
            primals_43, 16516096, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_43
        buf82 = extern_kernels.convolution(buf81, primals_44, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf82, (4, 64, 252, 252), (4064256, 63504, 252, 1))
        buf83 = empty_strided_cuda((4, 64, 256, 256), (4194304, 65536, 256,
            1), torch.float32)
        triton_poi_fused_constant_pad_nd_convolution_relu_34[grid(16777216)](
            buf82, primals_45, buf83, 16777216, XBLOCK=1024, num_warps=4,
            num_stages=1)
        buf84 = extern_kernels.convolution(buf83, primals_46, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf84, (4, 4, 256, 256), (262144, 65536, 256, 1))
        buf85 = buf84
        del buf84
        triton_poi_fused_convolution_35[grid(1048576)](buf85, primals_47, 
            1048576, XBLOCK=1024, num_warps=4, num_stages=1)
        del primals_47
        buf86 = empty_strided_cuda((4, 64, 252, 252), (4071424, 63616, 252,
            1), torch.bool)
        triton_poi_fused_convolution_relu_threshold_backward_36[grid(16257024)
            ](buf82, primals_45, buf86, 16257024, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del buf82
        del primals_45
    return (buf85, primals_1, primals_3, primals_4, primals_6, primals_8,
        primals_10, primals_12, primals_14, primals_16, primals_18,
        primals_20, primals_22, primals_24, primals_26, primals_28,
        primals_30, primals_32, primals_34, primals_36, primals_38,
        primals_40, primals_42, primals_44, primals_46, buf1, buf3, buf4,
        buf5, buf7, buf9, buf10, buf11, buf13, buf15, buf16, buf17, buf19,
        buf21, buf22, buf23, buf25, buf27, buf29, buf30, buf31, buf32,
        buf33, buf35, buf37, buf39, buf41, buf43, buf44, buf45, buf46,
        buf47, buf49, buf51, buf53, buf55, buf57, buf58, buf59, buf60,
        buf61, buf63, buf65, buf67, buf69, buf71, buf72, buf73, buf74,
        buf75, buf77, buf79, buf81, buf83, buf86)


class DoubleConv(nn.Module):
    """
    Double 3x3 conv + relu
    """

    def __init__(self, in_channels, out_channels):
        super(DoubleConv, self).__init__()
        self.conv_1 = nn.Conv2d(in_channels, out_channels, 3)
        self.conv_2 = nn.Conv2d(out_channels, out_channels, 3)
        self.relu = nn.ReLU()

    def forward(self, x):
        x = self.conv_1(x)
        x = self.relu(x)
        x = self.conv_2(x)
        x = self.relu(x)
        return x


class UpsampleCat(nn.Module):
    """
    Unsample input and concat with contracting tensor
    """

    def __init__(self, ch):
        super(UpsampleCat, self).__init__()
        self.up_conv = nn.Conv2d(ch, ch // 2, 3, padding=1)
        self.up = nn.Upsample(scale_factor=2, mode='bilinear',
            align_corners=True)

    def forward(self, up, down):
        up = self.up_conv(up)
        up = self.up(up)
        up_w, up_h = up.size()[2:4]
        down_w, down_h = down.size()[2:4]
        dw = down_w + 4 - up_w
        dh = down_h + 4 - up_h
        down = F.pad(down, (2, 2, 2, 2))
        up = F.pad(up, (dw // 2, dw - dw // 2, dh // 2, dh - dh // 2))
        y = torch.cat([down, up], dim=1)
        return y


class UNetNew(nn.Module):
    """
    UNet model
    """

    def __init__(self, in_channels, out_channels):
        super(UNetNew, self).__init__()
        self.conv_1 = DoubleConv(in_channels, 64)
        self.conv_2 = DoubleConv(64, 128)
        self.conv_3 = DoubleConv(128, 256)
        self.conv_4 = DoubleConv(256, 512)
        self.conv_5 = DoubleConv(512, 1024)
        self.down = nn.MaxPool2d(2)
        self.up_1 = UpsampleCat(1024)
        self.up_2 = UpsampleCat(512)
        self.up_3 = UpsampleCat(256)
        self.up_4 = UpsampleCat(128)
        self.conv_6 = DoubleConv(1024, 512)
        self.conv_7 = DoubleConv(512, 256)
        self.conv_8 = DoubleConv(256, 128)
        self.conv_9 = DoubleConv(128, 64)
        self.out_conv = nn.Conv2d(64, out_channels, 1)

    def forward(self, input_0):
        primals_1 = self.conv_1.conv_1.weight
        primals_2 = self.conv_1.conv_1.bias
        primals_4 = self.conv_1.conv_2.weight
        primals_5 = self.conv_1.conv_2.bias
        primals_6 = self.conv_2.conv_1.weight
        primals_7 = self.conv_2.conv_1.bias
        primals_8 = self.conv_2.conv_2.weight
        primals_9 = self.conv_2.conv_2.bias
        primals_10 = self.conv_3.conv_1.weight
        primals_11 = self.conv_3.conv_1.bias
        primals_12 = self.conv_3.conv_2.weight
        primals_13 = self.conv_3.conv_2.bias
        primals_14 = self.conv_4.conv_1.weight
        primals_15 = self.conv_4.conv_1.bias
        primals_16 = self.conv_4.conv_2.weight
        primals_17 = self.conv_4.conv_2.bias
        primals_18 = self.conv_5.conv_1.weight
        primals_19 = self.conv_5.conv_1.bias
        primals_20 = self.conv_5.conv_2.weight
        primals_21 = self.conv_5.conv_2.bias
        primals_22 = self.up_1.up_conv.weight
        primals_23 = self.up_1.up_conv.bias
        primals_28 = self.up_2.up_conv.weight
        primals_29 = self.up_2.up_conv.bias
        primals_34 = self.up_3.up_conv.weight
        primals_35 = self.up_3.up_conv.bias
        primals_40 = self.up_4.up_conv.weight
        primals_41 = self.up_4.up_conv.bias
        primals_24 = self.conv_6.conv_1.weight
        primals_25 = self.conv_6.conv_1.bias
        primals_26 = self.conv_6.conv_2.weight
        primals_27 = self.conv_6.conv_2.bias
        primals_30 = self.conv_7.conv_1.weight
        primals_31 = self.conv_7.conv_1.bias
        primals_32 = self.conv_7.conv_2.weight
        primals_33 = self.conv_7.conv_2.bias
        primals_36 = self.conv_8.conv_1.weight
        primals_37 = self.conv_8.conv_1.bias
        primals_38 = self.conv_8.conv_2.weight
        primals_39 = self.conv_8.conv_2.bias
        primals_42 = self.conv_9.conv_1.weight
        primals_43 = self.conv_9.conv_1.bias
        primals_44 = self.conv_9.conv_2.weight
        primals_45 = self.conv_9.conv_2.bias
        primals_46 = self.out_conv.weight
        primals_47 = self.out_conv.bias
        primals_3 = 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])
        return output[0]


Measured latency_ms: 0.115393