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.nn import functional as F
import torch.nn as nn
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_convolution_leaky_relu_0(in_ptr0, in_ptr1, 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)
    x3 = xindex
    x1 = xindex // 4096 % 32
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tmp5 = 0.2
    tmp6 = tmp2 * tmp5
    tmp7 = tl.where(tmp4, tmp2, tmp6)
    tl.store(out_ptr0 + x3, tmp4, None)
    tl.store(out_ptr1 + x3, tmp7, None)


@triton.jit
def triton_poi_fused_convolution_leaky_relu_1(in_ptr0, in_ptr1, 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)
    x3 = xindex
    x1 = xindex // 1024 % 32
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tmp5 = 0.2
    tmp6 = tmp2 * tmp5
    tmp7 = tl.where(tmp4, tmp2, tmp6)
    tl.store(out_ptr0 + x3, tmp4, None)
    tl.store(out_ptr1 + x3, tmp7, None)


@triton.jit
def triton_poi_fused_convolution_leaky_relu_2(in_ptr0, in_ptr1, 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)
    x3 = xindex
    x1 = xindex // 1024 % 64
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tmp5 = 0.2
    tmp6 = tmp2 * tmp5
    tmp7 = tl.where(tmp4, tmp2, tmp6)
    tl.store(out_ptr0 + x3, tmp4, None)
    tl.store(out_ptr1 + x3, tmp7, None)


@triton.jit
def triton_poi_fused_convolution_leaky_relu_3(in_ptr0, in_ptr1, 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)
    x3 = xindex
    x1 = xindex // 256 % 64
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tmp5 = 0.2
    tmp6 = tmp2 * tmp5
    tmp7 = tl.where(tmp4, tmp2, tmp6)
    tl.store(out_ptr0 + x3, tmp4, None)
    tl.store(out_ptr1 + x3, tmp7, None)


@triton.jit
def triton_poi_fused_convolution_leaky_relu_4(in_ptr0, in_ptr1, 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)
    x3 = xindex
    x1 = xindex // 256 % 128
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tmp5 = 0.2
    tmp6 = tmp2 * tmp5
    tmp7 = tl.where(tmp4, tmp2, tmp6)
    tl.store(out_ptr0 + x3, tmp4, None)
    tl.store(out_ptr1 + x3, tmp7, None)


@triton.jit
def triton_poi_fused_add_convolution_5(in_out_ptr0, in_ptr0, in_ptr1,
    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 // 256 % 128
    tmp0 = tl.load(in_out_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr1 + x3, None)
    tmp2 = tmp0 + tmp1
    tmp4 = tmp2 + tmp3
    tl.store(in_out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused_convolution_leaky_relu_6(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 // 256 % 64
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tl.store(out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused__to_copy_7(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 32
    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.5
    tmp3 = tmp1 + tmp2
    tmp4 = tmp3 * tmp2
    tmp5 = tmp4 - tmp2
    tmp6 = 0.0
    tmp7 = triton_helpers.maximum(tmp5, tmp6)
    tmp8 = tmp7.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp8, xmask)


@triton.jit
def triton_poi_fused_add_clamp_8(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 32
    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.5
    tmp3 = tmp1 + tmp2
    tmp4 = tmp3 * tmp2
    tmp5 = tmp4 - tmp2
    tmp6 = 0.0
    tmp7 = triton_helpers.maximum(tmp5, tmp6)
    tmp8 = tmp7.to(tl.int32)
    tmp9 = tl.full([1], 1, tl.int64)
    tmp10 = tmp8 + tmp9
    tmp11 = tl.full([1], 15, tl.int64)
    tmp12 = triton_helpers.minimum(tmp10, tmp11)
    tl.store(out_ptr0 + x0, tmp12, xmask)


@triton.jit
def triton_poi_fused__to_copy_add_arange_clamp_mul_sub_9(out_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 32
    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.5
    tmp3 = tmp1 + tmp2
    tmp4 = tmp3 * tmp2
    tmp5 = tmp4 - tmp2
    tmp6 = 0.0
    tmp7 = triton_helpers.maximum(tmp5, tmp6)
    tmp8 = tmp7.to(tl.int32)
    tmp9 = tmp8.to(tl.float32)
    tmp10 = tmp7 - tmp9
    tmp11 = triton_helpers.maximum(tmp10, tmp6)
    tmp12 = 1.0
    tmp13 = triton_helpers.minimum(tmp11, tmp12)
    tl.store(out_ptr0 + x0, tmp13, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_add_convolution_leaky_relu_mul_sub_10(
    in_out_ptr1, in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5,
    in_ptr6, in_ptr7, in_ptr8, in_ptr9, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x1 = xindex // 32 % 32
    x0 = xindex % 32
    x6 = xindex // 1024
    x2 = xindex // 1024 % 64
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr1 + x0, None, eviction_policy='evict_last')
    tmp11 = tl.load(in_ptr4 + x2, None, eviction_policy='evict_last')
    tmp16 = tl.load(in_ptr5 + x1, None, eviction_policy='evict_last')
    tmp25 = tl.load(in_ptr6 + x0, None, eviction_policy='evict_last')
    tmp35 = tl.load(in_ptr7 + x0, None, eviction_policy='evict_last')
    tmp47 = tl.load(in_ptr8 + x1, None, eviction_policy='evict_last')
    tmp50 = tl.load(in_ptr9 + x4, None)
    tmp1 = tl.full([XBLOCK], 16, 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 + 16 * tmp4 + 256 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp10 = tl.load(in_ptr3 + (tmp8 + 16 * tmp4 + 256 * x6), None,
        eviction_policy='evict_last')
    tmp12 = tmp10 + tmp11
    tmp13 = 0.2
    tmp14 = tmp12 * tmp13
    tmp15 = tl.where(tmp9, tmp12, tmp14)
    tmp17 = tmp16 + tmp1
    tmp18 = tmp16 < 0
    tmp19 = tl.where(tmp18, tmp17, tmp16)
    tmp20 = tl.load(in_ptr2 + (tmp8 + 16 * tmp19 + 256 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp21 = tl.load(in_ptr3 + (tmp8 + 16 * tmp19 + 256 * x6), None,
        eviction_policy='evict_last')
    tmp22 = tmp21 + tmp11
    tmp23 = tmp22 * tmp13
    tmp24 = tl.where(tmp20, tmp22, tmp23)
    tmp26 = tmp25 + tmp1
    tmp27 = tmp25 < 0
    tmp28 = tl.where(tmp27, tmp26, tmp25)
    tmp29 = tl.load(in_ptr2 + (tmp28 + 16 * tmp19 + 256 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp30 = tl.load(in_ptr3 + (tmp28 + 16 * tmp19 + 256 * x6), None,
        eviction_policy='evict_last')
    tmp31 = tmp30 + tmp11
    tmp32 = tmp31 * tmp13
    tmp33 = tl.where(tmp29, tmp31, tmp32)
    tmp34 = tmp33 - tmp24
    tmp36 = tmp34 * tmp35
    tmp37 = tmp24 + tmp36
    tmp38 = tl.load(in_ptr2 + (tmp28 + 16 * tmp4 + 256 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp39 = tl.load(in_ptr3 + (tmp28 + 16 * tmp4 + 256 * x6), None,
        eviction_policy='evict_last')
    tmp40 = tmp39 + tmp11
    tmp41 = tmp40 * tmp13
    tmp42 = tl.where(tmp38, tmp40, tmp41)
    tmp43 = tmp42 - tmp15
    tmp44 = tmp43 * tmp35
    tmp45 = tmp15 + tmp44
    tmp46 = tmp45 - tmp37
    tmp48 = tmp46 * tmp47
    tmp49 = tmp37 + tmp48
    tmp51 = tmp49 + tmp50
    tl.store(in_out_ptr1 + x4, tmp51, None)


@triton.jit
def triton_poi_fused_convolution_leaky_relu_11(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 // 1024 % 32
    tmp0 = tl.load(in_ptr0 + x3, None)
    tmp1 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tl.store(out_ptr0 + x3, tmp4, None)


@triton.jit
def triton_poi_fused__to_copy_12(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 64
    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.5
    tmp3 = tmp1 + tmp2
    tmp4 = tmp3 * tmp2
    tmp5 = tmp4 - tmp2
    tmp6 = 0.0
    tmp7 = triton_helpers.maximum(tmp5, tmp6)
    tmp8 = tmp7.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp8, xmask)


@triton.jit
def triton_poi_fused_add_clamp_13(out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 64
    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.5
    tmp3 = tmp1 + tmp2
    tmp4 = tmp3 * tmp2
    tmp5 = tmp4 - tmp2
    tmp6 = 0.0
    tmp7 = triton_helpers.maximum(tmp5, tmp6)
    tmp8 = tmp7.to(tl.int32)
    tmp9 = tl.full([1], 1, tl.int64)
    tmp10 = tmp8 + tmp9
    tmp11 = tl.full([1], 31, tl.int64)
    tmp12 = triton_helpers.minimum(tmp10, tmp11)
    tl.store(out_ptr0 + x0, tmp12, xmask)


@triton.jit
def triton_poi_fused__to_copy_add_arange_clamp_mul_sub_14(out_ptr0, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 64
    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.5
    tmp3 = tmp1 + tmp2
    tmp4 = tmp3 * tmp2
    tmp5 = tmp4 - tmp2
    tmp6 = 0.0
    tmp7 = triton_helpers.maximum(tmp5, tmp6)
    tmp8 = tmp7.to(tl.int32)
    tmp9 = tmp8.to(tl.float32)
    tmp10 = tmp7 - tmp9
    tmp11 = triton_helpers.maximum(tmp10, tmp6)
    tmp12 = 1.0
    tmp13 = triton_helpers.minimum(tmp11, tmp12)
    tl.store(out_ptr0 + x0, tmp13, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_add_convolution_leaky_relu_mul_sub_15(
    in_out_ptr1, in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5,
    in_ptr6, in_ptr7, in_ptr8, in_ptr9, xnumel, XBLOCK: tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x1 = xindex // 64 % 64
    x0 = xindex % 64
    x6 = xindex // 4096
    x2 = xindex // 4096 % 32
    x4 = xindex
    tmp0 = tl.load(in_ptr0 + x1, None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr1 + x0, None, eviction_policy='evict_last')
    tmp11 = tl.load(in_ptr4 + x2, None, eviction_policy='evict_last')
    tmp16 = tl.load(in_ptr5 + x1, None, eviction_policy='evict_last')
    tmp25 = tl.load(in_ptr6 + x0, None, eviction_policy='evict_last')
    tmp35 = tl.load(in_ptr7 + x0, None, eviction_policy='evict_last')
    tmp47 = tl.load(in_ptr8 + x1, None, eviction_policy='evict_last')
    tmp50 = tl.load(in_ptr9 + x4, None)
    tmp1 = tl.full([XBLOCK], 32, 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 + 32 * tmp4 + 1024 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp10 = tl.load(in_ptr3 + (tmp8 + 32 * tmp4 + 1024 * x6), None,
        eviction_policy='evict_last')
    tmp12 = tmp10 + tmp11
    tmp13 = 0.2
    tmp14 = tmp12 * tmp13
    tmp15 = tl.where(tmp9, tmp12, tmp14)
    tmp17 = tmp16 + tmp1
    tmp18 = tmp16 < 0
    tmp19 = tl.where(tmp18, tmp17, tmp16)
    tmp20 = tl.load(in_ptr2 + (tmp8 + 32 * tmp19 + 1024 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp21 = tl.load(in_ptr3 + (tmp8 + 32 * tmp19 + 1024 * x6), None,
        eviction_policy='evict_last')
    tmp22 = tmp21 + tmp11
    tmp23 = tmp22 * tmp13
    tmp24 = tl.where(tmp20, tmp22, tmp23)
    tmp26 = tmp25 + tmp1
    tmp27 = tmp25 < 0
    tmp28 = tl.where(tmp27, tmp26, tmp25)
    tmp29 = tl.load(in_ptr2 + (tmp28 + 32 * tmp19 + 1024 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp30 = tl.load(in_ptr3 + (tmp28 + 32 * tmp19 + 1024 * x6), None,
        eviction_policy='evict_last')
    tmp31 = tmp30 + tmp11
    tmp32 = tmp31 * tmp13
    tmp33 = tl.where(tmp29, tmp31, tmp32)
    tmp34 = tmp33 - tmp24
    tmp36 = tmp34 * tmp35
    tmp37 = tmp24 + tmp36
    tmp38 = tl.load(in_ptr2 + (tmp28 + 32 * tmp4 + 1024 * x6), None,
        eviction_policy='evict_last').to(tl.int1)
    tmp39 = tl.load(in_ptr3 + (tmp28 + 32 * tmp4 + 1024 * x6), None,
        eviction_policy='evict_last')
    tmp40 = tmp39 + tmp11
    tmp41 = tmp40 * tmp13
    tmp42 = tl.where(tmp38, tmp40, tmp41)
    tmp43 = tmp42 - tmp15
    tmp44 = tmp43 * tmp35
    tmp45 = tmp15 + tmp44
    tmp46 = tmp45 - tmp37
    tmp48 = tmp46 * tmp47
    tmp49 = tmp37 + tmp48
    tmp51 = tmp49 + tmp50
    tl.store(in_out_ptr1 + x4, tmp51, None)


@triton.jit
def triton_poi_fused_convolution_16(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 // 4096 % 3
    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)


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) = args
    args.clear()
    assert_size_stride(primals_1, (32, 3, 7, 7), (147, 49, 7, 1))
    assert_size_stride(primals_2, (32,), (1,))
    assert_size_stride(primals_3, (4, 3, 64, 64), (12288, 4096, 64, 1))
    assert_size_stride(primals_4, (32, 32, 3, 3), (288, 9, 3, 1))
    assert_size_stride(primals_5, (32,), (1,))
    assert_size_stride(primals_6, (64, 32, 3, 3), (288, 9, 3, 1))
    assert_size_stride(primals_7, (64,), (1,))
    assert_size_stride(primals_8, (64, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_9, (64,), (1,))
    assert_size_stride(primals_10, (128, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_11, (128,), (1,))
    assert_size_stride(primals_12, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_13, (128,), (1,))
    assert_size_stride(primals_14, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_15, (128,), (1,))
    assert_size_stride(primals_16, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_17, (128,), (1,))
    assert_size_stride(primals_18, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_19, (128,), (1,))
    assert_size_stride(primals_20, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_21, (128,), (1,))
    assert_size_stride(primals_22, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_23, (128,), (1,))
    assert_size_stride(primals_24, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_25, (128,), (1,))
    assert_size_stride(primals_26, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_27, (128,), (1,))
    assert_size_stride(primals_28, (64, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_29, (64,), (1,))
    assert_size_stride(primals_30, (64, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_31, (64,), (1,))
    assert_size_stride(primals_32, (32, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_33, (32,), (1,))
    assert_size_stride(primals_34, (32, 32, 3, 3), (288, 9, 3, 1))
    assert_size_stride(primals_35, (32,), (1,))
    assert_size_stride(primals_36, (3, 32, 7, 7), (1568, 49, 7, 1))
    assert_size_stride(primals_37, (3,), (1,))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = extern_kernels.convolution(primals_3, primals_1, stride=(1, 
            1), padding=(3, 3), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf0, (4, 32, 64, 64), (131072, 4096, 64, 1))
        buf1 = empty_strided_cuda((4, 32, 64, 64), (131072, 4096, 64, 1),
            torch.bool)
        buf2 = empty_strided_cuda((4, 32, 64, 64), (131072, 4096, 64, 1),
            torch.float32)
        get_raw_stream(0)
        triton_poi_fused_convolution_leaky_relu_0[grid(524288)](buf0,
            primals_2, buf1, buf2, 524288, XBLOCK=512, num_warps=8,
            num_stages=1)
        del primals_2
        buf3 = extern_kernels.convolution(buf2, primals_4, stride=(2, 2),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf3, (4, 32, 32, 32), (32768, 1024, 32, 1))
        buf4 = empty_strided_cuda((4, 32, 32, 32), (32768, 1024, 32, 1),
            torch.bool)
        buf5 = empty_strided_cuda((4, 32, 32, 32), (32768, 1024, 32, 1),
            torch.float32)
        triton_poi_fused_convolution_leaky_relu_1[grid(131072)](buf3,
            primals_5, buf4, buf5, 131072, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del primals_5
        buf6 = extern_kernels.convolution(buf5, primals_6, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf6, (4, 64, 32, 32), (65536, 1024, 32, 1))
        buf7 = empty_strided_cuda((4, 64, 32, 32), (65536, 1024, 32, 1),
            torch.bool)
        buf8 = empty_strided_cuda((4, 64, 32, 32), (65536, 1024, 32, 1),
            torch.float32)
        triton_poi_fused_convolution_leaky_relu_2[grid(262144)](buf6,
            primals_7, buf7, buf8, 262144, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del primals_7
        buf9 = extern_kernels.convolution(buf8, primals_8, stride=(2, 2),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf9, (4, 64, 16, 16), (16384, 256, 16, 1))
        buf10 = empty_strided_cuda((4, 64, 16, 16), (16384, 256, 16, 1),
            torch.bool)
        buf11 = empty_strided_cuda((4, 64, 16, 16), (16384, 256, 16, 1),
            torch.float32)
        triton_poi_fused_convolution_leaky_relu_3[grid(65536)](buf9,
            primals_9, buf10, buf11, 65536, XBLOCK=512, num_warps=4,
            num_stages=1)
        del buf9
        del primals_9
        buf12 = extern_kernels.convolution(buf11, primals_10, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf12, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf13 = empty_strided_cuda((4, 128, 16, 16), (32768, 256, 16, 1),
            torch.bool)
        buf14 = reinterpret_tensor(buf3, (4, 128, 16, 16), (32768, 256, 16,
            1), 0)
        del buf3
        triton_poi_fused_convolution_leaky_relu_4[grid(131072)](buf12,
            primals_11, buf13, buf14, 131072, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del primals_11
        buf15 = extern_kernels.convolution(buf14, primals_12, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf15, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf16 = empty_strided_cuda((4, 128, 16, 16), (32768, 256, 16, 1),
            torch.bool)
        buf17 = buf12
        del buf12
        triton_poi_fused_convolution_leaky_relu_4[grid(131072)](buf15,
            primals_13, buf16, buf17, 131072, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del primals_13
        buf18 = extern_kernels.convolution(buf17, primals_14, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf18, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf19 = buf18
        del buf18
        triton_poi_fused_add_convolution_5[grid(131072)](buf19, primals_15,
            buf14, 131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_15
        buf20 = extern_kernels.convolution(buf19, primals_16, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf20, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf21 = empty_strided_cuda((4, 128, 16, 16), (32768, 256, 16, 1),
            torch.bool)
        buf22 = buf15
        del buf15
        triton_poi_fused_convolution_leaky_relu_4[grid(131072)](buf20,
            primals_17, buf21, buf22, 131072, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del primals_17
        buf23 = extern_kernels.convolution(buf22, primals_18, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf23, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf24 = buf23
        del buf23
        triton_poi_fused_add_convolution_5[grid(131072)](buf24, primals_19,
            buf19, 131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_19
        buf25 = extern_kernels.convolution(buf24, primals_20, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf25, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf26 = empty_strided_cuda((4, 128, 16, 16), (32768, 256, 16, 1),
            torch.bool)
        buf27 = buf20
        del buf20
        triton_poi_fused_convolution_leaky_relu_4[grid(131072)](buf25,
            primals_21, buf26, buf27, 131072, XBLOCK=1024, num_warps=4,
            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, 128, 16, 16), (32768, 256, 16, 1))
        buf29 = buf28
        del buf28
        triton_poi_fused_add_convolution_5[grid(131072)](buf29, primals_23,
            buf24, 131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_23
        buf30 = extern_kernels.convolution(buf29, primals_24, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf30, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf31 = empty_strided_cuda((4, 128, 16, 16), (32768, 256, 16, 1),
            torch.bool)
        buf32 = buf25
        del buf25
        triton_poi_fused_convolution_leaky_relu_4[grid(131072)](buf30,
            primals_25, buf31, buf32, 131072, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del buf30
        del primals_25
        buf33 = extern_kernels.convolution(buf32, primals_26, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf33, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf34 = buf33
        del buf33
        triton_poi_fused_add_convolution_5[grid(131072)](buf34, primals_27,
            buf29, 131072, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_27
        buf35 = extern_kernels.convolution(buf34, primals_28, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf35, (4, 64, 16, 16), (16384, 256, 16, 1))
        buf36 = empty_strided_cuda((4, 64, 16, 16), (16384, 256, 16, 1),
            torch.bool)
        triton_poi_fused_convolution_leaky_relu_6[grid(65536)](buf35,
            primals_29, buf36, 65536, XBLOCK=512, num_warps=4, num_stages=1)
        buf37 = empty_strided_cuda((32, 1), (1, 1), torch.int64)
        triton_poi_fused__to_copy_7[grid(32)](buf37, 32, XBLOCK=32,
            num_warps=1, num_stages=1)
        buf38 = empty_strided_cuda((32, 1), (1, 1), torch.int64)
        triton_poi_fused_add_clamp_8[grid(32)](buf38, 32, XBLOCK=32,
            num_warps=1, num_stages=1)
        buf39 = empty_strided_cuda((32,), (1,), torch.int64)
        triton_poi_fused__to_copy_7[grid(32)](buf39, 32, XBLOCK=32,
            num_warps=1, num_stages=1)
        buf40 = empty_strided_cuda((32,), (1,), torch.int64)
        triton_poi_fused_add_clamp_8[grid(32)](buf40, 32, XBLOCK=32,
            num_warps=1, num_stages=1)
        buf43 = empty_strided_cuda((32,), (1,), torch.float32)
        triton_poi_fused__to_copy_add_arange_clamp_mul_sub_9[grid(32)](buf43,
            32, XBLOCK=32, num_warps=1, num_stages=1)
        buf45 = empty_strided_cuda((32, 1), (1, 1), torch.float32)
        triton_poi_fused__to_copy_add_arange_clamp_mul_sub_9[grid(32)](buf45,
            32, XBLOCK=32, num_warps=1, num_stages=1)
        buf42 = buf6
        del buf6
        buf46 = buf42
        del buf42
        buf47 = buf46
        del buf46
        triton_poi_fused__unsafe_index_add_convolution_leaky_relu_mul_sub_10[
            grid(262144)](buf47, buf38, buf39, buf36, buf35, primals_29,
            buf37, buf40, buf43, buf45, buf8, 262144, XBLOCK=512, num_warps
            =8, num_stages=1)
        del buf35
        del primals_29
        buf48 = extern_kernels.convolution(buf47, primals_30, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf48, (4, 64, 32, 32), (65536, 1024, 32, 1))
        buf49 = empty_strided_cuda((4, 64, 32, 32), (65536, 1024, 32, 1),
            torch.bool)
        buf50 = empty_strided_cuda((4, 64, 32, 32), (65536, 1024, 32, 1),
            torch.float32)
        triton_poi_fused_convolution_leaky_relu_2[grid(262144)](buf48,
            primals_31, buf49, buf50, 262144, XBLOCK=1024, num_warps=4,
            num_stages=1)
        del buf48
        del primals_31
        buf51 = extern_kernels.convolution(buf50, primals_32, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf51, (4, 32, 32, 32), (32768, 1024, 32, 1))
        buf52 = empty_strided_cuda((4, 32, 32, 32), (32768, 1024, 32, 1),
            torch.bool)
        triton_poi_fused_convolution_leaky_relu_11[grid(131072)](buf51,
            primals_33, buf52, 131072, XBLOCK=1024, num_warps=4, num_stages=1)
        buf53 = empty_strided_cuda((64, 1), (1, 1), torch.int64)
        triton_poi_fused__to_copy_12[grid(64)](buf53, 64, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf54 = empty_strided_cuda((64, 1), (1, 1), torch.int64)
        triton_poi_fused_add_clamp_13[grid(64)](buf54, 64, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf55 = empty_strided_cuda((64,), (1,), torch.int64)
        triton_poi_fused__to_copy_12[grid(64)](buf55, 64, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf56 = empty_strided_cuda((64,), (1,), torch.int64)
        triton_poi_fused_add_clamp_13[grid(64)](buf56, 64, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf59 = empty_strided_cuda((64,), (1,), torch.float32)
        triton_poi_fused__to_copy_add_arange_clamp_mul_sub_14[grid(64)](buf59,
            64, XBLOCK=64, num_warps=1, num_stages=1)
        buf61 = empty_strided_cuda((64, 1), (1, 1), torch.float32)
        triton_poi_fused__to_copy_add_arange_clamp_mul_sub_14[grid(64)](buf61,
            64, XBLOCK=64, num_warps=1, num_stages=1)
        buf58 = buf0
        del buf0
        buf62 = buf58
        del buf58
        buf63 = buf62
        del buf62
        triton_poi_fused__unsafe_index_add_convolution_leaky_relu_mul_sub_15[
            grid(524288)](buf63, buf54, buf55, buf52, buf51, primals_33,
            buf53, buf56, buf59, buf61, buf2, 524288, XBLOCK=512, num_warps
            =8, num_stages=1)
        del buf51
        del primals_33
        buf64 = extern_kernels.convolution(buf63, primals_34, stride=(1, 1),
            padding=(1, 1), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf64, (4, 32, 64, 64), (131072, 4096, 64, 1))
        buf65 = empty_strided_cuda((4, 32, 64, 64), (131072, 4096, 64, 1),
            torch.bool)
        buf66 = empty_strided_cuda((4, 32, 64, 64), (131072, 4096, 64, 1),
            torch.float32)
        triton_poi_fused_convolution_leaky_relu_0[grid(524288)](buf64,
            primals_35, buf65, buf66, 524288, XBLOCK=512, num_warps=8,
            num_stages=1)
        del buf64
        del primals_35
        buf67 = extern_kernels.convolution(buf66, primals_36, stride=(1, 1),
            padding=(3, 3), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf67, (4, 3, 64, 64), (12288, 4096, 64, 1))
        buf68 = buf67
        del buf67
        triton_poi_fused_convolution_16[grid(49152)](buf68, primals_37, 
            49152, XBLOCK=256, num_warps=4, num_stages=1)
        del primals_37
    return (buf68, 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, buf1, buf2, buf4,
        buf5, buf7, buf8, buf10, buf11, buf13, buf14, buf16, buf17, buf19,
        buf21, buf22, buf24, buf26, buf27, buf29, buf31, buf32, buf34,
        buf36, buf37, buf38, buf39, buf40, buf43, buf45, buf47, buf49,
        buf50, buf52, buf53, buf54, buf55, buf56, buf59, buf61, buf63,
        buf65, buf66)


def tf_2xupsample_bilinear(x):
    b, c, h, w = x.shape
    out = torch.zeros(b, c, h * 2, w * 2)
    out[:, :, ::2, ::2] = x
    padded = F.pad(x, (0, 1, 0, 1), mode='replicate')
    out[:, :, 1::2, ::2] = (padded[:, :, :-1, :-1] + padded[:, :, 1:, :-1]) / 2
    out[:, :, ::2, 1::2] = (padded[:, :, :-1, :-1] + padded[:, :, :-1, 1:]) / 2
    out[:, :, 1::2, 1::2] = (padded[:, :, :-1, :-1] + padded[:, :, 1:, 1:]) / 2
    return out


def tf_same_padding(x, k_size=3):
    j = k_size // 2
    return F.pad(x, (j - 1, j, j - 1, j))


class Upsample(nn.Module):
    """Upsamples a given multi-channel 1D (temporal), 2D (spatial) or 3D (volumetric) data.

    The input data is assumed to be of the form
    `minibatch x channels x [optional depth] x [optional height] x width`.

    Args:
        size (int or Tuple[int] or Tuple[int, int] or Tuple[int, int, int], optional):
            output spatial sizes
        scale_factor (float or Tuple[float] or Tuple[float, float] or Tuple[float, float, float], optional):
            multiplier for spatial size. Has to match input size if it is a tuple.
        mode (str, optional): the upsampling algorithm: one of ``'nearest'``,
            ``'linear'``, ``'bilinear'``, ``'bicubic'`` and ``'trilinear'``.
            Default: ``'nearest'``
        align_corners (bool, optional): if ``True``, the corner pixels of the input
            and output tensors are aligned, and thus preserving the values at
            those pixels. This only has effect when :attr:`mode` is
            ``'linear'``, ``'bilinear'``, or ``'trilinear'``. Default: ``False``
    """

    def __init__(self, size=None, scale_factor=None, mode='nearest',
        align_corners=None):
        super(Upsample, self).__init__()
        if isinstance(scale_factor, tuple):
            self.scale_factor = tuple(float(factor) for factor in scale_factor)
        else:
            self.scale_factor = float(scale_factor) if scale_factor else None
        self.mode = mode
        self.size = size
        self.align_corners = align_corners

    def forward(self, x):
        return nn.functional.interpolate(x, size=self.size, scale_factor=
            self.scale_factor, mode=self.mode, align_corners=self.align_corners
            )

    def extra_repr(self):
        if self.scale_factor is not None:
            info = 'scale_factor=' + str(self.scale_factor)
        else:
            info = 'size=' + str(self.size)
        info += ', mode=' + self.mode
        return info


class ResBlock(nn.Module):

    def __init__(self, in_nf, out_nf=32, slope=0.2):
        super().__init__()
        self.conv1 = nn.Conv2d(in_nf, out_nf, 3, 1, padding=1)
        self.conv2 = nn.Conv2d(out_nf, out_nf, 3, 1, padding=1)
        self.leaky_relu = nn.LeakyReLU(negative_slope=0.2, inplace=False)

    def forward(self, inputs):
        x = self.conv2(self.leaky_relu(self.conv1(inputs)))
        return x + inputs


class Upsample_2xBil_TF(nn.Module):

    def __init__(self):
        super(Upsample_2xBil_TF, self).__init__()

    def forward(self, x):
        return tf_2xupsample_bilinear(x)


class UnetGeneratorWBCNew(nn.Module):
    """ UNet Generator as used in Learning to Cartoonize Using White-box
    Cartoon Representations for image to image translation
    https://systemerrorwang.github.io/White-box-Cartoonization/paper/06791.pdf
    https://systemerrorwang.github.io/White-box-Cartoonization/paper/06791-supp.pdf
    """

    def __init__(self, nf=32, mode='pt', slope=0.2):
        super(UnetGeneratorWBCNew, self).__init__()
        self.mode = mode
        self.conv = nn.Conv2d(3, nf, 7, 1, padding=3)
        if mode == 'tf':
            self.conv_1 = nn.Conv2d(nf, nf, 3, stride=2, padding=0)
        else:
            self.conv_1 = nn.Conv2d(nf, nf, 3, stride=2, padding=1)
        self.conv_2 = nn.Conv2d(nf, nf * 2, 3, 1, padding=1)
        if mode == 'tf':
            self.conv_3 = nn.Conv2d(nf * 2, nf * 2, 3, stride=2, padding=0)
        else:
            self.conv_3 = nn.Conv2d(nf * 2, nf * 2, 3, stride=2, padding=1)
        self.conv_4 = nn.Conv2d(nf * 2, nf * 4, 3, 1, padding=1)
        self.block_0 = ResBlock(nf * 4, nf * 4, slope=slope)
        self.block_1 = ResBlock(nf * 4, nf * 4, slope=slope)
        self.block_2 = ResBlock(nf * 4, nf * 4, slope=slope)
        self.block_3 = ResBlock(nf * 4, nf * 4, slope=slope)
        self.conv_5 = nn.Conv2d(nf * 4, nf * 2, 3, 1, padding=1)
        self.conv_6 = nn.Conv2d(nf * 2, nf * 2, 3, 1, padding=1)
        self.conv_7 = nn.Conv2d(nf * 2, nf, 3, 1, padding=1)
        self.conv_8 = nn.Conv2d(nf, nf, 3, 1, padding=1)
        self.conv_9 = nn.Conv2d(nf, 3, 7, 1, padding=3)
        self.leaky_relu = nn.LeakyReLU(negative_slope=slope, inplace=False)
        if mode == 'tf':
            self.upsample = Upsample_2xBil_TF()
        else:
            self.upsample = Upsample(scale_factor=2, mode='bilinear',
                align_corners=False)

    def forward(self, input_0):
        primals_1 = self.conv.weight
        primals_2 = self.conv.bias
        primals_4 = self.conv_1.weight
        primals_5 = self.conv_1.bias
        primals_6 = self.conv_2.weight
        primals_7 = self.conv_2.bias
        primals_8 = self.conv_3.weight
        primals_9 = self.conv_3.bias
        primals_10 = self.conv_4.weight
        primals_11 = self.conv_4.bias
        primals_12 = self.block_0.conv1.weight
        primals_13 = self.block_0.conv1.bias
        primals_14 = self.block_0.conv2.weight
        primals_15 = self.block_0.conv2.bias
        primals_16 = self.block_1.conv1.weight
        primals_17 = self.block_1.conv1.bias
        primals_18 = self.block_1.conv2.weight
        primals_19 = self.block_1.conv2.bias
        primals_20 = self.block_2.conv1.weight
        primals_21 = self.block_2.conv1.bias
        primals_22 = self.block_2.conv2.weight
        primals_23 = self.block_2.conv2.bias
        primals_24 = self.block_3.conv1.weight
        primals_25 = self.block_3.conv1.bias
        primals_26 = self.block_3.conv2.weight
        primals_27 = self.block_3.conv2.bias
        primals_28 = self.conv_5.weight
        primals_29 = self.conv_5.bias
        primals_30 = self.conv_6.weight
        primals_31 = self.conv_6.bias
        primals_32 = self.conv_7.weight
        primals_33 = self.conv_7.bias
        primals_34 = self.conv_8.weight
        primals_35 = self.conv_8.bias
        primals_36 = self.conv_9.weight
        primals_37 = self.conv_9.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])
        return output[0]


Measured latency_ms: 0.015131