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 math
import torch.nn as nn
import torch.nn.functional as F
import torch.onnx
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_add_div_mean_mul_std_sub_0(in_ptr0, in_ptr1, in_ptr2,
    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 % 4
    x2 = xindex
    x1 = xindex // 4
    tmp0 = tl.load(in_ptr0 + x0, xmask, eviction_policy='evict_last')
    tmp1 = tl.load(in_ptr1 + x2, xmask)
    tmp2 = tl.load(in_ptr1 + 4 * x1, xmask, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr1 + (1 + 4 * x1), xmask, eviction_policy='evict_last')
    tmp5 = tl.load(in_ptr1 + (2 + 4 * x1), xmask, eviction_policy='evict_last')
    tmp7 = tl.load(in_ptr1 + (3 + 4 * x1), xmask, eviction_policy='evict_last')
    tmp30 = tl.load(in_ptr2 + x0, xmask, eviction_policy='evict_last')
    tmp4 = tmp2 + tmp3
    tmp6 = tmp4 + tmp5
    tmp8 = tmp6 + tmp7
    tmp9 = 4.0
    tmp10 = tmp8 / tmp9
    tmp11 = tmp1 - tmp10
    tmp12 = tmp2 - tmp10
    tmp13 = tmp12 * tmp12
    tmp14 = tmp3 - tmp10
    tmp15 = tmp14 * tmp14
    tmp16 = tmp13 + tmp15
    tmp17 = tmp5 - tmp10
    tmp18 = tmp17 * tmp17
    tmp19 = tmp16 + tmp18
    tmp20 = tmp7 - tmp10
    tmp21 = tmp20 * tmp20
    tmp22 = tmp19 + tmp21
    tmp23 = 3.0
    tmp24 = tmp22 / tmp23
    tmp25 = libdevice.sqrt(tmp24)
    tmp26 = 1e-06
    tmp27 = tmp25 + tmp26
    tmp28 = tmp11 / tmp27
    tmp29 = tmp0 * tmp28
    tmp31 = tmp29 + tmp30
    tl.store(out_ptr0 + x2, tmp31, xmask)


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


@triton.jit
def triton_poi_fused_eq_2(in_ptr0, 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 = tl.load(in_ptr0 + x0, xmask)
    tmp1 = 0.0
    tmp2 = tmp0 == tmp1
    tl.store(out_ptr0 + x0, tmp2, xmask)


@triton.jit
def triton_poi_fused__softmax_div_masked_fill_3(in_ptr0, in_ptr1, out_ptr0,
    out_ptr1, xnumel, XBLOCK: tl.constexpr):
    xnumel = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex % 4
    x2 = xindex // 16
    x3 = xindex
    tmp0 = tl.load(in_ptr0 + (4 * x0 + 16 * x2), xmask, eviction_policy=
        'evict_last').to(tl.int1)
    tmp1 = tl.load(in_ptr1 + 4 * x3, xmask, eviction_policy='evict_last')
    tmp6 = tl.load(in_ptr0 + (1 + 4 * x0 + 16 * x2), xmask, eviction_policy
        ='evict_last').to(tl.int1)
    tmp7 = tl.load(in_ptr1 + (1 + 4 * x3), xmask, eviction_policy='evict_last')
    tmp11 = tl.load(in_ptr0 + (2 + 4 * x0 + 16 * x2), xmask,
        eviction_policy='evict_last').to(tl.int1)
    tmp12 = tl.load(in_ptr1 + (2 + 4 * x3), xmask, eviction_policy='evict_last'
        )
    tmp16 = tl.load(in_ptr0 + (3 + 4 * x0 + 16 * x2), xmask,
        eviction_policy='evict_last').to(tl.int1)
    tmp17 = tl.load(in_ptr1 + (3 + 4 * x3), xmask, eviction_policy='evict_last'
        )
    tmp2 = 1.0
    tmp3 = tmp1 * tmp2
    tmp4 = -1000000000.0
    tmp5 = tl.where(tmp0, tmp4, tmp3)
    tmp8 = tmp7 * tmp2
    tmp9 = tl.where(tmp6, tmp4, tmp8)
    tmp10 = triton_helpers.maximum(tmp5, tmp9)
    tmp13 = tmp12 * tmp2
    tmp14 = tl.where(tmp11, tmp4, tmp13)
    tmp15 = triton_helpers.maximum(tmp10, tmp14)
    tmp18 = tmp17 * tmp2
    tmp19 = tl.where(tmp16, tmp4, tmp18)
    tmp20 = triton_helpers.maximum(tmp15, tmp19)
    tmp21 = tmp5 - tmp20
    tmp22 = tl_math.exp(tmp21)
    tmp23 = tmp9 - tmp20
    tmp24 = tl_math.exp(tmp23)
    tmp25 = tmp22 + tmp24
    tmp26 = tmp14 - tmp20
    tmp27 = tl_math.exp(tmp26)
    tmp28 = tmp25 + tmp27
    tmp29 = tmp19 - tmp20
    tmp30 = tl_math.exp(tmp29)
    tmp31 = tmp28 + tmp30
    tl.store(out_ptr0 + x3, tmp20, xmask)
    tl.store(out_ptr1 + x3, tmp31, xmask)


@triton.jit
def triton_poi_fused__softmax_div_masked_fill_4(in_out_ptr0, in_ptr0,
    in_ptr1, in_ptr2, xnumel, XBLOCK: tl.constexpr):
    xnumel = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x3 = xindex // 64
    x4 = xindex % 16
    x5 = xindex
    x6 = xindex // 4
    tmp0 = tl.load(in_ptr0 + (x4 + 16 * x3), xmask, eviction_policy=
        'evict_last').to(tl.int1)
    tmp1 = tl.load(in_out_ptr0 + x5, xmask)
    tmp6 = tl.load(in_ptr1 + x6, xmask, eviction_policy='evict_last')
    tmp9 = tl.load(in_ptr2 + x6, xmask, eviction_policy='evict_last')
    tmp2 = 1.0
    tmp3 = tmp1 * tmp2
    tmp4 = -1000000000.0
    tmp5 = tl.where(tmp0, tmp4, tmp3)
    tmp7 = tmp5 - tmp6
    tmp8 = tl_math.exp(tmp7)
    tmp10 = tmp8 / tmp9
    tl.store(in_out_ptr0 + x5, tmp10, xmask)


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


@triton.jit
def triton_poi_fused_add_mean_std_6(in_out_ptr0, in_ptr0, in_ptr1, out_ptr0,
    xnumel, XBLOCK: tl.constexpr):
    xnumel = 16
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + 4 * x0, xmask, eviction_policy='evict_last')
    tmp1 = tl.load(in_ptr1 + 4 * x0, xmask, eviction_policy='evict_last')
    tmp3 = tl.load(in_ptr0 + (1 + 4 * x0), xmask, eviction_policy='evict_last')
    tmp4 = tl.load(in_ptr1 + (1 + 4 * x0), xmask, eviction_policy='evict_last')
    tmp7 = tl.load(in_ptr0 + (2 + 4 * x0), xmask, eviction_policy='evict_last')
    tmp8 = tl.load(in_ptr1 + (2 + 4 * x0), xmask, eviction_policy='evict_last')
    tmp11 = tl.load(in_ptr0 + (3 + 4 * x0), xmask, eviction_policy='evict_last'
        )
    tmp12 = tl.load(in_ptr1 + (3 + 4 * x0), xmask, eviction_policy='evict_last'
        )
    tmp2 = tmp0 + tmp1
    tmp5 = tmp3 + tmp4
    tmp6 = tmp2 + tmp5
    tmp9 = tmp7 + tmp8
    tmp10 = tmp6 + tmp9
    tmp13 = tmp11 + tmp12
    tmp14 = tmp10 + tmp13
    tmp15 = 4.0
    tmp16 = tmp14 / tmp15
    tmp17 = tmp2 - tmp16
    tmp18 = tmp17 * tmp17
    tmp19 = tmp5 - tmp16
    tmp20 = tmp19 * tmp19
    tmp21 = tmp18 + tmp20
    tmp22 = tmp9 - tmp16
    tmp23 = tmp22 * tmp22
    tmp24 = tmp21 + tmp23
    tmp25 = tmp13 - tmp16
    tmp26 = tmp25 * tmp25
    tmp27 = tmp24 + tmp26
    tmp28 = 3.0
    tmp29 = tmp27 / tmp28
    tl.store(out_ptr0 + x0, tmp16, xmask)
    tl.store(in_out_ptr0 + x0, tmp29, xmask)


@triton.jit
def triton_poi_fused_add_div_mean_mul_std_sub_7(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, in_ptr4, in_ptr5, 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 % 4
    x2 = xindex
    x1 = xindex // 4
    tmp0 = tl.load(in_ptr0 + x0, xmask, eviction_policy='evict_last')
    tmp1 = tl.load(in_ptr1 + x2, xmask)
    tmp2 = tl.load(in_ptr2 + x2, xmask)
    tmp4 = tl.load(in_ptr3 + x1, xmask, eviction_policy='evict_last')
    tmp6 = tl.load(in_ptr4 + x1, xmask, eviction_policy='evict_last')
    tmp12 = tl.load(in_ptr5 + x0, xmask, eviction_policy='evict_last')
    tmp3 = tmp1 + tmp2
    tmp5 = tmp3 - tmp4
    tmp7 = libdevice.sqrt(tmp6)
    tmp8 = 1e-06
    tmp9 = tmp7 + tmp8
    tmp10 = tmp5 / tmp9
    tmp11 = tmp0 * tmp10
    tmp13 = tmp11 + tmp12
    tl.store(out_ptr0 + x2, tmp13, xmask)


@triton.jit
def triton_poi_fused_add_8(in_out_ptr0, in_ptr0, in_ptr1, in_ptr2, xnumel,
    XBLOCK: tl.constexpr):
    xnumel = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x2 = xindex
    x0 = xindex % 4
    tmp0 = tl.load(in_ptr0 + x2, xmask)
    tmp1 = tl.load(in_ptr1 + x2, xmask)
    tmp3 = tl.load(in_out_ptr0 + x2, xmask)
    tmp4 = tl.load(in_ptr2 + x0, xmask, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp5 = tmp3 + tmp4
    tmp6 = tmp2 + tmp5
    tl.store(in_out_ptr0 + x2, tmp6, xmask)


@triton.jit
def triton_poi_fused_leaky_relu_9(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)
    x2 = xindex
    x0 = xindex % 2048
    tmp0 = tl.load(in_ptr0 + x2, None)
    tmp1 = tl.load(in_ptr1 + x0, None, eviction_policy='evict_last')
    tmp2 = tmp0 + tmp1
    tmp3 = 0.0
    tmp4 = tmp2 > tmp3
    tmp5 = 0.01
    tmp6 = tmp2 * tmp5
    tmp7 = tl.where(tmp4, tmp2, tmp6)
    tl.store(out_ptr0 + x2, tmp4, None)
    tl.store(out_ptr1 + x2, tmp7, None)


@triton.jit
def triton_poi_fused_add_10(in_out_ptr0, in_ptr0, in_ptr1, xnumel, XBLOCK:
    tl.constexpr):
    xnumel = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x2 = xindex
    x0 = xindex % 4
    tmp0 = tl.load(in_ptr0 + x2, xmask)
    tmp1 = tl.load(in_out_ptr0 + x2, xmask)
    tmp2 = tl.load(in_ptr1 + x0, xmask, eviction_policy='evict_last')
    tmp3 = tmp1 + tmp2
    tmp4 = tmp0 + tmp3
    tl.store(in_out_ptr0 + x2, tmp4, 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) = args
    args.clear()
    assert_size_stride(primals_1, (4, 4, 4), (16, 4, 1))
    assert_size_stride(primals_2, (4,), (1,))
    assert_size_stride(primals_3, (4,), (1,))
    assert_size_stride(primals_4, (4, 4), (4, 1))
    assert_size_stride(primals_5, (4,), (1,))
    assert_size_stride(primals_6, (4, 4), (4, 1))
    assert_size_stride(primals_7, (4,), (1,))
    assert_size_stride(primals_8, (4, 4), (4, 1))
    assert_size_stride(primals_9, (4,), (1,))
    assert_size_stride(primals_10, (4, 4, 4), (16, 4, 1))
    assert_size_stride(primals_11, (4, 4), (4, 1))
    assert_size_stride(primals_12, (4,), (1,))
    assert_size_stride(primals_13, (4,), (1,))
    assert_size_stride(primals_14, (4,), (1,))
    assert_size_stride(primals_15, (4, 4), (4, 1))
    assert_size_stride(primals_16, (4,), (1,))
    assert_size_stride(primals_17, (4, 4), (4, 1))
    assert_size_stride(primals_18, (4,), (1,))
    assert_size_stride(primals_19, (4, 4, 4), (16, 4, 1))
    assert_size_stride(primals_20, (4, 4), (4, 1))
    assert_size_stride(primals_21, (4,), (1,))
    assert_size_stride(primals_22, (4, 4, 4), (16, 4, 1))
    assert_size_stride(primals_23, (4, 4), (4, 1))
    assert_size_stride(primals_24, (4,), (1,))
    assert_size_stride(primals_25, (4,), (1,))
    assert_size_stride(primals_26, (4,), (1,))
    assert_size_stride(primals_27, (2048, 4), (4, 1))
    assert_size_stride(primals_28, (2048,), (1,))
    assert_size_stride(primals_29, (4, 2048), (2048, 1))
    assert_size_stride(primals_30, (4,), (1,))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4, 4, 4), (16, 4, 1), torch.float32)
        get_raw_stream(0)
        triton_poi_fused_add_div_mean_mul_std_sub_0[grid(64)](primals_2,
            primals_1, primals_3, buf0, 64, XBLOCK=64, num_warps=1,
            num_stages=1)
        del primals_2
        del primals_3
        buf1 = empty_strided_cuda((16, 4), (4, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(buf0, (16, 4), (4, 1), 0),
            reinterpret_tensor(primals_4, (4, 4), (1, 4), 0), out=buf1)
        buf2 = empty_strided_cuda((16, 4), (4, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(buf0, (16, 4), (4, 1), 0),
            reinterpret_tensor(primals_6, (4, 4), (1, 4), 0), out=buf2)
        buf3 = empty_strided_cuda((16, 4), (4, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(buf0, (16, 4), (4, 1), 0),
            reinterpret_tensor(primals_8, (4, 4), (1, 4), 0), out=buf3)
        buf4 = empty_strided_cuda((4, 4, 4, 1), (16, 4, 1, 1), torch.float32)
        triton_poi_fused_clone_1[grid(16, 4)](buf1, primals_5, buf4, 16, 4,
            XBLOCK=2, YBLOCK=16, num_warps=1, num_stages=1)
        del primals_5
        buf5 = reinterpret_tensor(buf1, (4, 4, 1, 4), (16, 4, 4, 1), 0)
        del buf1
        triton_poi_fused_clone_1[grid(16, 4)](buf2, primals_7, buf5, 16, 4,
            XBLOCK=2, YBLOCK=16, num_warps=1, num_stages=1)
        del primals_7
        buf6 = empty_strided_cuda((16, 4, 4), (16, 4, 1), torch.float32)
        extern_kernels.bmm(reinterpret_tensor(buf4, (16, 4, 1), (4, 1, 0), 
            0), reinterpret_tensor(buf5, (16, 1, 4), (4, 0, 1), 0), out=buf6)
        buf7 = empty_strided_cuda((4, 1, 4, 4), (16, 16, 4, 1), torch.bool)
        triton_poi_fused_eq_2[grid(64)](primals_10, buf7, 64, XBLOCK=64,
            num_warps=1, num_stages=1)
        del primals_10
        buf8 = reinterpret_tensor(buf2, (4, 4, 4, 1), (16, 4, 1, 64), 0)
        del buf2
        buf9 = empty_strided_cuda((4, 4, 4, 1), (16, 4, 1, 64), torch.float32)
        triton_poi_fused__softmax_div_masked_fill_3[grid(64)](buf7, buf6,
            buf8, buf9, 64, XBLOCK=64, num_warps=1, num_stages=1)
        buf10 = reinterpret_tensor(buf6, (4, 4, 4, 4), (64, 16, 4, 1), 0)
        del buf6
        triton_poi_fused__softmax_div_masked_fill_4[grid(256)](buf10, buf7,
            buf8, buf9, 256, XBLOCK=128, num_warps=4, num_stages=1)
        buf11 = reinterpret_tensor(buf9, (4, 4, 4, 1), (16, 4, 1, 1), 0)
        del buf9
        triton_poi_fused_clone_1[grid(16, 4)](buf3, primals_9, buf11, 16, 4,
            XBLOCK=2, YBLOCK=16, num_warps=1, num_stages=1)
        del primals_9
        buf12 = reinterpret_tensor(buf3, (16, 4, 1), (4, 1, 1), 0)
        del buf3
        extern_kernels.bmm(reinterpret_tensor(buf10, (16, 4, 4), (16, 4, 1),
            0), reinterpret_tensor(buf11, (16, 4, 1), (4, 1, 0), 0), out=buf12)
        buf13 = reinterpret_tensor(buf8, (4, 4, 4, 1), (16, 4, 1, 1), 0)
        del buf8
        triton_poi_fused_clone_5[grid(16, 4)](buf12, buf13, 16, 4, XBLOCK=4,
            YBLOCK=16, num_warps=1, num_stages=1)
        buf14 = reinterpret_tensor(buf12, (16, 4), (4, 1), 0)
        del buf12
        extern_kernels.addmm(primals_12, reinterpret_tensor(buf13, (16, 4),
            (4, 1), 0), reinterpret_tensor(primals_11, (4, 4), (1, 4), 0),
            alpha=1, beta=1, out=buf14)
        del primals_12
        buf15 = empty_strided_cuda((4, 4, 1), (4, 1, 16), torch.float32)
        buf16 = empty_strided_cuda((4, 4, 1), (4, 1, 16), torch.float32)
        buf17 = buf16
        del buf16
        triton_poi_fused_add_mean_std_6[grid(16)](buf17, primals_1, buf14,
            buf15, 16, XBLOCK=16, num_warps=1, num_stages=1)
        buf18 = empty_strided_cuda((4, 4, 4), (16, 4, 1), torch.float32)
        triton_poi_fused_add_div_mean_mul_std_sub_7[grid(64)](primals_13,
            primals_1, buf14, buf15, buf17, primals_14, buf18, 64, XBLOCK=
            64, num_warps=1, num_stages=1)
        del buf15
        del buf17
        del primals_14
        buf19 = empty_strided_cuda((16, 4), (4, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(buf18, (16, 4), (4, 1), 0),
            reinterpret_tensor(primals_15, (4, 4), (1, 4), 0), out=buf19)
        buf20 = empty_strided_cuda((16, 4), (4, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(primals_19, (16, 4), (4, 1), 0
            ), reinterpret_tensor(primals_17, (4, 4), (1, 4), 0), out=buf20)
        del primals_17
        buf21 = empty_strided_cuda((16, 4), (4, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(primals_19, (16, 4), (4, 1), 0
            ), reinterpret_tensor(primals_20, (4, 4), (1, 4), 0), out=buf21)
        del primals_20
        buf22 = empty_strided_cuda((4, 4, 4, 1), (16, 4, 1, 1), torch.float32)
        triton_poi_fused_clone_1[grid(16, 4)](buf19, primals_16, buf22, 16,
            4, XBLOCK=2, YBLOCK=16, num_warps=1, num_stages=1)
        del primals_16
        buf23 = reinterpret_tensor(buf19, (4, 4, 1, 4), (16, 4, 4, 1), 0)
        del buf19
        triton_poi_fused_clone_1[grid(16, 4)](buf20, primals_18, buf23, 16,
            4, XBLOCK=2, YBLOCK=16, num_warps=1, num_stages=1)
        del primals_18
        buf24 = empty_strided_cuda((16, 4, 4), (16, 4, 1), torch.float32)
        extern_kernels.bmm(reinterpret_tensor(buf22, (16, 4, 1), (4, 1, 0),
            0), reinterpret_tensor(buf23, (16, 1, 4), (4, 0, 1), 0), out=buf24)
        buf25 = empty_strided_cuda((4, 1, 4, 4), (16, 16, 4, 1), torch.bool)
        triton_poi_fused_eq_2[grid(64)](primals_22, buf25, 64, XBLOCK=64,
            num_warps=1, num_stages=1)
        del primals_22
        buf26 = reinterpret_tensor(buf20, (4, 4, 4, 1), (16, 4, 1, 64), 0)
        del buf20
        buf27 = empty_strided_cuda((4, 4, 4, 1), (16, 4, 1, 64), torch.float32)
        triton_poi_fused__softmax_div_masked_fill_3[grid(64)](buf25, buf24,
            buf26, buf27, 64, XBLOCK=64, num_warps=1, num_stages=1)
        buf28 = reinterpret_tensor(buf24, (4, 4, 4, 4), (64, 16, 4, 1), 0)
        del buf24
        triton_poi_fused__softmax_div_masked_fill_4[grid(256)](buf28, buf25,
            buf26, buf27, 256, XBLOCK=128, num_warps=4, num_stages=1)
        buf29 = reinterpret_tensor(buf27, (4, 4, 4, 1), (16, 4, 1, 1), 0)
        del buf27
        triton_poi_fused_clone_1[grid(16, 4)](buf21, primals_21, buf29, 16,
            4, XBLOCK=2, YBLOCK=16, num_warps=1, num_stages=1)
        del primals_21
        buf30 = reinterpret_tensor(buf21, (16, 4, 1), (4, 1, 1), 0)
        del buf21
        extern_kernels.bmm(reinterpret_tensor(buf28, (16, 4, 4), (16, 4, 1),
            0), reinterpret_tensor(buf29, (16, 4, 1), (4, 1, 0), 0), out=buf30)
        buf31 = reinterpret_tensor(buf26, (4, 4, 4, 1), (16, 4, 1, 1), 0)
        del buf26
        triton_poi_fused_clone_5[grid(16, 4)](buf30, buf31, 16, 4, XBLOCK=4,
            YBLOCK=16, num_warps=1, num_stages=1)
        buf32 = reinterpret_tensor(buf30, (16, 4), (4, 1), 0)
        del buf30
        extern_kernels.mm(reinterpret_tensor(buf31, (16, 4), (4, 1), 0),
            reinterpret_tensor(primals_23, (4, 4), (1, 4), 0), out=buf32)
        buf33 = reinterpret_tensor(buf32, (4, 4, 4), (16, 4, 1), 0)
        del buf32
        triton_poi_fused_add_8[grid(64)](buf33, primals_1, buf14,
            primals_24, 64, XBLOCK=64, num_warps=1, num_stages=1)
        del primals_24
        buf34 = empty_strided_cuda((4, 4, 4), (16, 4, 1), torch.float32)
        triton_poi_fused_add_div_mean_mul_std_sub_0[grid(64)](primals_25,
            buf33, primals_26, buf34, 64, XBLOCK=64, num_warps=1, num_stages=1)
        del primals_26
        buf35 = empty_strided_cuda((16, 2048), (2048, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(buf34, (16, 4), (4, 1), 0),
            reinterpret_tensor(primals_27, (4, 2048), (1, 4), 0), out=buf35)
        buf36 = empty_strided_cuda((4, 4, 2048), (8192, 2048, 1), torch.bool)
        buf37 = empty_strided_cuda((4, 4, 2048), (8192, 2048, 1), torch.float32
            )
        triton_poi_fused_leaky_relu_9[grid(32768)](buf35, primals_28, buf36,
            buf37, 32768, XBLOCK=256, num_warps=4, num_stages=1)
        del buf35
        del primals_28
        buf38 = empty_strided_cuda((16, 4), (4, 1), torch.float32)
        extern_kernels.mm(reinterpret_tensor(buf37, (16, 2048), (2048, 1), 
            0), reinterpret_tensor(primals_29, (2048, 4), (1, 2048), 0),
            out=buf38)
        buf39 = reinterpret_tensor(buf38, (4, 4, 4), (16, 4, 1), 0)
        del buf38
        triton_poi_fused_add_10[grid(64)](buf39, buf33, primals_30, 64,
            XBLOCK=64, num_warps=1, num_stages=1)
        del primals_30
    return buf39, primals_1, primals_13, primals_25, reinterpret_tensor(buf0,
        (16, 4), (4, 1), 0), buf7, buf10, reinterpret_tensor(buf13, (16, 4),
        (4, 1), 0), buf14, reinterpret_tensor(buf18, (16, 4), (4, 1), 0
        ), reinterpret_tensor(primals_19, (16, 4), (4, 1), 0
        ), buf25, buf28, reinterpret_tensor(buf31, (16, 4), (4, 1), 0
        ), buf33, reinterpret_tensor(buf34, (16, 4), (4, 1), 0
        ), buf36, reinterpret_tensor(buf37, (16, 2048), (2048, 1), 0
        ), primals_29, primals_27, primals_23, reinterpret_tensor(buf29, (
        16, 1, 4), (4, 1, 1), 0), reinterpret_tensor(buf22, (16, 1, 4), (4,
        1, 1), 0), reinterpret_tensor(buf23, (16, 4, 1), (4, 1, 4), 0
        ), primals_15, primals_11, reinterpret_tensor(buf11, (16, 1, 4), (4,
        1, 1), 0), reinterpret_tensor(buf4, (16, 1, 4), (4, 1, 1), 0
        ), reinterpret_tensor(buf5, (16, 4, 1), (4, 1, 4), 0
        ), primals_8, primals_6, primals_4


class Norm(nn.Module):

    def __init__(self, emb_dim, eps=1e-06):
        super().__init__()
        self.size = emb_dim
        self.alpha = nn.Parameter(torch.ones(self.size))
        self.bias = nn.Parameter(torch.zeros(self.size))
        self.eps = eps

    def forward(self, x):
        """
        inputs:
            x: input of shape: (batch size, sequence length, embedding dimensions)

        outputs: Scaled, normalized x
        """
        norm = (x - x.mean(dim=-1, keepdim=True)) / (x.std(dim=-1, keepdim=
            True) + self.eps)
        norm = self.alpha * norm + self.bias
        return norm


class MultiHeadAttention(nn.Module):

    def __init__(self, num_heads, emb_dim, dim_k=None, dropout=0.1):
        super().__init__()
        self.emb_dim = emb_dim
        self.dim_k = dim_k if dim_k else emb_dim // num_heads
        self.num_heads = num_heads
        self.q_linear = nn.Linear(emb_dim, self.dim_k * num_heads)
        self.k_linear = nn.Linear(emb_dim, self.dim_k * num_heads)
        self.v_linear = nn.Linear(emb_dim, self.dim_k * num_heads)
        self.dropout = nn.Dropout(dropout)
        self.out = nn.Linear(self.dim_k * num_heads, emb_dim)

    def attention(self, q, k, v, dim_k, mask=None, dropout=None, explain=False
        ):
        k = k.transpose(-2, -1)
        if explain:
            None
        scores = torch.matmul(q, k) / math.sqrt(dim_k)
        if explain:
            None
        if mask is not None:
            mask = mask.unsqueeze(1)
            if explain:
                None
            scores = scores.masked_fill(mask == 0, -1000000000.0)
        softscores = F.softmax(scores, dim=-1)
        if dropout is not None:
            softscores = dropout(softscores)
        output = torch.matmul(softscores, v)
        return output, scores

    def forward(self, q, k, v, mask=None, explain=False):
        """
        inputs:
            q has shape (batch size, q_sequence length, embedding dimensions)
            k,v have shape (batch size, kv_sequence length, embedding dimensions)
            mask of shape (batch size, 1, kv_sequence length)
            explain: boolean, prints intermediate values if True
        outputs: sequence of vectors, re-represented using attention
            shape (batch size, q_sequence length, embedding dimensions)
        use:
            The encoder layer places the same source vector sequence into q,k,v
            and mask into mask.
            The decoder layer uses this twice, once with decoder inputs as q,k,v
            and target mask as mask. then with decoder inputs as q, encoder outputs
            as k, v and source mask as mask
        """
        batch_size = q.size(0)
        q = self.q_linear(q)
        k = self.k_linear(k)
        v = self.v_linear(v)
        if explain:
            None
        k = k.view(batch_size, -1, self.num_heads, self.dim_k)
        q = q.view(batch_size, -1, self.num_heads, self.dim_k)
        v = v.view(batch_size, -1, self.num_heads, self.dim_k)
        k = k.transpose(1, 2)
        q = q.transpose(1, 2)
        v = v.transpose(1, 2)
        if explain:
            None
        attn, scores = self.attention(q, k, v, self.dim_k, mask, self.
            dropout, explain)
        if explain:
            None
        concat = attn.transpose(1, 2).contiguous().view(batch_size, -1, 
            self.dim_k * self.num_heads)
        if explain:
            None
        output = self.out(concat)
        if explain:
            None
        return output, scores


class FeedForward(nn.Module):

    def __init__(self, emb_dim, ff_dim=2048, dropout=0.1):
        super().__init__()
        self.linear_1 = nn.Linear(emb_dim, ff_dim)
        self.dropout = nn.Dropout(dropout)
        self.linear_2 = nn.Linear(ff_dim, emb_dim)

    def forward(self, x):
        x = self.dropout(F.leaky_relu(self.linear_1(x)))
        x = self.linear_2(x)
        return x


class DecoderLayerNew(nn.Module):

    def __init__(self, emb_dim, heads, dropout=0.1):
        super().__init__()
        self.norm_1 = Norm(emb_dim)
        self.norm_2 = Norm(emb_dim)
        self.norm_3 = Norm(emb_dim)
        self.dropout_1 = nn.Dropout(dropout)
        self.dropout_2 = nn.Dropout(dropout)
        self.dropout_3 = nn.Dropout(dropout)
        self.attn_1 = MultiHeadAttention(heads, emb_dim, dropout=dropout)
        self.attn_2 = MultiHeadAttention(heads, emb_dim, dropout=dropout)
        self.ff = FeedForward(emb_dim, dropout=dropout)

    def forward(self, input_0, input_1, input_2, input_3):
        primals_2 = self.norm_1.alpha
        primals_3 = self.norm_1.bias
        primals_5 = self.norm_2.alpha
        primals_7 = self.norm_2.bias
        primals_9 = self.norm_3.alpha
        primals_12 = self.norm_3.bias
        primals_4 = self.attn_1.q_linear.weight
        primals_13 = self.attn_1.q_linear.bias
        primals_6 = self.attn_1.k_linear.weight
        primals_14 = self.attn_1.k_linear.bias
        primals_8 = self.attn_1.v_linear.weight
        primals_16 = self.attn_1.v_linear.bias
        primals_11 = self.attn_1.out.weight
        primals_18 = self.attn_1.out.bias
        primals_15 = self.attn_2.q_linear.weight
        primals_21 = self.attn_2.q_linear.bias
        primals_17 = self.attn_2.k_linear.weight
        primals_24 = self.attn_2.k_linear.bias
        primals_20 = self.attn_2.v_linear.weight
        primals_25 = self.attn_2.v_linear.bias
        primals_23 = self.attn_2.out.weight
        primals_26 = self.attn_2.out.bias
        primals_27 = self.ff.linear_1.weight
        primals_28 = self.ff.linear_1.bias
        primals_29 = self.ff.linear_2.weight
        primals_30 = self.ff.linear_2.bias
        primals_1 = input_0
        primals_10 = input_1
        primals_19 = input_2
        primals_22 = input_3
        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])
        return output[0]


Measured latency_ms: 0.015975