import torch
from torch._inductor.select_algorithm import extern_kernels
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid
from torch._C import _cuda_getCurrentRawStream as get_raw_stream
from torch._inductor.runtime import triton_helpers
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
import torch.nn.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_reflection_pad2d_0(in_ptr0, out_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xnumel = 277248
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex % 152
    x1 = xindex // 152 % 152
    x2 = xindex // 23104
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (4095 + -1 * tl_math.abs(-63 + tl_math.abs(-
        103 + tl_math.abs(-143 + tl_math.abs(-4 + x0)))) + -64 * tl_math.
        abs(-63 + tl_math.abs(-103 + tl_math.abs(-143 + tl_math.abs(-4 + x1
        )))) + 4096 * x2), xmask)
    tl.store(out_ptr0 + x3, tmp0, xmask)


@triton.jit
def triton_red_fused__native_batch_norm_legit_convolution_1(in_out_ptr0,
    in_ptr0, out_ptr0, out_ptr1, out_ptr2, xnumel, rnumel, XBLOCK: tl.
    constexpr, RBLOCK: tl.constexpr):
    xnumel = 384
    rnumel = 6912
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x4 = xindex
    x1 = xindex // 3 % 32
    tmp1 = tl.load(in_ptr0 + x1, xmask, eviction_policy='evict_last')
    tmp4_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp4_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp4_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r3 = rindex
        tmp0 = tl.load(in_out_ptr0 + (r3 + 6912 * x4), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp2 = tmp0 + tmp1
        tmp3 = tl.broadcast_to(tmp2, [XBLOCK, RBLOCK])
        tmp4_mean_next, tmp4_m2_next, tmp4_weight_next = (triton_helpers.
            welford_reduce(tmp3, tmp4_mean, tmp4_m2, tmp4_weight, roffset == 0)
            )
        tmp4_mean = tl.where(rmask & xmask, tmp4_mean_next, tmp4_mean)
        tmp4_m2 = tl.where(rmask & xmask, tmp4_m2_next, tmp4_m2)
        tmp4_weight = tl.where(rmask & xmask, tmp4_weight_next, tmp4_weight)
        tl.store(in_out_ptr0 + (r3 + 6912 * x4), tmp2, rmask & xmask)
    tmp4_tmp, tmp5_tmp, tmp6_tmp = triton_helpers.welford(tmp4_mean,
        tmp4_m2, tmp4_weight, 1)
    tmp4 = tmp4_tmp[:, None]
    tmp5 = tmp5_tmp[:, None]
    tmp6 = tmp6_tmp[:, None]
    tl.store(out_ptr0 + x4, tmp4, xmask)
    tl.store(out_ptr1 + x4, tmp5, xmask)
    tl.store(out_ptr2 + x4, tmp6, xmask)


@triton.jit
def triton_poi_fused_repeat_2(in_ptr0, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 128
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0 % 32, xmask)
    tl.store(out_ptr0 + x0, tmp0, xmask)


@triton.jit
def triton_per_fused__native_batch_norm_legit_3(in_out_ptr0, in_ptr0,
    in_ptr1, in_ptr2, out_ptr0, xnumel, rnumel, XBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 3
    RBLOCK: tl.constexpr = 4
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rindex = tl.arange(0, RBLOCK)[None, :]
    rmask = rindex < rnumel
    r1 = rindex
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (r1 + 3 * x0), rmask & xmask, other=0.0)
    tmp1 = tl.load(in_ptr1 + (r1 + 3 * x0), rmask & xmask, other=0.0)
    tmp2 = tl.load(in_ptr2 + (r1 + 3 * x0), rmask & xmask, other=0.0)
    tmp3 = tl.broadcast_to(tmp0, [XBLOCK, RBLOCK])
    tmp4 = tl.broadcast_to(tmp1, [XBLOCK, RBLOCK])
    tmp5 = tl.broadcast_to(tmp2, [XBLOCK, RBLOCK])
    tmp7 = tl.where(rmask & xmask, tmp3, 0)
    tmp8 = tl.where(rmask & xmask, tmp4, 0)
    tmp9 = tl.where(rmask & xmask, tmp5, 0)
    tmp10, tmp11, tmp12 = triton_helpers.welford(tmp7, tmp8, tmp9, 1)
    tmp13 = tmp10[:, None]
    tmp14 = tmp11[:, None]
    tmp12[:, None]
    tmp16 = 20736.0
    tmp17 = tmp14 / tmp16
    tmp18 = 1e-05
    tmp19 = tmp17 + tmp18
    tmp20 = libdevice.rsqrt(tmp19)
    tl.debug_barrier()
    tl.store(in_out_ptr0 + x0, tmp20, xmask)
    tl.store(out_ptr0 + x0, tmp13, xmask)


@triton.jit
def triton_poi_fused_reflection_pad2d_relu_4(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 2728448
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex % 146
    x1 = xindex // 146 % 146
    x2 = xindex // 21316
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (20735 + -1 * tl_math.abs(-143 + tl_math.abs(-
        1 + x0)) + -144 * tl_math.abs(-143 + tl_math.abs(-1 + x1)) + 20736 *
        x2), xmask, eviction_policy='evict_last')
    tmp1 = tl.load(in_ptr1 + x2, xmask, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + x2, xmask, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr3 + x2, xmask, eviction_policy='evict_last')
    tmp7 = tl.load(in_ptr4 + x2, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = tmp2 * tmp3
    tmp6 = tmp4 * tmp5
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 0, tl.int32)
    tmp10 = triton_helpers.maximum(tmp9, tmp8)
    tl.store(out_ptr0 + x3, tmp10, xmask)


@triton.jit
def triton_red_fused__native_batch_norm_legit_convolution_5(in_out_ptr0,
    in_out_ptr1, in_ptr0, out_ptr0, xnumel, rnumel, XBLOCK: tl.constexpr,
    RBLOCK: tl.constexpr):
    xnumel = 256
    rnumel = 5184
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x3 = xindex
    x0 = xindex % 64
    tmp1 = tl.load(in_ptr0 + x0, xmask, eviction_policy='evict_last')
    tmp4_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp4_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp4_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex
        tmp0 = tl.load(in_out_ptr0 + (r2 + 5184 * x3), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp2 = tmp0 + tmp1
        tmp3 = tl.broadcast_to(tmp2, [XBLOCK, RBLOCK])
        tmp4_mean_next, tmp4_m2_next, tmp4_weight_next = (triton_helpers.
            welford_reduce(tmp3, tmp4_mean, tmp4_m2, tmp4_weight, roffset == 0)
            )
        tmp4_mean = tl.where(rmask & xmask, tmp4_mean_next, tmp4_mean)
        tmp4_m2 = tl.where(rmask & xmask, tmp4_m2_next, tmp4_m2)
        tmp4_weight = tl.where(rmask & xmask, tmp4_weight_next, tmp4_weight)
        tl.store(in_out_ptr0 + (r2 + 5184 * x3), tmp2, rmask & xmask)
    tmp4_tmp, tmp5_tmp, tmp6_tmp = triton_helpers.welford(tmp4_mean,
        tmp4_m2, tmp4_weight, 1)
    tmp4 = tmp4_tmp[:, None]
    tmp5 = tmp5_tmp[:, None]
    tmp6_tmp[:, None]
    tl.store(out_ptr0 + x3, tmp4, xmask)
    tmp7 = 5184.0
    tmp8 = tmp5 / tmp7
    tmp9 = 1e-05
    tmp10 = tmp8 + tmp9
    tmp11 = libdevice.rsqrt(tmp10)
    tl.debug_barrier()
    tl.store(in_out_ptr1 + x3, tmp11, xmask)


@triton.jit
def triton_poi_fused_repeat_6(in_ptr0, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0 % 64, xmask)
    tl.store(out_ptr0 + x0, tmp0, xmask)


@triton.jit
def triton_poi_fused_reflection_pad2d_relu_7(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 1401856
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex % 74
    x1 = xindex // 74 % 74
    x2 = xindex // 5476
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (5183 + -1 * tl_math.abs(-71 + tl_math.abs(-1 +
        x0)) + -72 * tl_math.abs(-71 + tl_math.abs(-1 + x1)) + 5184 * x2),
        xmask, eviction_policy='evict_last')
    tmp1 = tl.load(in_ptr1 + x2, xmask, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr2 + x2, xmask, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr3 + x2, xmask, eviction_policy='evict_last')
    tmp7 = tl.load(in_ptr4 + x2, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 - tmp1
    tmp4 = tmp2 * tmp3
    tmp6 = tmp4 * tmp5
    tmp8 = tmp6 + tmp7
    tmp9 = tl.full([1], 0, tl.int32)
    tmp10 = triton_helpers.maximum(tmp9, tmp8)
    tl.store(out_ptr0 + x3, tmp10, xmask)


@triton.jit
def triton_red_fused__native_batch_norm_legit_convolution_relu_repeat_8(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, out_ptr0, out_ptr1, out_ptr3,
    out_ptr4, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 512
    rnumel = 1296
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0 % 128, xmask, eviction_policy='evict_last')
    tl.store(out_ptr0 + x0, tmp0, xmask)
    x1 = xindex % 128
    tmp2 = tl.load(in_ptr1 + x1, xmask, eviction_policy='evict_last')
    tmp5_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp5_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp5_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r3 = rindex
        tmp1 = tl.load(in_out_ptr0 + (r3 + 1296 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp3 = tmp1 + tmp2
        tmp4 = tl.broadcast_to(tmp3, [XBLOCK, RBLOCK])
        tmp5_mean_next, tmp5_m2_next, tmp5_weight_next = (triton_helpers.
            welford_reduce(tmp4, tmp5_mean, tmp5_m2, tmp5_weight, roffset == 0)
            )
        tmp5_mean = tl.where(rmask & xmask, tmp5_mean_next, tmp5_mean)
        tmp5_m2 = tl.where(rmask & xmask, tmp5_m2_next, tmp5_m2)
        tmp5_weight = tl.where(rmask & xmask, tmp5_weight_next, tmp5_weight)
        tl.store(in_out_ptr0 + (r3 + 1296 * x0), tmp3, rmask & xmask)
    tmp5_tmp, tmp6_tmp, tmp7_tmp = triton_helpers.welford(tmp5_mean,
        tmp5_m2, tmp5_weight, 1)
    tmp5 = tmp5_tmp[:, None]
    tmp6 = tmp6_tmp[:, None]
    tmp7_tmp[:, None]
    tl.store(out_ptr1 + x0, tmp5, xmask)
    tmp17 = tl.load(in_ptr2 + x1, xmask, eviction_policy='evict_last')
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r3 = rindex
        tmp8 = tl.load(in_out_ptr0 + (r3 + 1296 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp9 = tmp8 - tmp5
        tmp10 = 1296.0
        tmp11 = tmp6 / tmp10
        tmp12 = 1e-05
        tmp13 = tmp11 + tmp12
        tmp14 = libdevice.rsqrt(tmp13)
        tmp15 = tmp9 * tmp14
        tmp16 = tmp15 * tmp0
        tmp18 = tmp16 + tmp17
        tmp19 = tl.full([1, 1], 0, tl.int32)
        tmp20 = triton_helpers.maximum(tmp19, tmp18)
        tl.store(out_ptr3 + (r3 + 1296 * x0), tmp20, rmask & xmask)
    tmp21 = 1296.0
    tmp22 = tmp6 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tl.store(out_ptr4 + x0, tmp25, xmask)


@triton.jit
def triton_red_fused__native_batch_norm_legit_convolution_relu_repeat_9(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, out_ptr0, out_ptr1, out_ptr3,
    out_ptr4, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    xnumel = 512
    rnumel = 1156
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0 % 128, xmask, eviction_policy='evict_last')
    tl.store(out_ptr0 + x0, tmp0, xmask)
    x1 = xindex % 128
    tmp2 = tl.load(in_ptr1 + x1, xmask, eviction_policy='evict_last')
    tmp5_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp5_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp5_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r3 = rindex
        tmp1 = tl.load(in_out_ptr0 + (r3 + 1156 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp3 = tmp1 + tmp2
        tmp4 = tl.broadcast_to(tmp3, [XBLOCK, RBLOCK])
        tmp5_mean_next, tmp5_m2_next, tmp5_weight_next = (triton_helpers.
            welford_reduce(tmp4, tmp5_mean, tmp5_m2, tmp5_weight, roffset == 0)
            )
        tmp5_mean = tl.where(rmask & xmask, tmp5_mean_next, tmp5_mean)
        tmp5_m2 = tl.where(rmask & xmask, tmp5_m2_next, tmp5_m2)
        tmp5_weight = tl.where(rmask & xmask, tmp5_weight_next, tmp5_weight)
        tl.store(in_out_ptr0 + (r3 + 1156 * x0), tmp3, rmask & xmask)
    tmp5_tmp, tmp6_tmp, tmp7_tmp = triton_helpers.welford(tmp5_mean,
        tmp5_m2, tmp5_weight, 1)
    tmp5 = tmp5_tmp[:, None]
    tmp6 = tmp6_tmp[:, None]
    tmp7_tmp[:, None]
    tl.store(out_ptr1 + x0, tmp5, xmask)
    tmp17 = tl.load(in_ptr2 + x1, xmask, eviction_policy='evict_last')
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r3 = rindex
        tmp8 = tl.load(in_out_ptr0 + (r3 + 1156 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp9 = tmp8 - tmp5
        tmp10 = 1156.0
        tmp11 = tmp6 / tmp10
        tmp12 = 1e-05
        tmp13 = tmp11 + tmp12
        tmp14 = libdevice.rsqrt(tmp13)
        tmp15 = tmp9 * tmp14
        tmp16 = tmp15 * tmp0
        tmp18 = tmp16 + tmp17
        tmp19 = tl.full([1, 1], 0, tl.int32)
        tmp20 = triton_helpers.maximum(tmp19, tmp18)
        tl.store(out_ptr3 + (r3 + 1156 * x0), tmp20, rmask & xmask)
    tmp21 = 1156.0
    tmp22 = tmp6 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tl.store(out_ptr4 + x0, tmp25, xmask)


@triton.jit
def triton_per_fused__native_batch_norm_legit_add_convolution_repeat_10(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, in_ptr3, out_ptr0, out_ptr1,
    out_ptr3, out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    r4 = rindex % 32
    r5 = rindex // 32
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 1024 * x0), None)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp25 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp27 = tl.load(in_ptr3 + (74 + r4 + 36 * r5 + 1296 * x0), None)
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tmp6 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp8 = triton_helpers.promote_to_tensor(tl.sum(tmp6, 0))
    tmp9 = tl.full([1], 1024, tl.int32)
    tmp10 = tmp9.to(tl.float32)
    tmp11 = tmp8 / tmp10
    tmp12 = tmp4 - tmp11
    tmp13 = tmp12 * tmp12
    tmp14 = tl.broadcast_to(tmp13, [RBLOCK])
    tmp16 = triton_helpers.promote_to_tensor(tl.sum(tmp14, 0))
    tmp17 = tmp3 - tmp11
    tmp18 = 1024.0
    tmp19 = tmp16 / tmp18
    tmp20 = 1e-05
    tmp21 = tmp19 + tmp20
    tmp22 = libdevice.rsqrt(tmp21)
    tmp23 = tmp17 * tmp22
    tmp24 = tmp23 * tmp0
    tmp26 = tmp24 + tmp25
    tmp28 = tmp26 + tmp27
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 1024 * x0), tmp3, None)
    tl.store(out_ptr3 + (r3 + 1024 * x0), tmp28, None)
    tl.store(out_ptr4 + x0, tmp22, None)
    tl.store(out_ptr1 + x0, tmp11, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_11(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, out_ptr0, out_ptr1, out_ptr3,
    out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    rnumel = 900
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    rmask = rindex < rnumel
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 900 * x0), rmask, other=0.0)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp28 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tl.where(rmask, tmp4, 0)
    tmp7 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp9 = tl.where(rmask, tmp7, 0)
    tmp10 = triton_helpers.promote_to_tensor(tl.sum(tmp9, 0))
    tmp11 = tl.full([1], 900, tl.int32)
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp10 / tmp12
    tmp14 = tmp4 - tmp13
    tmp15 = tmp14 * tmp14
    tmp16 = tl.broadcast_to(tmp15, [RBLOCK])
    tmp18 = tl.where(rmask, tmp16, 0)
    tmp19 = triton_helpers.promote_to_tensor(tl.sum(tmp18, 0))
    tmp20 = tmp3 - tmp13
    tmp21 = 900.0
    tmp22 = tmp19 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tmp26 = tmp20 * tmp25
    tmp27 = tmp26 * tmp0
    tmp29 = tmp27 + tmp28
    tmp30 = tl.full([1], 0, tl.int32)
    tmp31 = triton_helpers.maximum(tmp30, tmp29)
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 900 * x0), tmp3, rmask)
    tl.store(out_ptr3 + (r3 + 900 * x0), tmp31, rmask)
    tl.store(out_ptr4 + x0, tmp25, None)
    tl.store(out_ptr1 + x0, tmp13, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_add_convolution_repeat_12(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, in_ptr3, out_ptr0, out_ptr1,
    out_ptr3, out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    rnumel = 784
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    rmask = rindex < rnumel
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    r4 = rindex % 28
    r5 = rindex // 28
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 784 * x0), rmask, other=0.0)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp28 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp30 = tl.load(in_ptr3 + (66 + r4 + 32 * r5 + 1024 * x0), rmask, other=0.0
        )
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tl.where(rmask, tmp4, 0)
    tmp7 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp9 = tl.where(rmask, tmp7, 0)
    tmp10 = triton_helpers.promote_to_tensor(tl.sum(tmp9, 0))
    tmp11 = tl.full([1], 784, tl.int32)
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp10 / tmp12
    tmp14 = tmp4 - tmp13
    tmp15 = tmp14 * tmp14
    tmp16 = tl.broadcast_to(tmp15, [RBLOCK])
    tmp18 = tl.where(rmask, tmp16, 0)
    tmp19 = triton_helpers.promote_to_tensor(tl.sum(tmp18, 0))
    tmp20 = tmp3 - tmp13
    tmp21 = 784.0
    tmp22 = tmp19 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tmp26 = tmp20 * tmp25
    tmp27 = tmp26 * tmp0
    tmp29 = tmp27 + tmp28
    tmp31 = tmp29 + tmp30
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 784 * x0), tmp3, rmask)
    tl.store(out_ptr3 + (r3 + 784 * x0), tmp31, rmask)
    tl.store(out_ptr4 + x0, tmp25, None)
    tl.store(out_ptr1 + x0, tmp13, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_13(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, out_ptr0, out_ptr1, out_ptr3,
    out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    rnumel = 676
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    rmask = rindex < rnumel
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 676 * x0), rmask, other=0.0)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp28 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tl.where(rmask, tmp4, 0)
    tmp7 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp9 = tl.where(rmask, tmp7, 0)
    tmp10 = triton_helpers.promote_to_tensor(tl.sum(tmp9, 0))
    tmp11 = tl.full([1], 676, tl.int32)
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp10 / tmp12
    tmp14 = tmp4 - tmp13
    tmp15 = tmp14 * tmp14
    tmp16 = tl.broadcast_to(tmp15, [RBLOCK])
    tmp18 = tl.where(rmask, tmp16, 0)
    tmp19 = triton_helpers.promote_to_tensor(tl.sum(tmp18, 0))
    tmp20 = tmp3 - tmp13
    tmp21 = 676.0
    tmp22 = tmp19 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tmp26 = tmp20 * tmp25
    tmp27 = tmp26 * tmp0
    tmp29 = tmp27 + tmp28
    tmp30 = tl.full([1], 0, tl.int32)
    tmp31 = triton_helpers.maximum(tmp30, tmp29)
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 676 * x0), tmp3, rmask)
    tl.store(out_ptr3 + (r3 + 676 * x0), tmp31, rmask)
    tl.store(out_ptr4 + x0, tmp25, None)
    tl.store(out_ptr1 + x0, tmp13, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_add_convolution_repeat_14(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, in_ptr3, out_ptr0, out_ptr1,
    out_ptr3, out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    rnumel = 576
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    rmask = rindex < rnumel
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    r4 = rindex % 24
    r5 = rindex // 24
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 576 * x0), rmask, other=0.0)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp28 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp30 = tl.load(in_ptr3 + (58 + r4 + 28 * r5 + 784 * x0), rmask, other=0.0)
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tl.where(rmask, tmp4, 0)
    tmp7 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp9 = tl.where(rmask, tmp7, 0)
    tmp10 = triton_helpers.promote_to_tensor(tl.sum(tmp9, 0))
    tmp11 = tl.full([1], 576, tl.int32)
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp10 / tmp12
    tmp14 = tmp4 - tmp13
    tmp15 = tmp14 * tmp14
    tmp16 = tl.broadcast_to(tmp15, [RBLOCK])
    tmp18 = tl.where(rmask, tmp16, 0)
    tmp19 = triton_helpers.promote_to_tensor(tl.sum(tmp18, 0))
    tmp20 = tmp3 - tmp13
    tmp21 = 576.0
    tmp22 = tmp19 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tmp26 = tmp20 * tmp25
    tmp27 = tmp26 * tmp0
    tmp29 = tmp27 + tmp28
    tmp31 = tmp29 + tmp30
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 576 * x0), tmp3, rmask)
    tl.store(out_ptr3 + (r3 + 576 * x0), tmp31, rmask)
    tl.store(out_ptr4 + x0, tmp25, None)
    tl.store(out_ptr1 + x0, tmp13, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_15(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, out_ptr0, out_ptr1, out_ptr3,
    out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    rnumel = 484
    RBLOCK: tl.constexpr = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    rmask = rindex < rnumel
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 484 * x0), rmask, other=0.0)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp28 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tl.where(rmask, tmp4, 0)
    tmp7 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp9 = tl.where(rmask, tmp7, 0)
    tmp10 = triton_helpers.promote_to_tensor(tl.sum(tmp9, 0))
    tmp11 = tl.full([1], 484, tl.int32)
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp10 / tmp12
    tmp14 = tmp4 - tmp13
    tmp15 = tmp14 * tmp14
    tmp16 = tl.broadcast_to(tmp15, [RBLOCK])
    tmp18 = tl.where(rmask, tmp16, 0)
    tmp19 = triton_helpers.promote_to_tensor(tl.sum(tmp18, 0))
    tmp20 = tmp3 - tmp13
    tmp21 = 484.0
    tmp22 = tmp19 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tmp26 = tmp20 * tmp25
    tmp27 = tmp26 * tmp0
    tmp29 = tmp27 + tmp28
    tmp30 = tl.full([1], 0, tl.int32)
    tmp31 = triton_helpers.maximum(tmp30, tmp29)
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 484 * x0), tmp3, rmask)
    tl.store(out_ptr3 + (r3 + 484 * x0), tmp31, rmask)
    tl.store(out_ptr4 + x0, tmp25, None)
    tl.store(out_ptr1 + x0, tmp13, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_add_convolution_repeat_16(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, in_ptr3, out_ptr0, out_ptr1,
    out_ptr3, out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    rnumel = 400
    RBLOCK: tl.constexpr = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    rmask = rindex < rnumel
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    r4 = rindex % 20
    r5 = rindex // 20
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 400 * x0), rmask, other=0.0)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp28 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp30 = tl.load(in_ptr3 + (50 + r4 + 24 * r5 + 576 * x0), rmask, other=0.0)
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tl.where(rmask, tmp4, 0)
    tmp7 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp9 = tl.where(rmask, tmp7, 0)
    tmp10 = triton_helpers.promote_to_tensor(tl.sum(tmp9, 0))
    tmp11 = tl.full([1], 400, tl.int32)
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp10 / tmp12
    tmp14 = tmp4 - tmp13
    tmp15 = tmp14 * tmp14
    tmp16 = tl.broadcast_to(tmp15, [RBLOCK])
    tmp18 = tl.where(rmask, tmp16, 0)
    tmp19 = triton_helpers.promote_to_tensor(tl.sum(tmp18, 0))
    tmp20 = tmp3 - tmp13
    tmp21 = 400.0
    tmp22 = tmp19 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tmp26 = tmp20 * tmp25
    tmp27 = tmp26 * tmp0
    tmp29 = tmp27 + tmp28
    tmp31 = tmp29 + tmp30
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 400 * x0), tmp3, rmask)
    tl.store(out_ptr3 + (r3 + 400 * x0), tmp31, rmask)
    tl.store(out_ptr4 + x0, tmp25, None)
    tl.store(out_ptr1 + x0, tmp13, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_17(
    in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, out_ptr0, out_ptr1, out_ptr3,
    out_ptr4, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    rnumel = 324
    RBLOCK: tl.constexpr = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    rmask = rindex < rnumel
    x0 = xindex
    r3 = rindex
    x1 = xindex % 128
    tmp0 = tl.load(in_ptr0 + x0 % 128, None, eviction_policy='evict_last')
    tmp1 = tl.load(in_out_ptr0 + (r3 + 324 * x0), rmask, other=0.0)
    tmp2 = tl.load(in_ptr1 + x1, None, eviction_policy='evict_last')
    tmp28 = tl.load(in_ptr2 + x1, None, eviction_policy='evict_last')
    tmp3 = tmp1 + tmp2
    tmp4 = tl.broadcast_to(tmp3, [RBLOCK])
    tl.where(rmask, tmp4, 0)
    tmp7 = tl.broadcast_to(tmp4, [RBLOCK])
    tmp9 = tl.where(rmask, tmp7, 0)
    tmp10 = triton_helpers.promote_to_tensor(tl.sum(tmp9, 0))
    tmp11 = tl.full([1], 324, tl.int32)
    tmp12 = tmp11.to(tl.float32)
    tmp13 = tmp10 / tmp12
    tmp14 = tmp4 - tmp13
    tmp15 = tmp14 * tmp14
    tmp16 = tl.broadcast_to(tmp15, [RBLOCK])
    tmp18 = tl.where(rmask, tmp16, 0)
    tmp19 = triton_helpers.promote_to_tensor(tl.sum(tmp18, 0))
    tmp20 = tmp3 - tmp13
    tmp21 = 324.0
    tmp22 = tmp19 / tmp21
    tmp23 = 1e-05
    tmp24 = tmp22 + tmp23
    tmp25 = libdevice.rsqrt(tmp24)
    tmp26 = tmp20 * tmp25
    tmp27 = tmp26 * tmp0
    tmp29 = tmp27 + tmp28
    tmp30 = tl.full([1], 0, tl.int32)
    tmp31 = triton_helpers.maximum(tmp30, tmp29)
    tl.store(out_ptr0 + x0, tmp0, None)
    tl.store(in_out_ptr0 + (r3 + 324 * x0), tmp3, rmask)
    tl.store(out_ptr3 + (r3 + 324 * x0), tmp31, rmask)
    tl.store(out_ptr4 + x0, tmp25, None)
    tl.store(out_ptr1 + x0, tmp13, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_convolution_18(in_out_ptr0,
    in_ptr0, out_ptr0, out_ptr1, out_ptr2, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r2 = rindex
    x3 = xindex
    x0 = xindex % 128
    tmp0 = tl.load(in_out_ptr0 + (r2 + 256 * x3), None)
    tmp1 = tl.load(in_ptr0 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.broadcast_to(tmp2, [RBLOCK])
    tmp5 = tl.broadcast_to(tmp3, [RBLOCK])
    tmp7 = triton_helpers.promote_to_tensor(tl.sum(tmp5, 0))
    tmp8 = tl.full([1], 256, tl.int32)
    tmp9 = tmp8.to(tl.float32)
    tmp10 = tmp7 / tmp9
    tmp11 = tmp3 - tmp10
    tmp12 = tmp11 * tmp11
    tmp13 = tl.broadcast_to(tmp12, [RBLOCK])
    tmp15 = triton_helpers.promote_to_tensor(tl.sum(tmp13, 0))
    tmp16 = 256.0
    tmp17 = tmp15 / tmp16
    tmp18 = 1e-05
    tmp19 = tmp17 + tmp18
    tmp20 = libdevice.rsqrt(tmp19)
    tl.store(in_out_ptr0 + (r2 + 256 * x3), tmp2, None)
    tl.store(out_ptr2 + x3, tmp20, None)
    tl.store(out_ptr0 + x3, tmp10, None)
    tl.store(out_ptr1 + x3, tmp15, None)


@triton.jit
def triton_poi_fused_repeat_19(in_ptr0, out_ptr0, xnumel, XBLOCK: tl.constexpr
    ):
    xnumel = 512
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0 % 128, xmask)
    tl.store(out_ptr0 + x0, tmp0, xmask)


@triton.jit
def triton_poi_fused_arange_20(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
    tl.store(out_ptr0 + x0, tmp0, xmask)


@triton.jit
def triton_poi_fused__to_copy_add_arange_mul_21(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.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp4, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_add_reflection_pad2d_22(in_ptr0, in_ptr1,
    in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, 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 // 34 % 34
    x0 = xindex % 34
    x4 = xindex // 1156
    x2 = xindex // 1156 % 128
    x7 = xindex
    tmp0 = tl.load(in_ptr0 + (31 + -1 * tl_math.abs(-31 + tl_math.abs(-1 +
        x1))), None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr0 + (31 + -1 * tl_math.abs(-31 + tl_math.abs(-1 +
        x0))), None, eviction_policy='evict_last')
    tmp10 = tl.load(in_ptr2 + x4, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr3 + x4, None, eviction_policy='evict_last')
    tmp19 = tl.load(in_ptr4 + x4, None, eviction_policy='evict_last')
    tmp21 = tl.load(in_ptr5 + x2, None, eviction_policy='evict_last')
    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_ptr1 + (tmp8 + 16 * tmp4 + 256 * x4), None,
        eviction_policy='evict_last')
    tmp11 = tmp9 - tmp10
    tmp13 = 256.0
    tmp14 = tmp12 / tmp13
    tmp15 = 1e-05
    tmp16 = tmp14 + tmp15
    tmp17 = libdevice.rsqrt(tmp16)
    tmp18 = tmp11 * tmp17
    tmp20 = tmp18 * tmp19
    tmp22 = tmp20 + tmp21
    tmp23 = tl.load(in_ptr6 + (42 + tmp8 + 20 * tmp4 + 400 * x4), None,
        eviction_policy='evict_last')
    tmp24 = tmp22 + tmp23
    tl.store(out_ptr0 + x7, tmp24, None)


@triton.jit
def triton_per_fused__native_batch_norm_legit_convolution_23(in_out_ptr0,
    in_out_ptr1, in_ptr0, out_ptr0, xnumel, rnumel):
    XBLOCK: tl.constexpr = 1
    RBLOCK: tl.constexpr = 1024
    xoffset = tl.program_id(0) * XBLOCK
    xindex = tl.full([1], xoffset, tl.int32)
    tl.full([RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[:]
    tl.full([RBLOCK], True, tl.int1)
    r2 = rindex
    x3 = xindex
    x0 = xindex % 64
    tmp0 = tl.load(in_out_ptr0 + (r2 + 1024 * x3), None)
    tmp1 = tl.load(in_ptr0 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = tl.broadcast_to(tmp2, [RBLOCK])
    tmp5 = tl.broadcast_to(tmp3, [RBLOCK])
    tmp7 = triton_helpers.promote_to_tensor(tl.sum(tmp5, 0))
    tmp8 = tl.full([1], 1024, tl.int32)
    tmp9 = tmp8.to(tl.float32)
    tmp10 = tmp7 / tmp9
    tmp11 = tmp3 - tmp10
    tmp12 = tmp11 * tmp11
    tmp13 = tl.broadcast_to(tmp12, [RBLOCK])
    tmp15 = triton_helpers.promote_to_tensor(tl.sum(tmp13, 0))
    tmp16 = 1024.0
    tmp17 = tmp15 / tmp16
    tmp18 = 1e-05
    tmp19 = tmp17 + tmp18
    tmp20 = libdevice.rsqrt(tmp19)
    tl.store(in_out_ptr0 + (r2 + 1024 * x3), tmp2, None)
    tl.debug_barrier()
    tl.store(in_out_ptr1 + x3, tmp20, None)
    tl.store(out_ptr0 + x3, tmp10, None)


@triton.jit
def triton_poi_fused_arange_24(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
    tl.store(out_ptr0 + x0, tmp0, xmask)


@triton.jit
def triton_poi_fused__to_copy_add_arange_mul_25(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.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp4, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_reflection_pad2d_relu_26(in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, out_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xnumel = 1115136
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x1 = xindex // 66 % 66
    x0 = xindex % 66
    x2 = xindex // 4356
    x5 = xindex
    tmp0 = tl.load(in_ptr0 + (63 + -1 * tl_math.abs(-63 + tl_math.abs(-1 +
        x1))), xmask, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr0 + (63 + -1 * tl_math.abs(-63 + tl_math.abs(-1 +
        x0))), xmask, eviction_policy='evict_last')
    tmp10 = tl.load(in_ptr2 + x2, xmask, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr3 + x2, xmask, eviction_policy='evict_last')
    tmp14 = tl.load(in_ptr4 + x2, xmask, eviction_policy='evict_last')
    tmp16 = tl.load(in_ptr5 + x2, xmask, eviction_policy='evict_last')
    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_ptr1 + (tmp8 + 32 * tmp4 + 1024 * x2), xmask,
        eviction_policy='evict_last')
    tmp11 = tmp9 - tmp10
    tmp13 = tmp11 * tmp12
    tmp15 = tmp13 * tmp14
    tmp17 = tmp15 + tmp16
    tmp18 = tl.full([1], 0, tl.int32)
    tmp19 = triton_helpers.maximum(tmp18, tmp17)
    tl.store(out_ptr0 + x5, tmp19, xmask)


@triton.jit
def triton_red_fused__native_batch_norm_legit_convolution_27(in_out_ptr0,
    in_out_ptr1, in_ptr0, out_ptr0, xnumel, rnumel, XBLOCK: tl.constexpr,
    RBLOCK: tl.constexpr):
    xnumel = 128
    rnumel = 4096
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x3 = xindex
    x0 = xindex % 32
    tmp1 = tl.load(in_ptr0 + x0, xmask, eviction_policy='evict_last')
    tmp4_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp4_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp4_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex
        tmp0 = tl.load(in_out_ptr0 + (r2 + 4096 * x3), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp2 = tmp0 + tmp1
        tmp3 = tl.broadcast_to(tmp2, [XBLOCK, RBLOCK])
        tmp4_mean_next, tmp4_m2_next, tmp4_weight_next = (triton_helpers.
            welford_reduce(tmp3, tmp4_mean, tmp4_m2, tmp4_weight, roffset == 0)
            )
        tmp4_mean = tl.where(rmask & xmask, tmp4_mean_next, tmp4_mean)
        tmp4_m2 = tl.where(rmask & xmask, tmp4_m2_next, tmp4_m2)
        tmp4_weight = tl.where(rmask & xmask, tmp4_weight_next, tmp4_weight)
        tl.store(in_out_ptr0 + (r2 + 4096 * x3), tmp2, rmask & xmask)
    tmp4_tmp, tmp5_tmp, tmp6_tmp = triton_helpers.welford(tmp4_mean,
        tmp4_m2, tmp4_weight, 1)
    tmp4 = tmp4_tmp[:, None]
    tmp5 = tmp5_tmp[:, None]
    tmp6_tmp[:, None]
    tl.store(out_ptr0 + x3, tmp4, xmask)
    tmp7 = 4096.0
    tmp8 = tmp5 / tmp7
    tmp9 = 1e-05
    tmp10 = tmp8 + tmp9
    tmp11 = libdevice.rsqrt(tmp10)
    tl.debug_barrier()
    tl.store(in_out_ptr1 + x3, tmp11, xmask)


@triton.jit
def triton_poi_fused__to_copy_add_arange_mul_28(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 = 1.0
    tmp3 = tmp1 * tmp2
    tmp4 = tmp3.to(tl.int32)
    tl.store(out_ptr0 + x0, tmp4, xmask)


@triton.jit
def triton_poi_fused__unsafe_index_reflection_pad2d_relu_29(in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, out_ptr0, xnumel, XBLOCK:
    tl.constexpr):
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    tl.full([XBLOCK], True, tl.int1)
    x1 = xindex // 72 % 72
    x0 = xindex % 72
    x2 = xindex // 5184
    x5 = xindex
    tmp0 = tl.load(in_ptr0 + (63 + -1 * tl_math.abs(-63 + tl_math.abs(-4 +
        x1))), None, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr0 + (63 + -1 * tl_math.abs(-63 + tl_math.abs(-4 +
        x0))), None, eviction_policy='evict_last')
    tmp10 = tl.load(in_ptr2 + x2, None, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr3 + x2, None, eviction_policy='evict_last')
    tmp14 = tl.load(in_ptr4 + x2, None, eviction_policy='evict_last')
    tmp16 = tl.load(in_ptr5 + x2, None, eviction_policy='evict_last')
    tmp1 = tl.full([XBLOCK], 64, 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_ptr1 + (tmp8 + 64 * tmp4 + 4096 * x2), None,
        eviction_policy='evict_last')
    tmp11 = tmp9 - tmp10
    tmp13 = tmp11 * tmp12
    tmp15 = tmp13 * tmp14
    tmp17 = tmp15 + tmp16
    tmp18 = tl.full([1], 0, tl.int32)
    tmp19 = triton_helpers.maximum(tmp18, tmp17)
    tl.store(out_ptr0 + x5, tmp19, None)


@triton.jit
def triton_red_fused__native_batch_norm_legit_add_convolution_div_mul_repeat_tanh_30(
    in_out_ptr0, in_out_ptr1, in_ptr0, in_ptr1, in_ptr2, out_ptr0, out_ptr1,
    out_ptr2, out_ptr3, xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.
    constexpr):
    xnumel = 12
    rnumel = 4096
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + x0 % 3, xmask, eviction_policy='evict_last')
    tmp1 = tl.load(in_ptr1 + x0 % 3, xmask, eviction_policy='evict_last')
    tl.store(out_ptr0 + x0, tmp0, xmask)
    tl.store(out_ptr1 + x0, tmp1, xmask)
    x1 = xindex % 3
    tmp3 = tl.load(in_ptr2 + x1, xmask, eviction_policy='evict_last')
    tmp6_mean = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp6_m2 = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    tmp6_weight = tl.zeros([XBLOCK, RBLOCK], tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r3 = rindex
        tmp2 = tl.load(in_out_ptr0 + (r3 + 4096 * x0), rmask & xmask,
            eviction_policy='evict_last', other=0.0)
        tmp4 = tmp2 + tmp3
        tmp5 = tl.broadcast_to(tmp4, [XBLOCK, RBLOCK])
        tmp6_mean_next, tmp6_m2_next, tmp6_weight_next = (triton_helpers.
            welford_reduce(tmp5, tmp6_mean, tmp6_m2, tmp6_weight, roffset == 0)
            )
        tmp6_mean = tl.where(rmask & xmask, tmp6_mean_next, tmp6_mean)
        tmp6_m2 = tl.where(rmask & xmask, tmp6_m2_next, tmp6_m2)
        tmp6_weight = tl.where(rmask & xmask, tmp6_weight_next, tmp6_weight)
        tl.store(in_out_ptr0 + (r3 + 4096 * x0), tmp4, rmask & xmask)
    tmp6_tmp, tmp7_tmp, tmp8_tmp = triton_helpers.welford(tmp6_mean,
        tmp6_m2, tmp6_weight, 1)
    tmp6 = tmp6_tmp[:, None]
    tmp7 = tmp7_tmp[:, None]
    tmp8_tmp[:, None]
    tl.store(out_ptr2 + x0, tmp6, xmask)
    tmp9 = 4096.0
    tmp10 = tmp7 / tmp9
    tmp11 = 1e-05
    tmp12 = tmp10 + tmp11
    tmp13 = libdevice.rsqrt(tmp12)
    tl.debug_barrier()
    tl.store(in_out_ptr1 + x0, tmp13, xmask)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r3 = rindex
        tmp14 = tl.load(in_out_ptr0 + (r3 + 4096 * x0), rmask & xmask,
            eviction_policy='evict_first', other=0.0)
        tmp15 = tmp14 - tmp6
        tmp16 = tmp15 * tmp13
        tmp17 = tmp16 * tmp0
        tmp18 = tmp17 + tmp1
        tmp19 = libdevice.tanh(tmp18)
        tmp20 = 1.0
        tmp21 = tmp19 + tmp20
        tmp22 = 0.5
        tmp23 = tmp21 * tmp22
        tmp24 = 255.0
        tmp25 = tmp23 * tmp24
        tl.store(out_ptr3 + (r3 + 4096 * x0), tmp25, rmask & xmask)


def call(args):
    (primals_1, primals_2, primals_3, primals_4, primals_5, primals_6,
        primals_7, primals_8, primals_9, primals_10, primals_11, primals_12,
        primals_13, primals_14, primals_15, primals_16, primals_17,
        primals_18, primals_19, primals_20, primals_21, primals_22,
        primals_23, primals_24, primals_25, primals_26, primals_27,
        primals_28, primals_29, primals_30, primals_31, primals_32,
        primals_33, primals_34, primals_35, primals_36, primals_37,
        primals_38, primals_39, primals_40, primals_41, primals_42,
        primals_43, primals_44, primals_45, primals_46, primals_47,
        primals_48, primals_49, primals_50, primals_51, primals_52,
        primals_53, primals_54, primals_55, primals_56, primals_57,
        primals_58, primals_59, primals_60, primals_61, primals_62,
        primals_63, primals_64, primals_65) = args
    args.clear()
    assert_size_stride(primals_1, (4, 3, 64, 64), (12288, 4096, 64, 1))
    assert_size_stride(primals_2, (32, 3, 9, 9), (243, 81, 9, 1))
    assert_size_stride(primals_3, (32,), (1,))
    assert_size_stride(primals_4, (32,), (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,), (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,), (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,), (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,), (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,), (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, (128,), (1,))
    assert_size_stride(primals_29, (128,), (1,))
    assert_size_stride(primals_30, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_31, (128,), (1,))
    assert_size_stride(primals_32, (128,), (1,))
    assert_size_stride(primals_33, (128,), (1,))
    assert_size_stride(primals_34, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_35, (128,), (1,))
    assert_size_stride(primals_36, (128,), (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, (128,), (1,))
    assert_size_stride(primals_41, (128,), (1,))
    assert_size_stride(primals_42, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_43, (128,), (1,))
    assert_size_stride(primals_44, (128,), (1,))
    assert_size_stride(primals_45, (128,), (1,))
    assert_size_stride(primals_46, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_47, (128,), (1,))
    assert_size_stride(primals_48, (128,), (1,))
    assert_size_stride(primals_49, (128,), (1,))
    assert_size_stride(primals_50, (128, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_51, (128,), (1,))
    assert_size_stride(primals_52, (128,), (1,))
    assert_size_stride(primals_53, (128,), (1,))
    assert_size_stride(primals_54, (64, 128, 3, 3), (1152, 9, 3, 1))
    assert_size_stride(primals_55, (64,), (1,))
    assert_size_stride(primals_56, (64,), (1,))
    assert_size_stride(primals_57, (64,), (1,))
    assert_size_stride(primals_58, (32, 64, 3, 3), (576, 9, 3, 1))
    assert_size_stride(primals_59, (32,), (1,))
    assert_size_stride(primals_60, (32,), (1,))
    assert_size_stride(primals_61, (32,), (1,))
    assert_size_stride(primals_62, (3, 32, 9, 9), (2592, 81, 9, 1))
    assert_size_stride(primals_63, (3,), (1,))
    assert_size_stride(primals_64, (3,), (1,))
    assert_size_stride(primals_65, (3,), (1,))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4, 3, 152, 152), (69312, 23104, 152, 1),
            torch.float32)
        get_raw_stream(0)
        triton_poi_fused_reflection_pad2d_0[grid(277248)](primals_1, buf0, 
            277248, XBLOCK=512, num_warps=8, num_stages=1)
        del primals_1
        buf1 = extern_kernels.convolution(buf0, primals_2, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf1, (4, 32, 144, 144), (663552, 20736, 144, 1))
        buf2 = buf1
        del buf1
        buf5 = empty_strided_cuda((1, 128, 1, 1, 3), (384, 3, 384, 384, 1),
            torch.float32)
        buf6 = empty_strided_cuda((1, 128, 1, 1, 3), (384, 3, 384, 384, 1),
            torch.float32)
        buf7 = empty_strided_cuda((1, 128, 1, 1, 3), (384, 3, 384, 384, 1),
            torch.float32)
        triton_red_fused__native_batch_norm_legit_convolution_1[grid(384)](buf2
            , primals_3, buf5, buf6, buf7, 384, 6912, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        del primals_3
        buf3 = empty_strided_cuda((128,), (1,), torch.float32)
        triton_poi_fused_repeat_2[grid(128)](primals_4, buf3, 128, XBLOCK=
            128, num_warps=4, num_stages=1)
        del primals_4
        buf4 = empty_strided_cuda((128,), (1,), torch.float32)
        triton_poi_fused_repeat_2[grid(128)](primals_5, buf4, 128, XBLOCK=
            128, num_warps=4, num_stages=1)
        del primals_5
        buf8 = empty_strided_cuda((1, 128, 1, 1), (128, 1, 1, 1), torch.float32
            )
        buf9 = empty_strided_cuda((1, 128, 1, 1), (128, 1, 128, 128), torch
            .float32)
        buf11 = reinterpret_tensor(buf9, (1, 128, 1, 1), (128, 1, 1, 1), 0)
        del buf9
        triton_per_fused__native_batch_norm_legit_3[grid(128)](buf11, buf5,
            buf6, buf7, buf8, 128, 3, XBLOCK=8, num_warps=2, num_stages=1)
        del buf5
        del buf6
        del buf7
        buf12 = empty_strided_cuda((4, 32, 146, 146), (682112, 21316, 146, 
            1), torch.float32)
        triton_poi_fused_reflection_pad2d_relu_4[grid(2728448)](buf2, buf8,
            buf11, buf3, buf4, buf12, 2728448, XBLOCK=1024, num_warps=4,
            num_stages=1)
        buf13 = extern_kernels.convolution(buf12, primals_6, stride=(2, 2),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf13, (4, 64, 72, 72), (331776, 5184, 72, 1))
        buf14 = buf13
        del buf13
        buf17 = empty_strided_cuda((1, 256, 1, 1), (256, 1, 1, 1), torch.
            float32)
        buf18 = empty_strided_cuda((1, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        buf20 = reinterpret_tensor(buf18, (1, 256, 1, 1), (256, 1, 1, 1), 0)
        del buf18
        triton_red_fused__native_batch_norm_legit_convolution_5[grid(256)](
            buf14, buf20, primals_7, buf17, 256, 5184, XBLOCK=1, RBLOCK=
            2048, num_warps=16, num_stages=1)
        del primals_7
        buf15 = empty_strided_cuda((256,), (1,), torch.float32)
        triton_poi_fused_repeat_6[grid(256)](primals_8, buf15, 256, XBLOCK=
            128, num_warps=4, num_stages=1)
        del primals_8
        buf16 = empty_strided_cuda((256,), (1,), torch.float32)
        triton_poi_fused_repeat_6[grid(256)](primals_9, buf16, 256, XBLOCK=
            128, num_warps=4, num_stages=1)
        del primals_9
        buf21 = empty_strided_cuda((4, 64, 74, 74), (350464, 5476, 74, 1),
            torch.float32)
        triton_poi_fused_reflection_pad2d_relu_7[grid(1401856)](buf14,
            buf17, buf20, buf15, buf16, buf21, 1401856, XBLOCK=1024,
            num_warps=4, num_stages=1)
        buf22 = extern_kernels.convolution(buf21, primals_10, stride=(2, 2),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf22, (4, 128, 36, 36), (165888, 1296, 36, 1))
        buf24 = empty_strided_cuda((512,), (1,), torch.float32)
        buf23 = buf22
        del buf22
        buf25 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf29 = empty_strided_cuda((4, 128, 36, 36), (165888, 1296, 36, 1),
            torch.float32)
        buf28 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_red_fused__native_batch_norm_legit_convolution_relu_repeat_8[
            grid(512)](buf23, primals_12, primals_11, primals_13, buf24,
            buf25, buf29, buf28, 512, 1296, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        del primals_11
        del primals_12
        del primals_13
        buf30 = extern_kernels.convolution(buf29, primals_14, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf30, (4, 128, 34, 34), (147968, 1156, 34, 1))
        buf32 = empty_strided_cuda((512,), (1,), torch.float32)
        buf31 = buf30
        del buf30
        buf33 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf37 = empty_strided_cuda((4, 128, 34, 34), (147968, 1156, 34, 1),
            torch.float32)
        buf36 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_red_fused__native_batch_norm_legit_convolution_relu_repeat_9[
            grid(512)](buf31, primals_16, primals_15, primals_17, buf32,
            buf33, buf37, buf36, 512, 1156, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        del primals_15
        del primals_16
        del primals_17
        buf38 = extern_kernels.convolution(buf37, primals_18, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf38, (4, 128, 32, 32), (131072, 1024, 32, 1))
        buf40 = empty_strided_cuda((512,), (1,), torch.float32)
        buf39 = buf38
        del buf38
        buf41 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf45 = empty_strided_cuda((4, 128, 32, 32), (131072, 1024, 32, 1),
            torch.float32)
        buf44 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_add_convolution_repeat_10[
            grid(512)](buf39, primals_20, primals_19, primals_21, buf29,
            buf40, buf41, buf45, buf44, 512, 1024, num_warps=8, num_stages=1)
        del primals_19
        del primals_20
        del primals_21
        buf46 = extern_kernels.convolution(buf45, primals_22, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf46, (4, 128, 30, 30), (115200, 900, 30, 1))
        buf48 = empty_strided_cuda((512,), (1,), torch.float32)
        buf47 = buf46
        del buf46
        buf49 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf53 = empty_strided_cuda((4, 128, 30, 30), (115200, 900, 30, 1),
            torch.float32)
        buf52 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_11[
            grid(512)](buf47, primals_24, primals_23, primals_25, buf48,
            buf49, buf53, buf52, 512, 900, num_warps=8, num_stages=1)
        del primals_23
        del primals_24
        del primals_25
        buf54 = extern_kernels.convolution(buf53, primals_26, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf54, (4, 128, 28, 28), (100352, 784, 28, 1))
        buf56 = empty_strided_cuda((512,), (1,), torch.float32)
        buf55 = buf54
        del buf54
        buf57 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf61 = empty_strided_cuda((4, 128, 28, 28), (100352, 784, 28, 1),
            torch.float32)
        buf60 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_add_convolution_repeat_12[
            grid(512)](buf55, primals_28, primals_27, primals_29, buf45,
            buf56, buf57, buf61, buf60, 512, 784, num_warps=8, num_stages=1)
        del primals_27
        del primals_28
        del primals_29
        buf62 = extern_kernels.convolution(buf61, primals_30, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf62, (4, 128, 26, 26), (86528, 676, 26, 1))
        buf64 = empty_strided_cuda((512,), (1,), torch.float32)
        buf63 = buf62
        del buf62
        buf65 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf69 = empty_strided_cuda((4, 128, 26, 26), (86528, 676, 26, 1),
            torch.float32)
        buf68 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_13[
            grid(512)](buf63, primals_32, primals_31, primals_33, buf64,
            buf65, buf69, buf68, 512, 676, num_warps=8, num_stages=1)
        del primals_31
        del primals_32
        del primals_33
        buf70 = extern_kernels.convolution(buf69, primals_34, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf70, (4, 128, 24, 24), (73728, 576, 24, 1))
        buf72 = empty_strided_cuda((512,), (1,), torch.float32)
        buf71 = buf70
        del buf70
        buf73 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf77 = empty_strided_cuda((4, 128, 24, 24), (73728, 576, 24, 1),
            torch.float32)
        buf76 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_add_convolution_repeat_14[
            grid(512)](buf71, primals_36, primals_35, primals_37, buf61,
            buf72, buf73, buf77, buf76, 512, 576, num_warps=8, num_stages=1)
        del primals_35
        del primals_36
        del primals_37
        buf78 = extern_kernels.convolution(buf77, primals_38, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf78, (4, 128, 22, 22), (61952, 484, 22, 1))
        buf80 = empty_strided_cuda((512,), (1,), torch.float32)
        buf79 = buf78
        del buf78
        buf81 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf85 = empty_strided_cuda((4, 128, 22, 22), (61952, 484, 22, 1),
            torch.float32)
        buf84 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_15[
            grid(512)](buf79, primals_40, primals_39, primals_41, buf80,
            buf81, buf85, buf84, 512, 484, num_warps=4, num_stages=1)
        del primals_39
        del primals_40
        del primals_41
        buf86 = extern_kernels.convolution(buf85, primals_42, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf86, (4, 128, 20, 20), (51200, 400, 20, 1))
        buf88 = empty_strided_cuda((512,), (1,), torch.float32)
        buf87 = buf86
        del buf86
        buf89 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf93 = empty_strided_cuda((4, 128, 20, 20), (51200, 400, 20, 1),
            torch.float32)
        buf92 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_add_convolution_repeat_16[
            grid(512)](buf87, primals_44, primals_43, primals_45, buf77,
            buf88, buf89, buf93, buf92, 512, 400, num_warps=4, num_stages=1)
        del primals_43
        del primals_44
        del primals_45
        buf94 = extern_kernels.convolution(buf93, primals_46, stride=(1, 1),
            padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf94, (4, 128, 18, 18), (41472, 324, 18, 1))
        buf96 = empty_strided_cuda((512,), (1,), torch.float32)
        buf95 = buf94
        del buf94
        buf97 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf101 = empty_strided_cuda((4, 128, 18, 18), (41472, 324, 18, 1),
            torch.float32)
        buf100 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_convolution_relu_repeat_17[
            grid(512)](buf95, primals_48, primals_47, primals_49, buf96,
            buf97, buf101, buf100, 512, 324, num_warps=4, num_stages=1)
        del primals_47
        del primals_48
        del primals_49
        buf102 = extern_kernels.convolution(buf101, primals_50, stride=(1, 
            1), padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf102, (4, 128, 16, 16), (32768, 256, 16, 1))
        buf103 = buf102
        del buf102
        buf105 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf106 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        buf108 = empty_strided_cuda((1, 512, 1, 1), (512, 1, 512, 512),
            torch.float32)
        triton_per_fused__native_batch_norm_legit_convolution_18[grid(512)](
            buf103, primals_51, buf105, buf106, buf108, 512, 256, num_warps
            =2, num_stages=1)
        del primals_51
        buf104 = empty_strided_cuda((512,), (1,), torch.float32)
        triton_poi_fused_repeat_19[grid(512)](primals_52, buf104, 512,
            XBLOCK=256, num_warps=4, num_stages=1)
        del primals_52
        buf109 = empty_strided_cuda((32,), (1,), torch.int64)
        triton_poi_fused_arange_20[grid(32)](buf109, 32, XBLOCK=32,
            num_warps=1, num_stages=1)
        buf110 = empty_strided_cuda((32,), (1,), torch.int64)
        triton_poi_fused__to_copy_add_arange_mul_21[grid(32)](buf110, 32,
            XBLOCK=32, num_warps=1, num_stages=1)
        buf111 = empty_strided_cuda((4, 128, 34, 34), (147968, 1156, 34, 1),
            torch.float32)
        triton_poi_fused__unsafe_index_add_reflection_pad2d_22[grid(591872)](
            buf110, buf103, buf105, buf106, buf104, primals_53, buf93,
            buf111, 591872, XBLOCK=512, num_warps=8, num_stages=1)
        del buf106
        del primals_53
        buf112 = extern_kernels.convolution(buf111, primals_54, stride=(1, 
            1), padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf112, (4, 64, 32, 32), (65536, 1024, 32, 1))
        buf113 = buf112
        del buf112
        buf116 = empty_strided_cuda((1, 256, 1, 1), (256, 1, 1, 1), torch.
            float32)
        buf117 = empty_strided_cuda((1, 256, 1, 1), (256, 1, 256, 256),
            torch.float32)
        buf119 = reinterpret_tensor(buf117, (1, 256, 1, 1), (256, 1, 1, 1), 0)
        del buf117
        triton_per_fused__native_batch_norm_legit_convolution_23[grid(256)](
            buf113, buf119, primals_55, buf116, 256, 1024, num_warps=8,
            num_stages=1)
        del primals_55
        buf114 = empty_strided_cuda((256,), (1,), torch.float32)
        triton_poi_fused_repeat_6[grid(256)](primals_56, buf114, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        del primals_56
        buf115 = empty_strided_cuda((256,), (1,), torch.float32)
        triton_poi_fused_repeat_6[grid(256)](primals_57, buf115, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        del primals_57
        buf120 = empty_strided_cuda((64,), (1,), torch.int64)
        triton_poi_fused_arange_24[grid(64)](buf120, 64, XBLOCK=64,
            num_warps=1, num_stages=1)
        buf121 = empty_strided_cuda((64,), (1,), torch.int64)
        triton_poi_fused__to_copy_add_arange_mul_25[grid(64)](buf121, 64,
            XBLOCK=64, num_warps=1, num_stages=1)
        buf122 = empty_strided_cuda((4, 64, 66, 66), (278784, 4356, 66, 1),
            torch.float32)
        triton_poi_fused__unsafe_index_reflection_pad2d_relu_26[grid(1115136)](
            buf121, buf113, buf116, buf119, buf114, buf115, buf122, 1115136,
            XBLOCK=512, num_warps=8, num_stages=1)
        buf123 = extern_kernels.convolution(buf122, primals_58, stride=(1, 
            1), padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf123, (4, 32, 64, 64), (131072, 4096, 64, 1))
        buf124 = buf123
        del buf123
        buf127 = empty_strided_cuda((1, 128, 1, 1), (128, 1, 1, 1), torch.
            float32)
        buf128 = empty_strided_cuda((1, 128, 1, 1), (128, 1, 128, 128),
            torch.float32)
        buf130 = reinterpret_tensor(buf128, (1, 128, 1, 1), (128, 1, 1, 1), 0)
        del buf128
        triton_red_fused__native_batch_norm_legit_convolution_27[grid(128)](
            buf124, buf130, primals_59, buf127, 128, 4096, XBLOCK=1, RBLOCK
            =2048, num_warps=16, num_stages=1)
        del primals_59
        buf125 = empty_strided_cuda((128,), (1,), torch.float32)
        triton_poi_fused_repeat_2[grid(128)](primals_60, buf125, 128,
            XBLOCK=128, num_warps=4, num_stages=1)
        del primals_60
        buf126 = empty_strided_cuda((128,), (1,), torch.float32)
        triton_poi_fused_repeat_2[grid(128)](primals_61, buf126, 128,
            XBLOCK=128, num_warps=4, num_stages=1)
        del primals_61
        buf131 = empty_strided_cuda((64,), (1,), torch.int64)
        triton_poi_fused__to_copy_add_arange_mul_28[grid(64)](buf131, 64,
            XBLOCK=64, num_warps=1, num_stages=1)
        buf132 = empty_strided_cuda((4, 32, 72, 72), (165888, 5184, 72, 1),
            torch.float32)
        triton_poi_fused__unsafe_index_reflection_pad2d_relu_29[grid(663552)](
            buf131, buf124, buf127, buf130, buf125, buf126, buf132, 663552,
            XBLOCK=1024, num_warps=4, num_stages=1)
        buf133 = extern_kernels.convolution(buf132, primals_62, stride=(1, 
            1), padding=(0, 0), dilation=(1, 1), transposed=False,
            output_padding=(0, 0), groups=1, bias=None)
        assert_size_stride(buf133, (4, 3, 64, 64), (12288, 4096, 64, 1))
        buf135 = empty_strided_cuda((12,), (1,), torch.float32)
        buf136 = empty_strided_cuda((12,), (1,), torch.float32)
        buf134 = buf133
        del buf133
        buf137 = empty_strided_cuda((1, 12, 1, 1), (12, 1, 1, 1), torch.float32
            )
        buf138 = empty_strided_cuda((1, 12, 1, 1), (12, 1, 12, 12), torch.
            float32)
        buf140 = reinterpret_tensor(buf138, (1, 12, 1, 1), (12, 1, 1, 1), 0)
        del buf138
        buf141 = empty_strided_cuda((4, 3, 64, 64), (12288, 4096, 64, 1),
            torch.float32)
        triton_red_fused__native_batch_norm_legit_add_convolution_div_mul_repeat_tanh_30[
            grid(12)](buf134, buf140, primals_64, primals_65, primals_63,
            buf135, buf136, buf137, buf141, 12, 4096, XBLOCK=1, RBLOCK=2048,
            num_warps=16, num_stages=1)
        del primals_63
        del primals_64
        del primals_65
    return (buf141, primals_2, primals_6, primals_10, primals_14,
        primals_18, primals_22, primals_26, primals_30, primals_34,
        primals_38, primals_42, primals_46, primals_50, primals_54,
        primals_58, primals_62, buf0, buf2, buf3, buf4, buf8, buf11, buf12,
        buf14, buf15, buf16, buf17, buf20, buf21, buf23, buf24,
        reinterpret_tensor(buf28, (512,), (1,), 0), buf29, buf31, buf32,
        reinterpret_tensor(buf36, (512,), (1,), 0), buf37, buf39, buf40,
        reinterpret_tensor(buf44, (512,), (1,), 0), buf45, buf47, buf48,
        reinterpret_tensor(buf52, (512,), (1,), 0), buf53, buf55, buf56,
        reinterpret_tensor(buf60, (512,), (1,), 0), buf61, buf63, buf64,
        reinterpret_tensor(buf68, (512,), (1,), 0), buf69, buf71, buf72,
        reinterpret_tensor(buf76, (512,), (1,), 0), buf77, buf79, buf80,
        reinterpret_tensor(buf84, (512,), (1,), 0), buf85, buf87, buf88,
        reinterpret_tensor(buf92, (512,), (1,), 0), buf93, buf95, buf96,
        reinterpret_tensor(buf100, (512,), (1,), 0), buf101, buf103, buf104,
        reinterpret_tensor(buf108, (512,), (1,), 0), buf109, buf110, buf111,
        buf113, buf114, buf115, buf116, buf119, buf120, buf121, buf122,
        buf124, buf125, buf126, buf127, buf130, buf131, buf132, buf134,
        buf135, buf136, buf137, buf140, reinterpret_tensor(buf105, (1, 512,
        1, 1), (512, 1, 1, 1), 0), reinterpret_tensor(buf97, (1, 512, 1, 1),
        (512, 1, 1, 1), 0), reinterpret_tensor(buf89, (1, 512, 1, 1), (512,
        1, 1, 1), 0), reinterpret_tensor(buf81, (1, 512, 1, 1), (512, 1, 1,
        1), 0), reinterpret_tensor(buf73, (1, 512, 1, 1), (512, 1, 1, 1), 0
        ), reinterpret_tensor(buf65, (1, 512, 1, 1), (512, 1, 1, 1), 0),
        reinterpret_tensor(buf57, (1, 512, 1, 1), (512, 1, 1, 1), 0),
        reinterpret_tensor(buf49, (1, 512, 1, 1), (512, 1, 1, 1), 0),
        reinterpret_tensor(buf41, (1, 512, 1, 1), (512, 1, 1, 1), 0),
        reinterpret_tensor(buf33, (1, 512, 1, 1), (512, 1, 1, 1), 0),
        reinterpret_tensor(buf25, (1, 512, 1, 1), (512, 1, 1, 1), 0))


class ResidualBlock(nn.Module):
    """Redisual network block for style transfer."""

    def __init__(self, nchannels):
        """Create a block of a residual network."""
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(nchannels, nchannels, kernel_size=3)
        self.conv2 = nn.Conv2d(nchannels, nchannels, kernel_size=3)
        self.norm_conv1 = nn.InstanceNorm2d(nchannels, affine=True)
        self.norm_conv2 = nn.InstanceNorm2d(nchannels, affine=True)
        self.nonlinearity = nn.ReLU()

    def forward(self, x):
        """Forward the input through the block."""
        residual = x[:, :, 2:-2, 2:-2]
        out = self.nonlinearity(self.norm_conv1(self.conv1(x)))
        out = self.norm_conv2(self.conv2(out))
        return out + residual


class UpsampleConv2d(nn.Module):
    """
    Avoid checkerboard patterns by upsampling the image and convolving.

    https://distill.pub/2016/deconv-checkerboard/
    """

    def __init__(self, in_channels, out_channels, kernel_size, stride,
        padding, upsample):
        """Set parameters for upsampling."""
        super(UpsampleConv2d, self).__init__()
        self.upsample = upsample
        self.padding = nn.ReflectionPad2d(padding)
        self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride)

    def forward(self, x):
        """
        Upsample then convolve the image.

        "We’ve had our best results with nearest-neighbor interpolation, and
        had difficulty making bilinear resize work. This may simply mean that,
        for our models, the nearest-neighbor happened to work well with
        hyper-parameters optimized for deconvolution. It might also point at
        trickier issues with naively using bilinear interpolation, where it
        resists high-frequency image features too strongly. We don’t
        necessarily think that either approach is the final solution to
        upsampling, but they do fix the checkerboard artifacts."
        (https://distill.pub/2016/deconv-checkerboard/)
        """
        x = F.interpolate(x, mode='nearest', scale_factor=self.upsample)
        return self.conv(self.padding(x))


class ImageTransformNetNew(nn.Module):
    """
    Image Transformation Network for style transfer.

    See here for the architecture:
    https://cs.stanford.edu/people/jcjohns/papers/eccv16/JohnsonECCV16Supplementary.pdf
    """

    def __init__(self):
        """Construct the network to train later."""
        super(ImageTransformNetNew, self).__init__()
        self.reflection_padding = nn.ReflectionPad2d(40)
        self.conv1 = nn.Conv2d(3, 32, kernel_size=9, stride=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=2)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=2)
        self.pad_conv1 = nn.ReflectionPad2d(padding=4)
        self.pad_conv2 = nn.ReflectionPad2d(padding=1)
        self.pad_conv3 = nn.ReflectionPad2d(padding=1)
        self.norm_conv1 = nn.InstanceNorm2d(32, affine=True)
        self.norm_conv2 = nn.InstanceNorm2d(64, affine=True)
        self.norm_conv3 = nn.InstanceNorm2d(128, affine=True)
        self.res_block1 = ResidualBlock(128)
        self.res_block2 = ResidualBlock(128)
        self.res_block3 = ResidualBlock(128)
        self.res_block4 = ResidualBlock(128)
        self.res_block5 = ResidualBlock(128)
        self.upsample_conv1 = UpsampleConv2d(128, 64, kernel_size=3, stride
            =1, padding=1, upsample=2)
        self.upsample_conv2 = UpsampleConv2d(64, 32, kernel_size=3, stride=
            1, padding=1, upsample=2)
        self.upsample_conv3 = UpsampleConv2d(32, 3, kernel_size=9, stride=1,
            padding=4, upsample=1)
        self.norm_upsample_conv1 = nn.InstanceNorm2d(64, affine=True)
        self.norm_upsample_conv2 = nn.InstanceNorm2d(32, affine=True)
        self.norm_upsample_conv3 = nn.InstanceNorm2d(3, affine=True)
        self.nonlinearity = nn.ReLU()
        self.tanh = nn.Tanh()
        self.output_nonlineaity = lambda x: (self.tanh(x) + 1) / 2 * 255

    def forward(self, input_0):
        primals_2 = self.conv1.weight
        primals_3 = self.conv1.bias
        primals_6 = self.conv2.weight
        primals_7 = self.conv2.bias
        primals_10 = self.conv3.weight
        primals_11 = self.conv3.bias
        primals_4 = self.norm_conv1.weight
        primals_5 = self.norm_conv1.bias
        primals_8 = self.norm_conv2.weight
        primals_9 = self.norm_conv2.bias
        primals_12 = self.norm_conv3.weight
        primals_13 = self.norm_conv3.bias
        primals_14 = self.res_block1.conv1.weight
        primals_15 = self.res_block1.conv1.bias
        primals_18 = self.res_block1.conv2.weight
        primals_16 = self.res_block1.conv2.bias
        primals_17 = self.res_block1.norm_conv1.weight
        primals_19 = self.res_block1.norm_conv1.bias
        primals_20 = self.res_block1.norm_conv2.weight
        primals_21 = self.res_block1.norm_conv2.bias
        primals_22 = self.res_block2.conv1.weight
        primals_23 = self.res_block2.conv1.bias
        primals_26 = self.res_block2.conv2.weight
        primals_24 = self.res_block2.conv2.bias
        primals_25 = self.res_block2.norm_conv1.weight
        primals_27 = self.res_block2.norm_conv1.bias
        primals_28 = self.res_block2.norm_conv2.weight
        primals_29 = self.res_block2.norm_conv2.bias
        primals_30 = self.res_block3.conv1.weight
        primals_31 = self.res_block3.conv1.bias
        primals_34 = self.res_block3.conv2.weight
        primals_32 = self.res_block3.conv2.bias
        primals_33 = self.res_block3.norm_conv1.weight
        primals_35 = self.res_block3.norm_conv1.bias
        primals_36 = self.res_block3.norm_conv2.weight
        primals_37 = self.res_block3.norm_conv2.bias
        primals_38 = self.res_block4.conv1.weight
        primals_39 = self.res_block4.conv1.bias
        primals_42 = self.res_block4.conv2.weight
        primals_40 = self.res_block4.conv2.bias
        primals_41 = self.res_block4.norm_conv1.weight
        primals_43 = self.res_block4.norm_conv1.bias
        primals_44 = self.res_block4.norm_conv2.weight
        primals_45 = self.res_block4.norm_conv2.bias
        primals_46 = self.res_block5.conv1.weight
        primals_47 = self.res_block5.conv1.bias
        primals_50 = self.res_block5.conv2.weight
        primals_48 = self.res_block5.conv2.bias
        primals_49 = self.res_block5.norm_conv1.weight
        primals_51 = self.res_block5.norm_conv1.bias
        primals_52 = self.res_block5.norm_conv2.weight
        primals_53 = self.res_block5.norm_conv2.bias
        primals_54 = self.upsample_conv1.conv.weight
        primals_55 = self.upsample_conv1.conv.bias
        primals_58 = self.upsample_conv2.conv.weight
        primals_59 = self.upsample_conv2.conv.bias
        primals_62 = self.upsample_conv3.conv.weight
        primals_63 = self.upsample_conv3.conv.bias
        primals_56 = self.norm_upsample_conv1.weight
        primals_57 = self.norm_upsample_conv1.bias
        primals_60 = self.norm_upsample_conv2.weight
        primals_61 = self.norm_upsample_conv2.bias
        primals_64 = self.norm_upsample_conv3.weight
        primals_65 = self.norm_upsample_conv3.bias
        primals_1 = input_0
        output = call([primals_1, primals_2, primals_3, primals_4,
            primals_5, primals_6, primals_7, primals_8, primals_9,
            primals_10, primals_11, primals_12, primals_13, primals_14,
            primals_15, primals_16, primals_17, primals_18, primals_19,
            primals_20, primals_21, primals_22, primals_23, primals_24,
            primals_25, primals_26, primals_27, primals_28, primals_29,
            primals_30, primals_31, primals_32, primals_33, primals_34,
            primals_35, primals_36, primals_37, primals_38, primals_39,
            primals_40, primals_41, primals_42, primals_43, primals_44,
            primals_45, primals_46, primals_47, primals_48, primals_49,
            primals_50, primals_51, primals_52, primals_53, primals_54,
            primals_55, primals_56, primals_57, primals_58, primals_59,
            primals_60, primals_61, primals_62, primals_63, primals_64,
            primals_65])
        return output[0]


Measured latency_ms: 0.033926