import torch
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 import Tensor
from torch import nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda


@triton.jit
def triton_red_fused_mean_0(in_ptr0, out_ptr0, xnumel, rnumel, XBLOCK: tl.
    constexpr, RBLOCK: tl.constexpr):
    xnumel = 5776
    rnumel = 484
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rbase = tl.arange(0, RBLOCK)[None, :]
    x0 = xindex % 1444
    x1 = xindex // 1444
    _tmp11 = tl.full([XBLOCK, RBLOCK], 0, tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r2 = rindex
        tmp0 = 11 * (x0 // 38) + r2 // 11 % 11
        tmp1 = tmp0.to(tl.float32)
        tmp2 = 0.009569377990430622
        tmp3 = tmp1 * tmp2
        tmp4 = tmp3.to(tl.int32)
        tmp5 = 11 * (x0 % 38) + r2 % 11
        tmp6 = tmp5.to(tl.float32)
        tmp7 = tmp6 * tmp2
        tmp8 = tmp7.to(tl.int32)
        tmp9 = tl.load(in_ptr0 + (tmp8 + 4 * tmp4 + 16 * (r2 // 121) + 64 *
            x1), rmask & xmask, eviction_policy='evict_last', other=0.0)
        tmp10 = tl.broadcast_to(tmp9, [XBLOCK, RBLOCK])
        tmp12 = _tmp11 + tmp10
        _tmp11 = tl.where(rmask & xmask, tmp12, _tmp11)
    tmp11 = tl.sum(_tmp11, 1)[:, None]
    tl.store(out_ptr0 + (x0 + 1472 * x1), tmp11, xmask)


@triton.jit
def triton_red_fused__to_copy_eq_gt_mean_1(in_out_ptr0, in_ptr0, in_ptr1,
    xnumel, rnumel, XBLOCK: tl.constexpr, RBLOCK: tl.constexpr):
    rnumel = 5776
    xoffset = tl.program_id(0) * XBLOCK
    xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    rbase = tl.arange(0, RBLOCK)[None, :]
    _tmp13 = tl.full([XBLOCK, RBLOCK], 0, tl.float32)
    for roffset in range(0, rnumel, RBLOCK):
        rindex = roffset + rbase
        rmask = rindex < rnumel
        r0 = rindex % 1444
        r1 = rindex // 1444
        tmp0 = tl.load(in_ptr0 + (r0 + 1472 * r1), rmask, eviction_policy=
            'evict_first', other=0.0)
        tmp6 = tl.load(in_ptr1 + (r0 + 1472 * r1), rmask, eviction_policy=
            'evict_first', other=0.0)
        tmp1 = 484.0
        tmp2 = tmp0 / tmp1
        tmp3 = 0.25
        tmp4 = tmp2 > tmp3
        tmp5 = tmp4.to(tl.float32)
        tmp7 = tmp6 / tmp1
        tmp8 = tmp7 > tmp3
        tmp9 = tmp8.to(tl.float32)
        tmp10 = tmp5 == tmp9
        tmp11 = tmp10.to(tl.float32)
        tmp12 = tl.broadcast_to(tmp11, [XBLOCK, RBLOCK])
        tmp14 = _tmp13 + tmp12
        _tmp13 = tl.where(rmask, tmp14, _tmp13)
    tmp13 = tl.sum(_tmp13, 1)[:, None]
    tmp15 = 5776.0
    tmp16 = tmp13 / tmp15
    tl.debug_barrier()
    tl.store(in_out_ptr0 + tl.full([XBLOCK, 1], 0, tl.int32), tmp16, None)


def call(args):
    arg0_1, arg1_1 = args
    args.clear()
    assert_size_stride(arg0_1, (4, 4, 4, 4), (64, 16, 4, 1))
    assert_size_stride(arg1_1, (4, 4, 4, 4), (64, 16, 4, 1))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4, 1444), (1472, 1), torch.float32)
        get_raw_stream(0)
        triton_red_fused_mean_0[grid(5776)](arg0_1, buf0, 5776, 484, XBLOCK
            =64, RBLOCK=64, num_warps=16, num_stages=1)
        del arg0_1
        buf1 = empty_strided_cuda((4, 1444), (1472, 1), torch.float32)
        triton_red_fused_mean_0[grid(5776)](arg1_1, buf1, 5776, 484, XBLOCK
            =64, RBLOCK=64, num_warps=16, num_stages=1)
        del arg1_1
        buf2 = empty_strided_cuda((), (), torch.float32)
        buf3 = buf2
        del buf2
        triton_red_fused__to_copy_eq_gt_mean_1[grid(1)](buf3, buf0, buf1, 1,
            5776, XBLOCK=1, RBLOCK=2048, num_warps=16, num_stages=1)
        del buf0
        del buf1
    return buf3,


class KaggleAccuracyNew(nn.Module):

    def __init__(self, threshold: 'float'=0.25, num_patches: 'int'=38, size:
        'int'=418) ->None:
        super().__init__()
        self.threshold = threshold
        self.num_patches = num_patches
        self.patch_size = size // num_patches
        self.resize = nn.Upsample(size=size)
        self.unfold = nn.Unfold(kernel_size=self.patch_size, stride=self.
            patch_size)

    def to_patch_value(self, x: 'Tensor') ->Tensor:
        x = x.float()
        x = self.resize(x)
        x = self.unfold(x)
        x = x.mean(dim=1)
        return (x > self.threshold).float()

    def forward(self, input_0, input_1):
        arg0_1 = input_0
        arg1_1 = input_1
        output = call([arg0_1, arg1_1])
        return output[0]


Measured latency_ms: 0.043328