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._inductor.runtime import triton_helpers
import numpy as np
from torch import nn
import torch.jit
import torch.nn.functional as F
import torch.nn.functional
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda


@triton.jit
def triton_poi_fused_neg_0(in_ptr0, out_ptr0, out_ptr1, out_ptr2, out_ptr3,
    out_ptr4, out_ptr5, 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, xmask)
    tmp1 = -tmp0
    tl.store(out_ptr0 + x0, tmp1, xmask)
    tl.store(out_ptr1 + x0, tmp1, xmask)
    tl.store(out_ptr2 + x0, tmp1, xmask)
    tl.store(out_ptr3 + x0, tmp1, xmask)
    tl.store(out_ptr4 + x0, tmp1, xmask)
    tl.store(out_ptr5 + x0, tmp1, xmask)


@triton.jit
def triton_poi_fused_minimum_neg_1(in_out_ptr0, in_ptr0, in_ptr1, 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, xmask)
    tmp2 = tl.load(in_out_ptr0 + x0, xmask)
    tmp5 = tl.load(in_ptr1 + x0, xmask)
    tmp1 = -tmp0
    tmp3 = -tmp2
    tmp4 = triton_helpers.minimum(tmp1, tmp3)
    tmp6 = -tmp5
    tmp7 = triton_helpers.minimum(tmp4, tmp6)
    tl.store(in_out_ptr0 + x0, tmp7, xmask)


@triton.jit
def triton_poi_fused_minimum_neg_2(in_ptr0, in_ptr1, in_ptr2, out_ptr0,
    out_ptr1, out_ptr2, out_ptr3, out_ptr4, out_ptr5, 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, xmask)
    tmp2 = tl.load(in_ptr1 + x0, xmask)
    tmp5 = tl.load(in_ptr2 + x0, xmask)
    tmp1 = -tmp0
    tmp3 = -tmp2
    tmp4 = triton_helpers.minimum(tmp1, tmp3)
    tmp6 = -tmp5
    tmp7 = triton_helpers.minimum(tmp4, tmp6)
    tmp8 = -tmp7
    tl.store(out_ptr0 + x0, tmp8, xmask)
    tl.store(out_ptr1 + x0, tmp8, xmask)
    tl.store(out_ptr2 + x0, tmp8, xmask)
    tl.store(out_ptr3 + x0, tmp8, xmask)
    tl.store(out_ptr4 + x0, tmp8, xmask)
    tl.store(out_ptr5 + x0, tmp8, xmask)


@triton.jit
def triton_poi_fused_minimum_neg_3(in_out_ptr0, in_ptr0, in_ptr1, 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_out_ptr0 + x0, xmask)
    tmp2 = tl.load(in_ptr0 + x0, xmask)
    tmp5 = tl.load(in_ptr1 + x0, xmask)
    tmp1 = -tmp0
    tmp3 = -tmp2
    tmp4 = triton_helpers.minimum(tmp1, tmp3)
    tmp6 = -tmp5
    tmp7 = triton_helpers.minimum(tmp4, tmp6)
    tl.store(in_out_ptr0 + x0, tmp7, xmask)


@triton.jit
def triton_poi_fused_minimum_neg_4(in_ptr0, in_ptr1, in_ptr2, out_ptr0,
    out_ptr1, out_ptr2, 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, xmask)
    tmp2 = tl.load(in_ptr1 + x0, xmask)
    tmp5 = tl.load(in_ptr2 + x0, xmask)
    tmp1 = -tmp0
    tmp3 = -tmp2
    tmp4 = triton_helpers.minimum(tmp1, tmp3)
    tmp6 = -tmp5
    tmp7 = triton_helpers.minimum(tmp4, tmp6)
    tmp8 = -tmp7
    tl.store(out_ptr0 + x0, tmp8, xmask)
    tl.store(out_ptr1 + x0, tmp8, xmask)
    tl.store(out_ptr2 + x0, tmp8, xmask)


@triton.jit
def triton_poi_fused_add_minimum_mul_neg_relu_sub_5(in_out_ptr0,
    in_out_ptr1, in_out_ptr2, in_out_ptr3, in_out_ptr4, in_out_ptr5,
    in_out_ptr6, in_out_ptr7, in_out_ptr8, in_out_ptr9, in_out_ptr10,
    in_out_ptr11, in_out_ptr12, in_out_ptr13, in_out_ptr14, in_out_ptr15,
    in_out_ptr16, in_out_ptr17, in_out_ptr18, in_out_ptr19, in_out_ptr20,
    in_out_ptr21, in_out_ptr22, in_out_ptr23, in_out_ptr24, in_out_ptr25,
    in_out_ptr26, in_out_ptr27, in_out_ptr28, in_out_ptr29, in_out_ptr30,
    in_out_ptr31, in_out_ptr32, in_out_ptr33, in_out_ptr34, in_out_ptr35,
    in_out_ptr36, in_out_ptr37, in_out_ptr38, in_out_ptr39, in_out_ptr40,
    in_out_ptr41, in_out_ptr42, in_out_ptr43, in_out_ptr44, in_out_ptr45,
    in_out_ptr46, in_out_ptr47, in_out_ptr48, in_out_ptr49, in_ptr0,
    in_ptr1, in_ptr2, in_ptr3, in_ptr4, in_ptr5, in_ptr6, in_ptr7, in_ptr8,
    in_ptr9, in_ptr10, in_ptr11, in_ptr12, in_ptr13, in_ptr14, in_ptr15,
    in_ptr16, in_ptr17, in_ptr18, in_ptr19, in_ptr20, in_ptr21, in_ptr22,
    in_ptr23, in_ptr24, in_ptr25, in_ptr26, in_ptr27, in_ptr28, in_ptr29,
    in_ptr30, in_ptr31, in_ptr32, in_ptr33, in_ptr34, in_ptr35, in_ptr36,
    in_ptr37, in_ptr38, in_ptr39, in_ptr40, in_ptr41, in_ptr42, in_ptr43,
    in_ptr44, in_ptr45, in_ptr46, in_ptr47, in_ptr48, in_ptr49, in_ptr50,
    in_ptr51, in_ptr52, in_ptr53, in_ptr54, in_ptr55, in_ptr56, in_ptr57,
    in_ptr58, in_ptr59, in_ptr60, in_ptr61, in_ptr62, in_ptr63, in_ptr64,
    in_ptr65, in_ptr66, in_ptr67, in_ptr68, in_ptr69, in_ptr70, in_ptr71,
    in_ptr72, in_ptr73, in_ptr74, in_ptr75, in_ptr76, in_ptr77, in_ptr78,
    in_ptr79, in_ptr80, in_ptr81, in_ptr82, in_ptr83, in_ptr84, in_ptr85,
    in_ptr86, in_ptr87, in_ptr88, in_ptr89, in_ptr90, in_ptr91, in_ptr92,
    in_ptr93, in_ptr94, in_ptr95, in_ptr96, in_ptr97, in_ptr98, in_ptr99,
    in_ptr100, in_ptr101, in_ptr102, in_ptr103, in_ptr104, in_ptr105,
    in_ptr106, in_ptr107, in_ptr108, in_ptr109, in_ptr110, in_ptr111,
    in_ptr112, in_ptr113, in_ptr114, in_ptr115, in_ptr116, in_ptr117,
    in_ptr118, in_ptr119, in_ptr120, in_ptr121, in_ptr122, in_ptr123,
    in_ptr124, in_ptr125, in_ptr126, in_ptr127, in_ptr128, in_ptr129,
    in_ptr130, in_ptr131, in_ptr132, in_ptr133, in_ptr134, in_ptr135,
    in_ptr136, in_ptr137, in_ptr138, in_ptr139, in_ptr140, in_ptr141,
    in_ptr142, in_ptr143, in_ptr144, in_ptr145, in_ptr146, in_ptr147,
    in_ptr148, in_ptr149, in_ptr150, in_ptr151, 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, xmask)
    tmp1 = tl.load(in_out_ptr0 + x0, xmask)
    tmp5 = tl.load(in_ptr1 + x0, xmask)
    tmp7 = tl.load(in_ptr2 + x0, xmask)
    tmp10 = tl.load(in_ptr3 + x0, xmask)
    tmp13 = tl.load(in_ptr4 + x0, xmask)
    tmp20 = tl.load(in_out_ptr1 + x0, xmask)
    tmp22 = tl.load(in_ptr5 + x0, xmask)
    tmp25 = tl.load(in_ptr6 + x0, xmask)
    tmp28 = tl.load(in_ptr7 + x0, xmask)
    tmp35 = tl.load(in_out_ptr2 + x0, xmask)
    tmp37 = tl.load(in_ptr8 + x0, xmask)
    tmp40 = tl.load(in_ptr9 + x0, xmask)
    tmp43 = tl.load(in_ptr10 + x0, xmask)
    tmp50 = tl.load(in_out_ptr3 + x0, xmask)
    tmp52 = tl.load(in_ptr11 + x0, xmask)
    tmp55 = tl.load(in_ptr12 + x0, xmask)
    tmp58 = tl.load(in_ptr13 + x0, xmask)
    tmp65 = tl.load(in_out_ptr4 + x0, xmask)
    tmp67 = tl.load(in_ptr14 + x0, xmask)
    tmp70 = tl.load(in_ptr15 + x0, xmask)
    tmp73 = tl.load(in_ptr16 + x0, xmask)
    tmp80 = tl.load(in_out_ptr5 + x0, xmask)
    tmp82 = tl.load(in_ptr17 + x0, xmask)
    tmp85 = tl.load(in_ptr18 + x0, xmask)
    tmp88 = tl.load(in_ptr19 + x0, xmask)
    tmp95 = tl.load(in_out_ptr6 + x0, xmask)
    tmp97 = tl.load(in_ptr20 + x0, xmask)
    tmp100 = tl.load(in_ptr21 + x0, xmask)
    tmp103 = tl.load(in_ptr22 + x0, xmask)
    tmp110 = tl.load(in_out_ptr7 + x0, xmask)
    tmp112 = tl.load(in_ptr23 + x0, xmask)
    tmp115 = tl.load(in_ptr24 + x0, xmask)
    tmp118 = tl.load(in_ptr25 + x0, xmask)
    tmp125 = tl.load(in_out_ptr8 + x0, xmask)
    tmp127 = tl.load(in_ptr26 + x0, xmask)
    tmp130 = tl.load(in_ptr27 + x0, xmask)
    tmp133 = tl.load(in_ptr28 + x0, xmask)
    tmp140 = tl.load(in_out_ptr9 + x0, xmask)
    tmp142 = tl.load(in_ptr29 + x0, xmask)
    tmp145 = tl.load(in_ptr30 + x0, xmask)
    tmp148 = tl.load(in_ptr31 + x0, xmask)
    tmp155 = tl.load(in_out_ptr10 + x0, xmask)
    tmp157 = tl.load(in_ptr32 + x0, xmask)
    tmp160 = tl.load(in_ptr33 + x0, xmask)
    tmp163 = tl.load(in_ptr34 + x0, xmask)
    tmp170 = tl.load(in_out_ptr11 + x0, xmask)
    tmp172 = tl.load(in_ptr35 + x0, xmask)
    tmp175 = tl.load(in_ptr36 + x0, xmask)
    tmp178 = tl.load(in_ptr37 + x0, xmask)
    tmp185 = tl.load(in_out_ptr12 + x0, xmask)
    tmp187 = tl.load(in_ptr38 + x0, xmask)
    tmp190 = tl.load(in_ptr39 + x0, xmask)
    tmp193 = tl.load(in_ptr40 + x0, xmask)
    tmp200 = tl.load(in_out_ptr13 + x0, xmask)
    tmp202 = tl.load(in_ptr41 + x0, xmask)
    tmp205 = tl.load(in_ptr42 + x0, xmask)
    tmp208 = tl.load(in_ptr43 + x0, xmask)
    tmp215 = tl.load(in_out_ptr14 + x0, xmask)
    tmp217 = tl.load(in_ptr44 + x0, xmask)
    tmp220 = tl.load(in_ptr45 + x0, xmask)
    tmp223 = tl.load(in_ptr46 + x0, xmask)
    tmp230 = tl.load(in_out_ptr15 + x0, xmask)
    tmp232 = tl.load(in_ptr47 + x0, xmask)
    tmp235 = tl.load(in_ptr48 + x0, xmask)
    tmp238 = tl.load(in_ptr49 + x0, xmask)
    tmp245 = tl.load(in_out_ptr16 + x0, xmask)
    tmp247 = tl.load(in_ptr50 + x0, xmask)
    tmp250 = tl.load(in_ptr51 + x0, xmask)
    tmp253 = tl.load(in_ptr52 + x0, xmask)
    tmp260 = tl.load(in_out_ptr17 + x0, xmask)
    tmp262 = tl.load(in_ptr53 + x0, xmask)
    tmp265 = tl.load(in_ptr54 + x0, xmask)
    tmp268 = tl.load(in_ptr55 + x0, xmask)
    tmp275 = tl.load(in_out_ptr18 + x0, xmask)
    tmp277 = tl.load(in_ptr56 + x0, xmask)
    tmp280 = tl.load(in_ptr57 + x0, xmask)
    tmp283 = tl.load(in_ptr58 + x0, xmask)
    tmp290 = tl.load(in_out_ptr19 + x0, xmask)
    tmp292 = tl.load(in_ptr59 + x0, xmask)
    tmp295 = tl.load(in_ptr60 + x0, xmask)
    tmp298 = tl.load(in_ptr61 + x0, xmask)
    tmp305 = tl.load(in_out_ptr20 + x0, xmask)
    tmp307 = tl.load(in_ptr62 + x0, xmask)
    tmp310 = tl.load(in_ptr63 + x0, xmask)
    tmp313 = tl.load(in_ptr64 + x0, xmask)
    tmp320 = tl.load(in_out_ptr21 + x0, xmask)
    tmp322 = tl.load(in_ptr65 + x0, xmask)
    tmp325 = tl.load(in_ptr66 + x0, xmask)
    tmp328 = tl.load(in_ptr67 + x0, xmask)
    tmp335 = tl.load(in_out_ptr22 + x0, xmask)
    tmp337 = tl.load(in_ptr68 + x0, xmask)
    tmp340 = tl.load(in_ptr69 + x0, xmask)
    tmp343 = tl.load(in_ptr70 + x0, xmask)
    tmp350 = tl.load(in_out_ptr23 + x0, xmask)
    tmp352 = tl.load(in_ptr71 + x0, xmask)
    tmp355 = tl.load(in_ptr72 + x0, xmask)
    tmp358 = tl.load(in_ptr73 + x0, xmask)
    tmp365 = tl.load(in_out_ptr24 + x0, xmask)
    tmp367 = tl.load(in_ptr74 + x0, xmask)
    tmp370 = tl.load(in_ptr75 + x0, xmask)
    tmp373 = tl.load(in_ptr76 + x0, xmask)
    tmp380 = tl.load(in_out_ptr25 + x0, xmask)
    tmp382 = tl.load(in_ptr77 + x0, xmask)
    tmp385 = tl.load(in_ptr78 + x0, xmask)
    tmp388 = tl.load(in_ptr79 + x0, xmask)
    tmp395 = tl.load(in_out_ptr26 + x0, xmask)
    tmp397 = tl.load(in_ptr80 + x0, xmask)
    tmp400 = tl.load(in_ptr81 + x0, xmask)
    tmp403 = tl.load(in_ptr82 + x0, xmask)
    tmp410 = tl.load(in_out_ptr27 + x0, xmask)
    tmp412 = tl.load(in_ptr83 + x0, xmask)
    tmp415 = tl.load(in_ptr84 + x0, xmask)
    tmp418 = tl.load(in_ptr85 + x0, xmask)
    tmp425 = tl.load(in_out_ptr28 + x0, xmask)
    tmp427 = tl.load(in_ptr86 + x0, xmask)
    tmp430 = tl.load(in_ptr87 + x0, xmask)
    tmp433 = tl.load(in_ptr88 + x0, xmask)
    tmp440 = tl.load(in_out_ptr29 + x0, xmask)
    tmp442 = tl.load(in_ptr89 + x0, xmask)
    tmp445 = tl.load(in_ptr90 + x0, xmask)
    tmp448 = tl.load(in_ptr91 + x0, xmask)
    tmp455 = tl.load(in_out_ptr30 + x0, xmask)
    tmp457 = tl.load(in_ptr92 + x0, xmask)
    tmp460 = tl.load(in_ptr93 + x0, xmask)
    tmp463 = tl.load(in_ptr94 + x0, xmask)
    tmp470 = tl.load(in_out_ptr31 + x0, xmask)
    tmp472 = tl.load(in_ptr95 + x0, xmask)
    tmp475 = tl.load(in_ptr96 + x0, xmask)
    tmp478 = tl.load(in_ptr97 + x0, xmask)
    tmp485 = tl.load(in_out_ptr32 + x0, xmask)
    tmp487 = tl.load(in_ptr98 + x0, xmask)
    tmp490 = tl.load(in_ptr99 + x0, xmask)
    tmp493 = tl.load(in_ptr100 + x0, xmask)
    tmp500 = tl.load(in_out_ptr33 + x0, xmask)
    tmp502 = tl.load(in_ptr101 + x0, xmask)
    tmp505 = tl.load(in_ptr102 + x0, xmask)
    tmp508 = tl.load(in_ptr103 + x0, xmask)
    tmp515 = tl.load(in_out_ptr34 + x0, xmask)
    tmp517 = tl.load(in_ptr104 + x0, xmask)
    tmp520 = tl.load(in_ptr105 + x0, xmask)
    tmp523 = tl.load(in_ptr106 + x0, xmask)
    tmp530 = tl.load(in_out_ptr35 + x0, xmask)
    tmp532 = tl.load(in_ptr107 + x0, xmask)
    tmp535 = tl.load(in_ptr108 + x0, xmask)
    tmp538 = tl.load(in_ptr109 + x0, xmask)
    tmp545 = tl.load(in_out_ptr36 + x0, xmask)
    tmp547 = tl.load(in_ptr110 + x0, xmask)
    tmp550 = tl.load(in_ptr111 + x0, xmask)
    tmp553 = tl.load(in_ptr112 + x0, xmask)
    tmp560 = tl.load(in_out_ptr37 + x0, xmask)
    tmp562 = tl.load(in_ptr113 + x0, xmask)
    tmp565 = tl.load(in_ptr114 + x0, xmask)
    tmp568 = tl.load(in_ptr115 + x0, xmask)
    tmp575 = tl.load(in_out_ptr38 + x0, xmask)
    tmp577 = tl.load(in_ptr116 + x0, xmask)
    tmp580 = tl.load(in_ptr117 + x0, xmask)
    tmp583 = tl.load(in_ptr118 + x0, xmask)
    tmp590 = tl.load(in_out_ptr39 + x0, xmask)
    tmp592 = tl.load(in_ptr119 + x0, xmask)
    tmp595 = tl.load(in_ptr120 + x0, xmask)
    tmp598 = tl.load(in_ptr121 + x0, xmask)
    tmp605 = tl.load(in_out_ptr40 + x0, xmask)
    tmp607 = tl.load(in_ptr122 + x0, xmask)
    tmp610 = tl.load(in_ptr123 + x0, xmask)
    tmp613 = tl.load(in_ptr124 + x0, xmask)
    tmp620 = tl.load(in_out_ptr41 + x0, xmask)
    tmp622 = tl.load(in_ptr125 + x0, xmask)
    tmp625 = tl.load(in_ptr126 + x0, xmask)
    tmp628 = tl.load(in_ptr127 + x0, xmask)
    tmp635 = tl.load(in_out_ptr42 + x0, xmask)
    tmp637 = tl.load(in_ptr128 + x0, xmask)
    tmp640 = tl.load(in_ptr129 + x0, xmask)
    tmp643 = tl.load(in_ptr130 + x0, xmask)
    tmp650 = tl.load(in_out_ptr43 + x0, xmask)
    tmp652 = tl.load(in_ptr131 + x0, xmask)
    tmp655 = tl.load(in_ptr132 + x0, xmask)
    tmp658 = tl.load(in_ptr133 + x0, xmask)
    tmp665 = tl.load(in_out_ptr44 + x0, xmask)
    tmp667 = tl.load(in_ptr134 + x0, xmask)
    tmp670 = tl.load(in_ptr135 + x0, xmask)
    tmp673 = tl.load(in_ptr136 + x0, xmask)
    tmp680 = tl.load(in_out_ptr45 + x0, xmask)
    tmp682 = tl.load(in_ptr137 + x0, xmask)
    tmp685 = tl.load(in_ptr138 + x0, xmask)
    tmp688 = tl.load(in_ptr139 + x0, xmask)
    tmp695 = tl.load(in_out_ptr46 + x0, xmask)
    tmp697 = tl.load(in_ptr140 + x0, xmask)
    tmp700 = tl.load(in_ptr141 + x0, xmask)
    tmp703 = tl.load(in_ptr142 + x0, xmask)
    tmp710 = tl.load(in_out_ptr47 + x0, xmask)
    tmp712 = tl.load(in_ptr143 + x0, xmask)
    tmp715 = tl.load(in_ptr144 + x0, xmask)
    tmp718 = tl.load(in_ptr145 + x0, xmask)
    tmp725 = tl.load(in_out_ptr48 + x0, xmask)
    tmp727 = tl.load(in_ptr146 + x0, xmask)
    tmp730 = tl.load(in_ptr147 + x0, xmask)
    tmp733 = tl.load(in_ptr148 + x0, xmask)
    tmp740 = tl.load(in_out_ptr49 + x0, xmask)
    tmp742 = tl.load(in_ptr149 + x0, xmask)
    tmp745 = tl.load(in_ptr150 + x0, xmask)
    tmp748 = tl.load(in_ptr151 + x0, xmask)
    tmp2 = tmp0 - tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp6 = -tmp5
    tmp8 = -tmp7
    tmp9 = triton_helpers.minimum(tmp6, tmp8)
    tmp11 = -tmp10
    tmp12 = triton_helpers.minimum(tmp9, tmp11)
    tmp14 = tmp12 - tmp13
    tmp15 = triton_helpers.maximum(tmp3, tmp14)
    tmp16 = tmp4 * tmp15
    tmp17 = tmp15 - tmp16
    tmp18 = triton_helpers.maximum(tmp3, tmp17)
    tmp19 = tmp4 + tmp18
    tmp21 = -tmp20
    tmp23 = -tmp22
    tmp24 = triton_helpers.minimum(tmp21, tmp23)
    tmp26 = -tmp25
    tmp27 = triton_helpers.minimum(tmp24, tmp26)
    tmp29 = tmp27 - tmp28
    tmp30 = triton_helpers.maximum(tmp3, tmp29)
    tmp31 = tmp19 * tmp30
    tmp32 = tmp30 - tmp31
    tmp33 = triton_helpers.maximum(tmp3, tmp32)
    tmp34 = tmp19 + tmp33
    tmp36 = -tmp35
    tmp38 = -tmp37
    tmp39 = triton_helpers.minimum(tmp36, tmp38)
    tmp41 = -tmp40
    tmp42 = triton_helpers.minimum(tmp39, tmp41)
    tmp44 = tmp42 - tmp43
    tmp45 = triton_helpers.maximum(tmp3, tmp44)
    tmp46 = tmp34 * tmp45
    tmp47 = tmp45 - tmp46
    tmp48 = triton_helpers.maximum(tmp3, tmp47)
    tmp49 = tmp34 + tmp48
    tmp51 = -tmp50
    tmp53 = -tmp52
    tmp54 = triton_helpers.minimum(tmp51, tmp53)
    tmp56 = -tmp55
    tmp57 = triton_helpers.minimum(tmp54, tmp56)
    tmp59 = tmp57 - tmp58
    tmp60 = triton_helpers.maximum(tmp3, tmp59)
    tmp61 = tmp49 * tmp60
    tmp62 = tmp60 - tmp61
    tmp63 = triton_helpers.maximum(tmp3, tmp62)
    tmp64 = tmp49 + tmp63
    tmp66 = -tmp65
    tmp68 = -tmp67
    tmp69 = triton_helpers.minimum(tmp66, tmp68)
    tmp71 = -tmp70
    tmp72 = triton_helpers.minimum(tmp69, tmp71)
    tmp74 = tmp72 - tmp73
    tmp75 = triton_helpers.maximum(tmp3, tmp74)
    tmp76 = tmp64 * tmp75
    tmp77 = tmp75 - tmp76
    tmp78 = triton_helpers.maximum(tmp3, tmp77)
    tmp79 = tmp64 + tmp78
    tmp81 = -tmp80
    tmp83 = -tmp82
    tmp84 = triton_helpers.minimum(tmp81, tmp83)
    tmp86 = -tmp85
    tmp87 = triton_helpers.minimum(tmp84, tmp86)
    tmp89 = tmp87 - tmp88
    tmp90 = triton_helpers.maximum(tmp3, tmp89)
    tmp91 = tmp79 * tmp90
    tmp92 = tmp90 - tmp91
    tmp93 = triton_helpers.maximum(tmp3, tmp92)
    tmp94 = tmp79 + tmp93
    tmp96 = -tmp95
    tmp98 = -tmp97
    tmp99 = triton_helpers.minimum(tmp96, tmp98)
    tmp101 = -tmp100
    tmp102 = triton_helpers.minimum(tmp99, tmp101)
    tmp104 = tmp102 - tmp103
    tmp105 = triton_helpers.maximum(tmp3, tmp104)
    tmp106 = tmp94 * tmp105
    tmp107 = tmp105 - tmp106
    tmp108 = triton_helpers.maximum(tmp3, tmp107)
    tmp109 = tmp94 + tmp108
    tmp111 = -tmp110
    tmp113 = -tmp112
    tmp114 = triton_helpers.minimum(tmp111, tmp113)
    tmp116 = -tmp115
    tmp117 = triton_helpers.minimum(tmp114, tmp116)
    tmp119 = tmp117 - tmp118
    tmp120 = triton_helpers.maximum(tmp3, tmp119)
    tmp121 = tmp109 * tmp120
    tmp122 = tmp120 - tmp121
    tmp123 = triton_helpers.maximum(tmp3, tmp122)
    tmp124 = tmp109 + tmp123
    tmp126 = -tmp125
    tmp128 = -tmp127
    tmp129 = triton_helpers.minimum(tmp126, tmp128)
    tmp131 = -tmp130
    tmp132 = triton_helpers.minimum(tmp129, tmp131)
    tmp134 = tmp132 - tmp133
    tmp135 = triton_helpers.maximum(tmp3, tmp134)
    tmp136 = tmp124 * tmp135
    tmp137 = tmp135 - tmp136
    tmp138 = triton_helpers.maximum(tmp3, tmp137)
    tmp139 = tmp124 + tmp138
    tmp141 = -tmp140
    tmp143 = -tmp142
    tmp144 = triton_helpers.minimum(tmp141, tmp143)
    tmp146 = -tmp145
    tmp147 = triton_helpers.minimum(tmp144, tmp146)
    tmp149 = tmp147 - tmp148
    tmp150 = triton_helpers.maximum(tmp3, tmp149)
    tmp151 = tmp139 * tmp150
    tmp152 = tmp150 - tmp151
    tmp153 = triton_helpers.maximum(tmp3, tmp152)
    tmp154 = tmp139 + tmp153
    tmp156 = -tmp155
    tmp158 = -tmp157
    tmp159 = triton_helpers.minimum(tmp156, tmp158)
    tmp161 = -tmp160
    tmp162 = triton_helpers.minimum(tmp159, tmp161)
    tmp164 = tmp162 - tmp163
    tmp165 = triton_helpers.maximum(tmp3, tmp164)
    tmp166 = tmp154 * tmp165
    tmp167 = tmp165 - tmp166
    tmp168 = triton_helpers.maximum(tmp3, tmp167)
    tmp169 = tmp154 + tmp168
    tmp171 = -tmp170
    tmp173 = -tmp172
    tmp174 = triton_helpers.minimum(tmp171, tmp173)
    tmp176 = -tmp175
    tmp177 = triton_helpers.minimum(tmp174, tmp176)
    tmp179 = tmp177 - tmp178
    tmp180 = triton_helpers.maximum(tmp3, tmp179)
    tmp181 = tmp169 * tmp180
    tmp182 = tmp180 - tmp181
    tmp183 = triton_helpers.maximum(tmp3, tmp182)
    tmp184 = tmp169 + tmp183
    tmp186 = -tmp185
    tmp188 = -tmp187
    tmp189 = triton_helpers.minimum(tmp186, tmp188)
    tmp191 = -tmp190
    tmp192 = triton_helpers.minimum(tmp189, tmp191)
    tmp194 = tmp192 - tmp193
    tmp195 = triton_helpers.maximum(tmp3, tmp194)
    tmp196 = tmp184 * tmp195
    tmp197 = tmp195 - tmp196
    tmp198 = triton_helpers.maximum(tmp3, tmp197)
    tmp199 = tmp184 + tmp198
    tmp201 = -tmp200
    tmp203 = -tmp202
    tmp204 = triton_helpers.minimum(tmp201, tmp203)
    tmp206 = -tmp205
    tmp207 = triton_helpers.minimum(tmp204, tmp206)
    tmp209 = tmp207 - tmp208
    tmp210 = triton_helpers.maximum(tmp3, tmp209)
    tmp211 = tmp199 * tmp210
    tmp212 = tmp210 - tmp211
    tmp213 = triton_helpers.maximum(tmp3, tmp212)
    tmp214 = tmp199 + tmp213
    tmp216 = -tmp215
    tmp218 = -tmp217
    tmp219 = triton_helpers.minimum(tmp216, tmp218)
    tmp221 = -tmp220
    tmp222 = triton_helpers.minimum(tmp219, tmp221)
    tmp224 = tmp222 - tmp223
    tmp225 = triton_helpers.maximum(tmp3, tmp224)
    tmp226 = tmp214 * tmp225
    tmp227 = tmp225 - tmp226
    tmp228 = triton_helpers.maximum(tmp3, tmp227)
    tmp229 = tmp214 + tmp228
    tmp231 = -tmp230
    tmp233 = -tmp232
    tmp234 = triton_helpers.minimum(tmp231, tmp233)
    tmp236 = -tmp235
    tmp237 = triton_helpers.minimum(tmp234, tmp236)
    tmp239 = tmp237 - tmp238
    tmp240 = triton_helpers.maximum(tmp3, tmp239)
    tmp241 = tmp229 * tmp240
    tmp242 = tmp240 - tmp241
    tmp243 = triton_helpers.maximum(tmp3, tmp242)
    tmp244 = tmp229 + tmp243
    tmp246 = -tmp245
    tmp248 = -tmp247
    tmp249 = triton_helpers.minimum(tmp246, tmp248)
    tmp251 = -tmp250
    tmp252 = triton_helpers.minimum(tmp249, tmp251)
    tmp254 = tmp252 - tmp253
    tmp255 = triton_helpers.maximum(tmp3, tmp254)
    tmp256 = tmp244 * tmp255
    tmp257 = tmp255 - tmp256
    tmp258 = triton_helpers.maximum(tmp3, tmp257)
    tmp259 = tmp244 + tmp258
    tmp261 = -tmp260
    tmp263 = -tmp262
    tmp264 = triton_helpers.minimum(tmp261, tmp263)
    tmp266 = -tmp265
    tmp267 = triton_helpers.minimum(tmp264, tmp266)
    tmp269 = tmp267 - tmp268
    tmp270 = triton_helpers.maximum(tmp3, tmp269)
    tmp271 = tmp259 * tmp270
    tmp272 = tmp270 - tmp271
    tmp273 = triton_helpers.maximum(tmp3, tmp272)
    tmp274 = tmp259 + tmp273
    tmp276 = -tmp275
    tmp278 = -tmp277
    tmp279 = triton_helpers.minimum(tmp276, tmp278)
    tmp281 = -tmp280
    tmp282 = triton_helpers.minimum(tmp279, tmp281)
    tmp284 = tmp282 - tmp283
    tmp285 = triton_helpers.maximum(tmp3, tmp284)
    tmp286 = tmp274 * tmp285
    tmp287 = tmp285 - tmp286
    tmp288 = triton_helpers.maximum(tmp3, tmp287)
    tmp289 = tmp274 + tmp288
    tmp291 = -tmp290
    tmp293 = -tmp292
    tmp294 = triton_helpers.minimum(tmp291, tmp293)
    tmp296 = -tmp295
    tmp297 = triton_helpers.minimum(tmp294, tmp296)
    tmp299 = tmp297 - tmp298
    tmp300 = triton_helpers.maximum(tmp3, tmp299)
    tmp301 = tmp289 * tmp300
    tmp302 = tmp300 - tmp301
    tmp303 = triton_helpers.maximum(tmp3, tmp302)
    tmp304 = tmp289 + tmp303
    tmp306 = -tmp305
    tmp308 = -tmp307
    tmp309 = triton_helpers.minimum(tmp306, tmp308)
    tmp311 = -tmp310
    tmp312 = triton_helpers.minimum(tmp309, tmp311)
    tmp314 = tmp312 - tmp313
    tmp315 = triton_helpers.maximum(tmp3, tmp314)
    tmp316 = tmp304 * tmp315
    tmp317 = tmp315 - tmp316
    tmp318 = triton_helpers.maximum(tmp3, tmp317)
    tmp319 = tmp304 + tmp318
    tmp321 = -tmp320
    tmp323 = -tmp322
    tmp324 = triton_helpers.minimum(tmp321, tmp323)
    tmp326 = -tmp325
    tmp327 = triton_helpers.minimum(tmp324, tmp326)
    tmp329 = tmp327 - tmp328
    tmp330 = triton_helpers.maximum(tmp3, tmp329)
    tmp331 = tmp319 * tmp330
    tmp332 = tmp330 - tmp331
    tmp333 = triton_helpers.maximum(tmp3, tmp332)
    tmp334 = tmp319 + tmp333
    tmp336 = -tmp335
    tmp338 = -tmp337
    tmp339 = triton_helpers.minimum(tmp336, tmp338)
    tmp341 = -tmp340
    tmp342 = triton_helpers.minimum(tmp339, tmp341)
    tmp344 = tmp342 - tmp343
    tmp345 = triton_helpers.maximum(tmp3, tmp344)
    tmp346 = tmp334 * tmp345
    tmp347 = tmp345 - tmp346
    tmp348 = triton_helpers.maximum(tmp3, tmp347)
    tmp349 = tmp334 + tmp348
    tmp351 = -tmp350
    tmp353 = -tmp352
    tmp354 = triton_helpers.minimum(tmp351, tmp353)
    tmp356 = -tmp355
    tmp357 = triton_helpers.minimum(tmp354, tmp356)
    tmp359 = tmp357 - tmp358
    tmp360 = triton_helpers.maximum(tmp3, tmp359)
    tmp361 = tmp349 * tmp360
    tmp362 = tmp360 - tmp361
    tmp363 = triton_helpers.maximum(tmp3, tmp362)
    tmp364 = tmp349 + tmp363
    tmp366 = -tmp365
    tmp368 = -tmp367
    tmp369 = triton_helpers.minimum(tmp366, tmp368)
    tmp371 = -tmp370
    tmp372 = triton_helpers.minimum(tmp369, tmp371)
    tmp374 = tmp372 - tmp373
    tmp375 = triton_helpers.maximum(tmp3, tmp374)
    tmp376 = tmp364 * tmp375
    tmp377 = tmp375 - tmp376
    tmp378 = triton_helpers.maximum(tmp3, tmp377)
    tmp379 = tmp364 + tmp378
    tmp381 = -tmp380
    tmp383 = -tmp382
    tmp384 = triton_helpers.minimum(tmp381, tmp383)
    tmp386 = -tmp385
    tmp387 = triton_helpers.minimum(tmp384, tmp386)
    tmp389 = tmp387 - tmp388
    tmp390 = triton_helpers.maximum(tmp3, tmp389)
    tmp391 = tmp379 * tmp390
    tmp392 = tmp390 - tmp391
    tmp393 = triton_helpers.maximum(tmp3, tmp392)
    tmp394 = tmp379 + tmp393
    tmp396 = -tmp395
    tmp398 = -tmp397
    tmp399 = triton_helpers.minimum(tmp396, tmp398)
    tmp401 = -tmp400
    tmp402 = triton_helpers.minimum(tmp399, tmp401)
    tmp404 = tmp402 - tmp403
    tmp405 = triton_helpers.maximum(tmp3, tmp404)
    tmp406 = tmp394 * tmp405
    tmp407 = tmp405 - tmp406
    tmp408 = triton_helpers.maximum(tmp3, tmp407)
    tmp409 = tmp394 + tmp408
    tmp411 = -tmp410
    tmp413 = -tmp412
    tmp414 = triton_helpers.minimum(tmp411, tmp413)
    tmp416 = -tmp415
    tmp417 = triton_helpers.minimum(tmp414, tmp416)
    tmp419 = tmp417 - tmp418
    tmp420 = triton_helpers.maximum(tmp3, tmp419)
    tmp421 = tmp409 * tmp420
    tmp422 = tmp420 - tmp421
    tmp423 = triton_helpers.maximum(tmp3, tmp422)
    tmp424 = tmp409 + tmp423
    tmp426 = -tmp425
    tmp428 = -tmp427
    tmp429 = triton_helpers.minimum(tmp426, tmp428)
    tmp431 = -tmp430
    tmp432 = triton_helpers.minimum(tmp429, tmp431)
    tmp434 = tmp432 - tmp433
    tmp435 = triton_helpers.maximum(tmp3, tmp434)
    tmp436 = tmp424 * tmp435
    tmp437 = tmp435 - tmp436
    tmp438 = triton_helpers.maximum(tmp3, tmp437)
    tmp439 = tmp424 + tmp438
    tmp441 = -tmp440
    tmp443 = -tmp442
    tmp444 = triton_helpers.minimum(tmp441, tmp443)
    tmp446 = -tmp445
    tmp447 = triton_helpers.minimum(tmp444, tmp446)
    tmp449 = tmp447 - tmp448
    tmp450 = triton_helpers.maximum(tmp3, tmp449)
    tmp451 = tmp439 * tmp450
    tmp452 = tmp450 - tmp451
    tmp453 = triton_helpers.maximum(tmp3, tmp452)
    tmp454 = tmp439 + tmp453
    tmp456 = -tmp455
    tmp458 = -tmp457
    tmp459 = triton_helpers.minimum(tmp456, tmp458)
    tmp461 = -tmp460
    tmp462 = triton_helpers.minimum(tmp459, tmp461)
    tmp464 = tmp462 - tmp463
    tmp465 = triton_helpers.maximum(tmp3, tmp464)
    tmp466 = tmp454 * tmp465
    tmp467 = tmp465 - tmp466
    tmp468 = triton_helpers.maximum(tmp3, tmp467)
    tmp469 = tmp454 + tmp468
    tmp471 = -tmp470
    tmp473 = -tmp472
    tmp474 = triton_helpers.minimum(tmp471, tmp473)
    tmp476 = -tmp475
    tmp477 = triton_helpers.minimum(tmp474, tmp476)
    tmp479 = tmp477 - tmp478
    tmp480 = triton_helpers.maximum(tmp3, tmp479)
    tmp481 = tmp469 * tmp480
    tmp482 = tmp480 - tmp481
    tmp483 = triton_helpers.maximum(tmp3, tmp482)
    tmp484 = tmp469 + tmp483
    tmp486 = -tmp485
    tmp488 = -tmp487
    tmp489 = triton_helpers.minimum(tmp486, tmp488)
    tmp491 = -tmp490
    tmp492 = triton_helpers.minimum(tmp489, tmp491)
    tmp494 = tmp492 - tmp493
    tmp495 = triton_helpers.maximum(tmp3, tmp494)
    tmp496 = tmp484 * tmp495
    tmp497 = tmp495 - tmp496
    tmp498 = triton_helpers.maximum(tmp3, tmp497)
    tmp499 = tmp484 + tmp498
    tmp501 = -tmp500
    tmp503 = -tmp502
    tmp504 = triton_helpers.minimum(tmp501, tmp503)
    tmp506 = -tmp505
    tmp507 = triton_helpers.minimum(tmp504, tmp506)
    tmp509 = tmp507 - tmp508
    tmp510 = triton_helpers.maximum(tmp3, tmp509)
    tmp511 = tmp499 * tmp510
    tmp512 = tmp510 - tmp511
    tmp513 = triton_helpers.maximum(tmp3, tmp512)
    tmp514 = tmp499 + tmp513
    tmp516 = -tmp515
    tmp518 = -tmp517
    tmp519 = triton_helpers.minimum(tmp516, tmp518)
    tmp521 = -tmp520
    tmp522 = triton_helpers.minimum(tmp519, tmp521)
    tmp524 = tmp522 - tmp523
    tmp525 = triton_helpers.maximum(tmp3, tmp524)
    tmp526 = tmp514 * tmp525
    tmp527 = tmp525 - tmp526
    tmp528 = triton_helpers.maximum(tmp3, tmp527)
    tmp529 = tmp514 + tmp528
    tmp531 = -tmp530
    tmp533 = -tmp532
    tmp534 = triton_helpers.minimum(tmp531, tmp533)
    tmp536 = -tmp535
    tmp537 = triton_helpers.minimum(tmp534, tmp536)
    tmp539 = tmp537 - tmp538
    tmp540 = triton_helpers.maximum(tmp3, tmp539)
    tmp541 = tmp529 * tmp540
    tmp542 = tmp540 - tmp541
    tmp543 = triton_helpers.maximum(tmp3, tmp542)
    tmp544 = tmp529 + tmp543
    tmp546 = -tmp545
    tmp548 = -tmp547
    tmp549 = triton_helpers.minimum(tmp546, tmp548)
    tmp551 = -tmp550
    tmp552 = triton_helpers.minimum(tmp549, tmp551)
    tmp554 = tmp552 - tmp553
    tmp555 = triton_helpers.maximum(tmp3, tmp554)
    tmp556 = tmp544 * tmp555
    tmp557 = tmp555 - tmp556
    tmp558 = triton_helpers.maximum(tmp3, tmp557)
    tmp559 = tmp544 + tmp558
    tmp561 = -tmp560
    tmp563 = -tmp562
    tmp564 = triton_helpers.minimum(tmp561, tmp563)
    tmp566 = -tmp565
    tmp567 = triton_helpers.minimum(tmp564, tmp566)
    tmp569 = tmp567 - tmp568
    tmp570 = triton_helpers.maximum(tmp3, tmp569)
    tmp571 = tmp559 * tmp570
    tmp572 = tmp570 - tmp571
    tmp573 = triton_helpers.maximum(tmp3, tmp572)
    tmp574 = tmp559 + tmp573
    tmp576 = -tmp575
    tmp578 = -tmp577
    tmp579 = triton_helpers.minimum(tmp576, tmp578)
    tmp581 = -tmp580
    tmp582 = triton_helpers.minimum(tmp579, tmp581)
    tmp584 = tmp582 - tmp583
    tmp585 = triton_helpers.maximum(tmp3, tmp584)
    tmp586 = tmp574 * tmp585
    tmp587 = tmp585 - tmp586
    tmp588 = triton_helpers.maximum(tmp3, tmp587)
    tmp589 = tmp574 + tmp588
    tmp591 = -tmp590
    tmp593 = -tmp592
    tmp594 = triton_helpers.minimum(tmp591, tmp593)
    tmp596 = -tmp595
    tmp597 = triton_helpers.minimum(tmp594, tmp596)
    tmp599 = tmp597 - tmp598
    tmp600 = triton_helpers.maximum(tmp3, tmp599)
    tmp601 = tmp589 * tmp600
    tmp602 = tmp600 - tmp601
    tmp603 = triton_helpers.maximum(tmp3, tmp602)
    tmp604 = tmp589 + tmp603
    tmp606 = -tmp605
    tmp608 = -tmp607
    tmp609 = triton_helpers.minimum(tmp606, tmp608)
    tmp611 = -tmp610
    tmp612 = triton_helpers.minimum(tmp609, tmp611)
    tmp614 = tmp612 - tmp613
    tmp615 = triton_helpers.maximum(tmp3, tmp614)
    tmp616 = tmp604 * tmp615
    tmp617 = tmp615 - tmp616
    tmp618 = triton_helpers.maximum(tmp3, tmp617)
    tmp619 = tmp604 + tmp618
    tmp621 = -tmp620
    tmp623 = -tmp622
    tmp624 = triton_helpers.minimum(tmp621, tmp623)
    tmp626 = -tmp625
    tmp627 = triton_helpers.minimum(tmp624, tmp626)
    tmp629 = tmp627 - tmp628
    tmp630 = triton_helpers.maximum(tmp3, tmp629)
    tmp631 = tmp619 * tmp630
    tmp632 = tmp630 - tmp631
    tmp633 = triton_helpers.maximum(tmp3, tmp632)
    tmp634 = tmp619 + tmp633
    tmp636 = -tmp635
    tmp638 = -tmp637
    tmp639 = triton_helpers.minimum(tmp636, tmp638)
    tmp641 = -tmp640
    tmp642 = triton_helpers.minimum(tmp639, tmp641)
    tmp644 = tmp642 - tmp643
    tmp645 = triton_helpers.maximum(tmp3, tmp644)
    tmp646 = tmp634 * tmp645
    tmp647 = tmp645 - tmp646
    tmp648 = triton_helpers.maximum(tmp3, tmp647)
    tmp649 = tmp634 + tmp648
    tmp651 = -tmp650
    tmp653 = -tmp652
    tmp654 = triton_helpers.minimum(tmp651, tmp653)
    tmp656 = -tmp655
    tmp657 = triton_helpers.minimum(tmp654, tmp656)
    tmp659 = tmp657 - tmp658
    tmp660 = triton_helpers.maximum(tmp3, tmp659)
    tmp661 = tmp649 * tmp660
    tmp662 = tmp660 - tmp661
    tmp663 = triton_helpers.maximum(tmp3, tmp662)
    tmp664 = tmp649 + tmp663
    tmp666 = -tmp665
    tmp668 = -tmp667
    tmp669 = triton_helpers.minimum(tmp666, tmp668)
    tmp671 = -tmp670
    tmp672 = triton_helpers.minimum(tmp669, tmp671)
    tmp674 = tmp672 - tmp673
    tmp675 = triton_helpers.maximum(tmp3, tmp674)
    tmp676 = tmp664 * tmp675
    tmp677 = tmp675 - tmp676
    tmp678 = triton_helpers.maximum(tmp3, tmp677)
    tmp679 = tmp664 + tmp678
    tmp681 = -tmp680
    tmp683 = -tmp682
    tmp684 = triton_helpers.minimum(tmp681, tmp683)
    tmp686 = -tmp685
    tmp687 = triton_helpers.minimum(tmp684, tmp686)
    tmp689 = tmp687 - tmp688
    tmp690 = triton_helpers.maximum(tmp3, tmp689)
    tmp691 = tmp679 * tmp690
    tmp692 = tmp690 - tmp691
    tmp693 = triton_helpers.maximum(tmp3, tmp692)
    tmp694 = tmp679 + tmp693
    tmp696 = -tmp695
    tmp698 = -tmp697
    tmp699 = triton_helpers.minimum(tmp696, tmp698)
    tmp701 = -tmp700
    tmp702 = triton_helpers.minimum(tmp699, tmp701)
    tmp704 = tmp702 - tmp703
    tmp705 = triton_helpers.maximum(tmp3, tmp704)
    tmp706 = tmp694 * tmp705
    tmp707 = tmp705 - tmp706
    tmp708 = triton_helpers.maximum(tmp3, tmp707)
    tmp709 = tmp694 + tmp708
    tmp711 = -tmp710
    tmp713 = -tmp712
    tmp714 = triton_helpers.minimum(tmp711, tmp713)
    tmp716 = -tmp715
    tmp717 = triton_helpers.minimum(tmp714, tmp716)
    tmp719 = tmp717 - tmp718
    tmp720 = triton_helpers.maximum(tmp3, tmp719)
    tmp721 = tmp709 * tmp720
    tmp722 = tmp720 - tmp721
    tmp723 = triton_helpers.maximum(tmp3, tmp722)
    tmp724 = tmp709 + tmp723
    tmp726 = -tmp725
    tmp728 = -tmp727
    tmp729 = triton_helpers.minimum(tmp726, tmp728)
    tmp731 = -tmp730
    tmp732 = triton_helpers.minimum(tmp729, tmp731)
    tmp734 = tmp732 - tmp733
    tmp735 = triton_helpers.maximum(tmp3, tmp734)
    tmp736 = tmp724 * tmp735
    tmp737 = tmp735 - tmp736
    tmp738 = triton_helpers.maximum(tmp3, tmp737)
    tmp739 = tmp724 + tmp738
    tmp741 = -tmp740
    tmp743 = -tmp742
    tmp744 = triton_helpers.minimum(tmp741, tmp743)
    tmp746 = -tmp745
    tmp747 = triton_helpers.minimum(tmp744, tmp746)
    tmp749 = tmp747 - tmp748
    tmp750 = triton_helpers.maximum(tmp3, tmp749)
    tmp751 = tmp739 * tmp750
    tmp752 = tmp750 - tmp751
    tmp753 = triton_helpers.maximum(tmp3, tmp752)
    tmp754 = tmp739 + tmp753
    tl.store(in_out_ptr49 + x0, tmp754, xmask)


@triton.jit
def triton_poi_fused_add_minimum_mul_neg_relu_sub_6(in_out_ptr0,
    in_out_ptr1, in_out_ptr2, in_out_ptr3, in_out_ptr4, in_out_ptr5,
    in_out_ptr6, in_out_ptr7, in_out_ptr8, in_out_ptr9, in_out_ptr10,
    in_out_ptr11, in_out_ptr12, in_out_ptr13, in_out_ptr14, in_out_ptr15,
    in_out_ptr16, in_out_ptr17, in_out_ptr18, in_out_ptr19, in_out_ptr20,
    in_out_ptr21, in_out_ptr22, in_ptr0, in_ptr1, in_ptr2, in_ptr3, in_ptr4,
    in_ptr5, in_ptr6, in_ptr7, in_ptr8, in_ptr9, in_ptr10, in_ptr11,
    in_ptr12, in_ptr13, in_ptr14, in_ptr15, in_ptr16, in_ptr17, in_ptr18,
    in_ptr19, in_ptr20, in_ptr21, in_ptr22, in_ptr23, in_ptr24, in_ptr25,
    in_ptr26, in_ptr27, in_ptr28, in_ptr29, in_ptr30, in_ptr31, in_ptr32,
    in_ptr33, in_ptr34, in_ptr35, in_ptr36, in_ptr37, in_ptr38, in_ptr39,
    in_ptr40, in_ptr41, in_ptr42, in_ptr43, in_ptr44, in_ptr45, in_ptr46,
    in_ptr47, in_ptr48, in_ptr49, in_ptr50, in_ptr51, in_ptr52, in_ptr53,
    in_ptr54, in_ptr55, in_ptr56, in_ptr57, in_ptr58, in_ptr59, in_ptr60,
    in_ptr61, in_ptr62, in_ptr63, in_ptr64, in_ptr65, in_ptr66, in_ptr67,
    in_ptr68, in_ptr69, in_ptr70, in_ptr71, in_ptr72, in_ptr73, in_ptr74,
    in_ptr75, in_ptr76, in_ptr77, in_ptr78, in_ptr79, in_ptr80, in_ptr81,
    in_ptr82, in_ptr83, in_ptr84, in_ptr85, in_ptr86, in_ptr87, in_ptr88,
    in_ptr89, in_ptr90, in_ptr91, in_ptr92, in_ptr93, in_ptr94, in_ptr95,
    in_ptr96, in_ptr97, in_ptr98, in_ptr99, in_ptr100, in_ptr101, in_ptr102,
    in_ptr103, in_ptr104, in_ptr105, in_ptr106, in_ptr107, in_ptr108,
    in_ptr109, in_ptr110, in_ptr111, in_ptr112, in_ptr113, in_ptr114,
    in_ptr115, in_ptr116, in_ptr117, in_ptr118, in_ptr119, in_ptr120,
    in_ptr121, in_ptr122, in_ptr123, in_ptr124, in_ptr125, in_ptr126,
    in_ptr127, in_ptr128, in_ptr129, in_ptr130, in_ptr131, in_ptr132,
    in_ptr133, in_ptr134, in_ptr135, in_ptr136, in_ptr137, in_ptr138,
    in_ptr139, in_ptr140, in_ptr141, in_ptr142, in_ptr143, in_ptr144,
    in_ptr145, in_ptr146, in_ptr147, in_ptr148, in_ptr149, in_ptr150,
    in_ptr151, in_ptr152, in_ptr153, in_ptr154, in_ptr155, in_ptr156,
    in_ptr157, in_ptr158, in_ptr159, in_ptr160, in_ptr161, in_ptr162,
    in_ptr163, in_ptr164, in_ptr165, in_ptr166, in_ptr167, in_ptr168,
    in_ptr169, in_ptr170, in_ptr171, in_ptr172, in_ptr173, in_ptr174,
    in_ptr175, in_ptr176, in_ptr177, in_ptr178, 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, xmask)
    tmp1 = tl.load(in_out_ptr0 + x0, xmask)
    tmp5 = tl.load(in_ptr1 + x0, xmask)
    tmp7 = tl.load(in_ptr2 + x0, xmask)
    tmp10 = tl.load(in_ptr3 + x0, xmask)
    tmp13 = tl.load(in_ptr4 + x0, xmask)
    tmp20 = tl.load(in_ptr5 + x0, xmask)
    tmp22 = tl.load(in_ptr6 + x0, xmask)
    tmp25 = tl.load(in_ptr7 + x0, xmask)
    tmp28 = tl.load(in_ptr8 + x0, xmask)
    tmp35 = tl.load(in_ptr9 + x0, xmask)
    tmp37 = tl.load(in_ptr10 + x0, xmask)
    tmp40 = tl.load(in_ptr11 + x0, xmask)
    tmp43 = tl.load(in_ptr12 + x0, xmask)
    tmp50 = tl.load(in_out_ptr1 + x0, xmask)
    tmp52 = tl.load(in_ptr13 + x0, xmask)
    tmp55 = tl.load(in_ptr14 + x0, xmask)
    tmp58 = tl.load(in_ptr15 + x0, xmask)
    tmp65 = tl.load(in_out_ptr2 + x0, xmask)
    tmp67 = tl.load(in_ptr16 + x0, xmask)
    tmp70 = tl.load(in_ptr17 + x0, xmask)
    tmp73 = tl.load(in_ptr18 + x0, xmask)
    tmp80 = tl.load(in_out_ptr3 + x0, xmask)
    tmp82 = tl.load(in_ptr19 + x0, xmask)
    tmp85 = tl.load(in_ptr20 + x0, xmask)
    tmp88 = tl.load(in_ptr21 + x0, xmask)
    tmp95 = tl.load(in_out_ptr4 + x0, xmask)
    tmp97 = tl.load(in_ptr22 + x0, xmask)
    tmp100 = tl.load(in_ptr23 + x0, xmask)
    tmp103 = tl.load(in_ptr24 + x0, xmask)
    tmp110 = tl.load(in_out_ptr5 + x0, xmask)
    tmp112 = tl.load(in_ptr25 + x0, xmask)
    tmp115 = tl.load(in_ptr26 + x0, xmask)
    tmp118 = tl.load(in_ptr27 + x0, xmask)
    tmp125 = tl.load(in_out_ptr6 + x0, xmask)
    tmp127 = tl.load(in_ptr28 + x0, xmask)
    tmp130 = tl.load(in_ptr29 + x0, xmask)
    tmp133 = tl.load(in_ptr30 + x0, xmask)
    tmp140 = tl.load(in_out_ptr7 + x0, xmask)
    tmp142 = tl.load(in_ptr31 + x0, xmask)
    tmp145 = tl.load(in_ptr32 + x0, xmask)
    tmp148 = tl.load(in_ptr33 + x0, xmask)
    tmp155 = tl.load(in_ptr34 + x0, xmask)
    tmp157 = tl.load(in_ptr35 + x0, xmask)
    tmp160 = tl.load(in_ptr36 + x0, xmask)
    tmp163 = tl.load(in_ptr37 + x0, xmask)
    tmp170 = tl.load(in_ptr38 + x0, xmask)
    tmp172 = tl.load(in_ptr39 + x0, xmask)
    tmp175 = tl.load(in_ptr40 + x0, xmask)
    tmp178 = tl.load(in_ptr41 + x0, xmask)
    tmp185 = tl.load(in_ptr42 + x0, xmask)
    tmp187 = tl.load(in_ptr43 + x0, xmask)
    tmp190 = tl.load(in_ptr44 + x0, xmask)
    tmp193 = tl.load(in_ptr45 + x0, xmask)
    tmp200 = tl.load(in_ptr46 + x0, xmask)
    tmp202 = tl.load(in_ptr47 + x0, xmask)
    tmp205 = tl.load(in_ptr48 + x0, xmask)
    tmp208 = tl.load(in_ptr49 + x0, xmask)
    tmp215 = tl.load(in_ptr50 + x0, xmask)
    tmp217 = tl.load(in_ptr51 + x0, xmask)
    tmp220 = tl.load(in_ptr52 + x0, xmask)
    tmp223 = tl.load(in_ptr53 + x0, xmask)
    tmp230 = tl.load(in_ptr54 + x0, xmask)
    tmp232 = tl.load(in_ptr55 + x0, xmask)
    tmp235 = tl.load(in_ptr56 + x0, xmask)
    tmp238 = tl.load(in_ptr57 + x0, xmask)
    tmp245 = tl.load(in_ptr58 + x0, xmask)
    tmp247 = tl.load(in_ptr59 + x0, xmask)
    tmp250 = tl.load(in_ptr60 + x0, xmask)
    tmp253 = tl.load(in_ptr61 + x0, xmask)
    tmp260 = tl.load(in_ptr62 + x0, xmask)
    tmp262 = tl.load(in_ptr63 + x0, xmask)
    tmp265 = tl.load(in_ptr64 + x0, xmask)
    tmp268 = tl.load(in_ptr65 + x0, xmask)
    tmp275 = tl.load(in_ptr66 + x0, xmask)
    tmp277 = tl.load(in_ptr67 + x0, xmask)
    tmp280 = tl.load(in_ptr68 + x0, xmask)
    tmp283 = tl.load(in_ptr69 + x0, xmask)
    tmp290 = tl.load(in_ptr70 + x0, xmask)
    tmp292 = tl.load(in_ptr71 + x0, xmask)
    tmp295 = tl.load(in_ptr72 + x0, xmask)
    tmp298 = tl.load(in_ptr73 + x0, xmask)
    tmp305 = tl.load(in_ptr74 + x0, xmask)
    tmp307 = tl.load(in_ptr75 + x0, xmask)
    tmp310 = tl.load(in_ptr76 + x0, xmask)
    tmp313 = tl.load(in_ptr77 + x0, xmask)
    tmp320 = tl.load(in_ptr78 + x0, xmask)
    tmp322 = tl.load(in_ptr79 + x0, xmask)
    tmp325 = tl.load(in_ptr80 + x0, xmask)
    tmp328 = tl.load(in_ptr81 + x0, xmask)
    tmp335 = tl.load(in_ptr82 + x0, xmask)
    tmp337 = tl.load(in_ptr83 + x0, xmask)
    tmp340 = tl.load(in_ptr84 + x0, xmask)
    tmp343 = tl.load(in_ptr85 + x0, xmask)
    tmp350 = tl.load(in_ptr86 + x0, xmask)
    tmp352 = tl.load(in_ptr87 + x0, xmask)
    tmp355 = tl.load(in_ptr88 + x0, xmask)
    tmp358 = tl.load(in_ptr89 + x0, xmask)
    tmp365 = tl.load(in_ptr90 + x0, xmask)
    tmp367 = tl.load(in_ptr91 + x0, xmask)
    tmp370 = tl.load(in_ptr92 + x0, xmask)
    tmp373 = tl.load(in_ptr93 + x0, xmask)
    tmp380 = tl.load(in_ptr94 + x0, xmask)
    tmp382 = tl.load(in_ptr95 + x0, xmask)
    tmp385 = tl.load(in_ptr96 + x0, xmask)
    tmp388 = tl.load(in_ptr97 + x0, xmask)
    tmp395 = tl.load(in_ptr98 + x0, xmask)
    tmp397 = tl.load(in_ptr99 + x0, xmask)
    tmp400 = tl.load(in_ptr100 + x0, xmask)
    tmp403 = tl.load(in_ptr101 + x0, xmask)
    tmp410 = tl.load(in_ptr102 + x0, xmask)
    tmp412 = tl.load(in_ptr103 + x0, xmask)
    tmp415 = tl.load(in_ptr104 + x0, xmask)
    tmp418 = tl.load(in_ptr105 + x0, xmask)
    tmp425 = tl.load(in_ptr106 + x0, xmask)
    tmp427 = tl.load(in_ptr107 + x0, xmask)
    tmp430 = tl.load(in_ptr108 + x0, xmask)
    tmp433 = tl.load(in_ptr109 + x0, xmask)
    tmp440 = tl.load(in_ptr110 + x0, xmask)
    tmp442 = tl.load(in_ptr111 + x0, xmask)
    tmp445 = tl.load(in_ptr112 + x0, xmask)
    tmp448 = tl.load(in_ptr113 + x0, xmask)
    tmp455 = tl.load(in_ptr114 + x0, xmask)
    tmp457 = tl.load(in_ptr115 + x0, xmask)
    tmp460 = tl.load(in_ptr116 + x0, xmask)
    tmp463 = tl.load(in_ptr117 + x0, xmask)
    tmp470 = tl.load(in_ptr118 + x0, xmask)
    tmp472 = tl.load(in_ptr119 + x0, xmask)
    tmp475 = tl.load(in_ptr120 + x0, xmask)
    tmp478 = tl.load(in_ptr121 + x0, xmask)
    tmp485 = tl.load(in_ptr122 + x0, xmask)
    tmp487 = tl.load(in_ptr123 + x0, xmask)
    tmp490 = tl.load(in_ptr124 + x0, xmask)
    tmp493 = tl.load(in_ptr125 + x0, xmask)
    tmp500 = tl.load(in_ptr126 + x0, xmask)
    tmp502 = tl.load(in_ptr127 + x0, xmask)
    tmp505 = tl.load(in_ptr128 + x0, xmask)
    tmp508 = tl.load(in_ptr129 + x0, xmask)
    tmp515 = tl.load(in_ptr130 + x0, xmask)
    tmp517 = tl.load(in_ptr131 + x0, xmask)
    tmp520 = tl.load(in_ptr132 + x0, xmask)
    tmp523 = tl.load(in_ptr133 + x0, xmask)
    tmp530 = tl.load(in_ptr134 + x0, xmask)
    tmp532 = tl.load(in_ptr135 + x0, xmask)
    tmp535 = tl.load(in_out_ptr8 + x0, xmask)
    tmp538 = tl.load(in_ptr136 + x0, xmask)
    tmp545 = tl.load(in_out_ptr9 + x0, xmask)
    tmp547 = tl.load(in_ptr137 + x0, xmask)
    tmp550 = tl.load(in_ptr138 + x0, xmask)
    tmp553 = tl.load(in_ptr139 + x0, xmask)
    tmp560 = tl.load(in_out_ptr10 + x0, xmask)
    tmp562 = tl.load(in_ptr140 + x0, xmask)
    tmp565 = tl.load(in_ptr141 + x0, xmask)
    tmp568 = tl.load(in_ptr142 + x0, xmask)
    tmp575 = tl.load(in_out_ptr11 + x0, xmask)
    tmp577 = tl.load(in_ptr143 + x0, xmask)
    tmp580 = tl.load(in_ptr144 + x0, xmask)
    tmp583 = tl.load(in_ptr145 + x0, xmask)
    tmp590 = tl.load(in_out_ptr12 + x0, xmask)
    tmp592 = tl.load(in_ptr146 + x0, xmask)
    tmp595 = tl.load(in_ptr147 + x0, xmask)
    tmp598 = tl.load(in_ptr148 + x0, xmask)
    tmp605 = tl.load(in_out_ptr13 + x0, xmask)
    tmp607 = tl.load(in_ptr149 + x0, xmask)
    tmp610 = tl.load(in_ptr150 + x0, xmask)
    tmp613 = tl.load(in_ptr151 + x0, xmask)
    tmp620 = tl.load(in_out_ptr14 + x0, xmask)
    tmp622 = tl.load(in_ptr152 + x0, xmask)
    tmp625 = tl.load(in_ptr153 + x0, xmask)
    tmp628 = tl.load(in_ptr154 + x0, xmask)
    tmp635 = tl.load(in_out_ptr15 + x0, xmask)
    tmp637 = tl.load(in_ptr155 + x0, xmask)
    tmp640 = tl.load(in_ptr156 + x0, xmask)
    tmp643 = tl.load(in_ptr157 + x0, xmask)
    tmp650 = tl.load(in_out_ptr16 + x0, xmask)
    tmp652 = tl.load(in_ptr158 + x0, xmask)
    tmp655 = tl.load(in_ptr159 + x0, xmask)
    tmp658 = tl.load(in_ptr160 + x0, xmask)
    tmp665 = tl.load(in_out_ptr17 + x0, xmask)
    tmp667 = tl.load(in_ptr161 + x0, xmask)
    tmp670 = tl.load(in_ptr162 + x0, xmask)
    tmp673 = tl.load(in_ptr163 + x0, xmask)
    tmp680 = tl.load(in_out_ptr18 + x0, xmask)
    tmp682 = tl.load(in_ptr164 + x0, xmask)
    tmp685 = tl.load(in_ptr165 + x0, xmask)
    tmp688 = tl.load(in_ptr166 + x0, xmask)
    tmp695 = tl.load(in_out_ptr19 + x0, xmask)
    tmp697 = tl.load(in_ptr167 + x0, xmask)
    tmp700 = tl.load(in_ptr168 + x0, xmask)
    tmp703 = tl.load(in_ptr169 + x0, xmask)
    tmp710 = tl.load(in_out_ptr20 + x0, xmask)
    tmp712 = tl.load(in_ptr170 + x0, xmask)
    tmp715 = tl.load(in_ptr171 + x0, xmask)
    tmp718 = tl.load(in_ptr172 + x0, xmask)
    tmp725 = tl.load(in_out_ptr21 + x0, xmask)
    tmp727 = tl.load(in_ptr173 + x0, xmask)
    tmp730 = tl.load(in_ptr174 + x0, xmask)
    tmp733 = tl.load(in_ptr175 + x0, xmask)
    tmp740 = tl.load(in_out_ptr22 + x0, xmask)
    tmp742 = tl.load(in_ptr176 + x0, xmask)
    tmp745 = tl.load(in_ptr177 + x0, xmask)
    tmp748 = tl.load(in_ptr178 + x0, xmask)
    tmp2 = tmp0 - tmp1
    tmp3 = tl.full([1], 0, tl.int32)
    tmp4 = triton_helpers.maximum(tmp3, tmp2)
    tmp6 = -tmp5
    tmp8 = -tmp7
    tmp9 = triton_helpers.minimum(tmp6, tmp8)
    tmp11 = -tmp10
    tmp12 = triton_helpers.minimum(tmp9, tmp11)
    tmp14 = tmp12 - tmp13
    tmp15 = triton_helpers.maximum(tmp3, tmp14)
    tmp16 = tmp4 * tmp15
    tmp17 = tmp15 - tmp16
    tmp18 = triton_helpers.maximum(tmp3, tmp17)
    tmp19 = tmp4 + tmp18
    tmp21 = -tmp20
    tmp23 = -tmp22
    tmp24 = triton_helpers.minimum(tmp21, tmp23)
    tmp26 = -tmp25
    tmp27 = triton_helpers.minimum(tmp24, tmp26)
    tmp29 = tmp27 - tmp28
    tmp30 = triton_helpers.maximum(tmp3, tmp29)
    tmp31 = tmp19 * tmp30
    tmp32 = tmp30 - tmp31
    tmp33 = triton_helpers.maximum(tmp3, tmp32)
    tmp34 = tmp19 + tmp33
    tmp36 = -tmp35
    tmp38 = -tmp37
    tmp39 = triton_helpers.minimum(tmp36, tmp38)
    tmp41 = -tmp40
    tmp42 = triton_helpers.minimum(tmp39, tmp41)
    tmp44 = tmp42 - tmp43
    tmp45 = triton_helpers.maximum(tmp3, tmp44)
    tmp46 = tmp34 * tmp45
    tmp47 = tmp45 - tmp46
    tmp48 = triton_helpers.maximum(tmp3, tmp47)
    tmp49 = tmp34 + tmp48
    tmp51 = -tmp50
    tmp53 = -tmp52
    tmp54 = triton_helpers.minimum(tmp51, tmp53)
    tmp56 = -tmp55
    tmp57 = triton_helpers.minimum(tmp54, tmp56)
    tmp59 = tmp57 - tmp58
    tmp60 = triton_helpers.maximum(tmp3, tmp59)
    tmp61 = tmp49 * tmp60
    tmp62 = tmp60 - tmp61
    tmp63 = triton_helpers.maximum(tmp3, tmp62)
    tmp64 = tmp49 + tmp63
    tmp66 = -tmp65
    tmp68 = -tmp67
    tmp69 = triton_helpers.minimum(tmp66, tmp68)
    tmp71 = -tmp70
    tmp72 = triton_helpers.minimum(tmp69, tmp71)
    tmp74 = tmp72 - tmp73
    tmp75 = triton_helpers.maximum(tmp3, tmp74)
    tmp76 = tmp64 * tmp75
    tmp77 = tmp75 - tmp76
    tmp78 = triton_helpers.maximum(tmp3, tmp77)
    tmp79 = tmp64 + tmp78
    tmp81 = -tmp80
    tmp83 = -tmp82
    tmp84 = triton_helpers.minimum(tmp81, tmp83)
    tmp86 = -tmp85
    tmp87 = triton_helpers.minimum(tmp84, tmp86)
    tmp89 = tmp87 - tmp88
    tmp90 = triton_helpers.maximum(tmp3, tmp89)
    tmp91 = tmp79 * tmp90
    tmp92 = tmp90 - tmp91
    tmp93 = triton_helpers.maximum(tmp3, tmp92)
    tmp94 = tmp79 + tmp93
    tmp96 = -tmp95
    tmp98 = -tmp97
    tmp99 = triton_helpers.minimum(tmp96, tmp98)
    tmp101 = -tmp100
    tmp102 = triton_helpers.minimum(tmp99, tmp101)
    tmp104 = tmp102 - tmp103
    tmp105 = triton_helpers.maximum(tmp3, tmp104)
    tmp106 = tmp94 * tmp105
    tmp107 = tmp105 - tmp106
    tmp108 = triton_helpers.maximum(tmp3, tmp107)
    tmp109 = tmp94 + tmp108
    tmp111 = -tmp110
    tmp113 = -tmp112
    tmp114 = triton_helpers.minimum(tmp111, tmp113)
    tmp116 = -tmp115
    tmp117 = triton_helpers.minimum(tmp114, tmp116)
    tmp119 = tmp117 - tmp118
    tmp120 = triton_helpers.maximum(tmp3, tmp119)
    tmp121 = tmp109 * tmp120
    tmp122 = tmp120 - tmp121
    tmp123 = triton_helpers.maximum(tmp3, tmp122)
    tmp124 = tmp109 + tmp123
    tmp126 = -tmp125
    tmp128 = -tmp127
    tmp129 = triton_helpers.minimum(tmp126, tmp128)
    tmp131 = -tmp130
    tmp132 = triton_helpers.minimum(tmp129, tmp131)
    tmp134 = tmp132 - tmp133
    tmp135 = triton_helpers.maximum(tmp3, tmp134)
    tmp136 = tmp124 * tmp135
    tmp137 = tmp135 - tmp136
    tmp138 = triton_helpers.maximum(tmp3, tmp137)
    tmp139 = tmp124 + tmp138
    tmp141 = -tmp140
    tmp143 = -tmp142
    tmp144 = triton_helpers.minimum(tmp141, tmp143)
    tmp146 = -tmp145
    tmp147 = triton_helpers.minimum(tmp144, tmp146)
    tmp149 = tmp147 - tmp148
    tmp150 = triton_helpers.maximum(tmp3, tmp149)
    tmp151 = tmp139 * tmp150
    tmp152 = tmp150 - tmp151
    tmp153 = triton_helpers.maximum(tmp3, tmp152)
    tmp154 = tmp139 + tmp153
    tmp156 = -tmp155
    tmp158 = -tmp157
    tmp159 = triton_helpers.minimum(tmp156, tmp158)
    tmp161 = -tmp160
    tmp162 = triton_helpers.minimum(tmp159, tmp161)
    tmp164 = tmp162 - tmp163
    tmp165 = triton_helpers.maximum(tmp3, tmp164)
    tmp166 = tmp154 * tmp165
    tmp167 = tmp165 - tmp166
    tmp168 = triton_helpers.maximum(tmp3, tmp167)
    tmp169 = tmp154 + tmp168
    tmp171 = -tmp170
    tmp173 = -tmp172
    tmp174 = triton_helpers.minimum(tmp171, tmp173)
    tmp176 = -tmp175
    tmp177 = triton_helpers.minimum(tmp174, tmp176)
    tmp179 = tmp177 - tmp178
    tmp180 = triton_helpers.maximum(tmp3, tmp179)
    tmp181 = tmp169 * tmp180
    tmp182 = tmp180 - tmp181
    tmp183 = triton_helpers.maximum(tmp3, tmp182)
    tmp184 = tmp169 + tmp183
    tmp186 = -tmp185
    tmp188 = -tmp187
    tmp189 = triton_helpers.minimum(tmp186, tmp188)
    tmp191 = -tmp190
    tmp192 = triton_helpers.minimum(tmp189, tmp191)
    tmp194 = tmp192 - tmp193
    tmp195 = triton_helpers.maximum(tmp3, tmp194)
    tmp196 = tmp184 * tmp195
    tmp197 = tmp195 - tmp196
    tmp198 = triton_helpers.maximum(tmp3, tmp197)
    tmp199 = tmp184 + tmp198
    tmp201 = -tmp200
    tmp203 = -tmp202
    tmp204 = triton_helpers.minimum(tmp201, tmp203)
    tmp206 = -tmp205
    tmp207 = triton_helpers.minimum(tmp204, tmp206)
    tmp209 = tmp207 - tmp208
    tmp210 = triton_helpers.maximum(tmp3, tmp209)
    tmp211 = tmp199 * tmp210
    tmp212 = tmp210 - tmp211
    tmp213 = triton_helpers.maximum(tmp3, tmp212)
    tmp214 = tmp199 + tmp213
    tmp216 = -tmp215
    tmp218 = -tmp217
    tmp219 = triton_helpers.minimum(tmp216, tmp218)
    tmp221 = -tmp220
    tmp222 = triton_helpers.minimum(tmp219, tmp221)
    tmp224 = tmp222 - tmp223
    tmp225 = triton_helpers.maximum(tmp3, tmp224)
    tmp226 = tmp214 * tmp225
    tmp227 = tmp225 - tmp226
    tmp228 = triton_helpers.maximum(tmp3, tmp227)
    tmp229 = tmp214 + tmp228
    tmp231 = -tmp230
    tmp233 = -tmp232
    tmp234 = triton_helpers.minimum(tmp231, tmp233)
    tmp236 = -tmp235
    tmp237 = triton_helpers.minimum(tmp234, tmp236)
    tmp239 = tmp237 - tmp238
    tmp240 = triton_helpers.maximum(tmp3, tmp239)
    tmp241 = tmp229 * tmp240
    tmp242 = tmp240 - tmp241
    tmp243 = triton_helpers.maximum(tmp3, tmp242)
    tmp244 = tmp229 + tmp243
    tmp246 = -tmp245
    tmp248 = -tmp247
    tmp249 = triton_helpers.minimum(tmp246, tmp248)
    tmp251 = -tmp250
    tmp252 = triton_helpers.minimum(tmp249, tmp251)
    tmp254 = tmp252 - tmp253
    tmp255 = triton_helpers.maximum(tmp3, tmp254)
    tmp256 = tmp244 * tmp255
    tmp257 = tmp255 - tmp256
    tmp258 = triton_helpers.maximum(tmp3, tmp257)
    tmp259 = tmp244 + tmp258
    tmp261 = -tmp260
    tmp263 = -tmp262
    tmp264 = triton_helpers.minimum(tmp261, tmp263)
    tmp266 = -tmp265
    tmp267 = triton_helpers.minimum(tmp264, tmp266)
    tmp269 = tmp267 - tmp268
    tmp270 = triton_helpers.maximum(tmp3, tmp269)
    tmp271 = tmp259 * tmp270
    tmp272 = tmp270 - tmp271
    tmp273 = triton_helpers.maximum(tmp3, tmp272)
    tmp274 = tmp259 + tmp273
    tmp276 = -tmp275
    tmp278 = -tmp277
    tmp279 = triton_helpers.minimum(tmp276, tmp278)
    tmp281 = -tmp280
    tmp282 = triton_helpers.minimum(tmp279, tmp281)
    tmp284 = tmp282 - tmp283
    tmp285 = triton_helpers.maximum(tmp3, tmp284)
    tmp286 = tmp274 * tmp285
    tmp287 = tmp285 - tmp286
    tmp288 = triton_helpers.maximum(tmp3, tmp287)
    tmp289 = tmp274 + tmp288
    tmp291 = -tmp290
    tmp293 = -tmp292
    tmp294 = triton_helpers.minimum(tmp291, tmp293)
    tmp296 = -tmp295
    tmp297 = triton_helpers.minimum(tmp294, tmp296)
    tmp299 = tmp297 - tmp298
    tmp300 = triton_helpers.maximum(tmp3, tmp299)
    tmp301 = tmp289 * tmp300
    tmp302 = tmp300 - tmp301
    tmp303 = triton_helpers.maximum(tmp3, tmp302)
    tmp304 = tmp289 + tmp303
    tmp306 = -tmp305
    tmp308 = -tmp307
    tmp309 = triton_helpers.minimum(tmp306, tmp308)
    tmp311 = -tmp310
    tmp312 = triton_helpers.minimum(tmp309, tmp311)
    tmp314 = tmp312 - tmp313
    tmp315 = triton_helpers.maximum(tmp3, tmp314)
    tmp316 = tmp304 * tmp315
    tmp317 = tmp315 - tmp316
    tmp318 = triton_helpers.maximum(tmp3, tmp317)
    tmp319 = tmp304 + tmp318
    tmp321 = -tmp320
    tmp323 = -tmp322
    tmp324 = triton_helpers.minimum(tmp321, tmp323)
    tmp326 = -tmp325
    tmp327 = triton_helpers.minimum(tmp324, tmp326)
    tmp329 = tmp327 - tmp328
    tmp330 = triton_helpers.maximum(tmp3, tmp329)
    tmp331 = tmp319 * tmp330
    tmp332 = tmp330 - tmp331
    tmp333 = triton_helpers.maximum(tmp3, tmp332)
    tmp334 = tmp319 + tmp333
    tmp336 = -tmp335
    tmp338 = -tmp337
    tmp339 = triton_helpers.minimum(tmp336, tmp338)
    tmp341 = -tmp340
    tmp342 = triton_helpers.minimum(tmp339, tmp341)
    tmp344 = tmp342 - tmp343
    tmp345 = triton_helpers.maximum(tmp3, tmp344)
    tmp346 = tmp334 * tmp345
    tmp347 = tmp345 - tmp346
    tmp348 = triton_helpers.maximum(tmp3, tmp347)
    tmp349 = tmp334 + tmp348
    tmp351 = -tmp350
    tmp353 = -tmp352
    tmp354 = triton_helpers.minimum(tmp351, tmp353)
    tmp356 = -tmp355
    tmp357 = triton_helpers.minimum(tmp354, tmp356)
    tmp359 = tmp357 - tmp358
    tmp360 = triton_helpers.maximum(tmp3, tmp359)
    tmp361 = tmp349 * tmp360
    tmp362 = tmp360 - tmp361
    tmp363 = triton_helpers.maximum(tmp3, tmp362)
    tmp364 = tmp349 + tmp363
    tmp366 = -tmp365
    tmp368 = -tmp367
    tmp369 = triton_helpers.minimum(tmp366, tmp368)
    tmp371 = -tmp370
    tmp372 = triton_helpers.minimum(tmp369, tmp371)
    tmp374 = tmp372 - tmp373
    tmp375 = triton_helpers.maximum(tmp3, tmp374)
    tmp376 = tmp364 * tmp375
    tmp377 = tmp375 - tmp376
    tmp378 = triton_helpers.maximum(tmp3, tmp377)
    tmp379 = tmp364 + tmp378
    tmp381 = -tmp380
    tmp383 = -tmp382
    tmp384 = triton_helpers.minimum(tmp381, tmp383)
    tmp386 = -tmp385
    tmp387 = triton_helpers.minimum(tmp384, tmp386)
    tmp389 = tmp387 - tmp388
    tmp390 = triton_helpers.maximum(tmp3, tmp389)
    tmp391 = tmp379 * tmp390
    tmp392 = tmp390 - tmp391
    tmp393 = triton_helpers.maximum(tmp3, tmp392)
    tmp394 = tmp379 + tmp393
    tmp396 = -tmp395
    tmp398 = -tmp397
    tmp399 = triton_helpers.minimum(tmp396, tmp398)
    tmp401 = -tmp400
    tmp402 = triton_helpers.minimum(tmp399, tmp401)
    tmp404 = tmp402 - tmp403
    tmp405 = triton_helpers.maximum(tmp3, tmp404)
    tmp406 = tmp394 * tmp405
    tmp407 = tmp405 - tmp406
    tmp408 = triton_helpers.maximum(tmp3, tmp407)
    tmp409 = tmp394 + tmp408
    tmp411 = -tmp410
    tmp413 = -tmp412
    tmp414 = triton_helpers.minimum(tmp411, tmp413)
    tmp416 = -tmp415
    tmp417 = triton_helpers.minimum(tmp414, tmp416)
    tmp419 = tmp417 - tmp418
    tmp420 = triton_helpers.maximum(tmp3, tmp419)
    tmp421 = tmp409 * tmp420
    tmp422 = tmp420 - tmp421
    tmp423 = triton_helpers.maximum(tmp3, tmp422)
    tmp424 = tmp409 + tmp423
    tmp426 = -tmp425
    tmp428 = -tmp427
    tmp429 = triton_helpers.minimum(tmp426, tmp428)
    tmp431 = -tmp430
    tmp432 = triton_helpers.minimum(tmp429, tmp431)
    tmp434 = tmp432 - tmp433
    tmp435 = triton_helpers.maximum(tmp3, tmp434)
    tmp436 = tmp424 * tmp435
    tmp437 = tmp435 - tmp436
    tmp438 = triton_helpers.maximum(tmp3, tmp437)
    tmp439 = tmp424 + tmp438
    tmp441 = -tmp440
    tmp443 = -tmp442
    tmp444 = triton_helpers.minimum(tmp441, tmp443)
    tmp446 = -tmp445
    tmp447 = triton_helpers.minimum(tmp444, tmp446)
    tmp449 = tmp447 - tmp448
    tmp450 = triton_helpers.maximum(tmp3, tmp449)
    tmp451 = tmp439 * tmp450
    tmp452 = tmp450 - tmp451
    tmp453 = triton_helpers.maximum(tmp3, tmp452)
    tmp454 = tmp439 + tmp453
    tmp456 = -tmp455
    tmp458 = -tmp457
    tmp459 = triton_helpers.minimum(tmp456, tmp458)
    tmp461 = -tmp460
    tmp462 = triton_helpers.minimum(tmp459, tmp461)
    tmp464 = tmp462 - tmp463
    tmp465 = triton_helpers.maximum(tmp3, tmp464)
    tmp466 = tmp454 * tmp465
    tmp467 = tmp465 - tmp466
    tmp468 = triton_helpers.maximum(tmp3, tmp467)
    tmp469 = tmp454 + tmp468
    tmp471 = -tmp470
    tmp473 = -tmp472
    tmp474 = triton_helpers.minimum(tmp471, tmp473)
    tmp476 = -tmp475
    tmp477 = triton_helpers.minimum(tmp474, tmp476)
    tmp479 = tmp477 - tmp478
    tmp480 = triton_helpers.maximum(tmp3, tmp479)
    tmp481 = tmp469 * tmp480
    tmp482 = tmp480 - tmp481
    tmp483 = triton_helpers.maximum(tmp3, tmp482)
    tmp484 = tmp469 + tmp483
    tmp486 = -tmp485
    tmp488 = -tmp487
    tmp489 = triton_helpers.minimum(tmp486, tmp488)
    tmp491 = -tmp490
    tmp492 = triton_helpers.minimum(tmp489, tmp491)
    tmp494 = tmp492 - tmp493
    tmp495 = triton_helpers.maximum(tmp3, tmp494)
    tmp496 = tmp484 * tmp495
    tmp497 = tmp495 - tmp496
    tmp498 = triton_helpers.maximum(tmp3, tmp497)
    tmp499 = tmp484 + tmp498
    tmp501 = -tmp500
    tmp503 = -tmp502
    tmp504 = triton_helpers.minimum(tmp501, tmp503)
    tmp506 = -tmp505
    tmp507 = triton_helpers.minimum(tmp504, tmp506)
    tmp509 = tmp507 - tmp508
    tmp510 = triton_helpers.maximum(tmp3, tmp509)
    tmp511 = tmp499 * tmp510
    tmp512 = tmp510 - tmp511
    tmp513 = triton_helpers.maximum(tmp3, tmp512)
    tmp514 = tmp499 + tmp513
    tmp516 = -tmp515
    tmp518 = -tmp517
    tmp519 = triton_helpers.minimum(tmp516, tmp518)
    tmp521 = -tmp520
    tmp522 = triton_helpers.minimum(tmp519, tmp521)
    tmp524 = tmp522 - tmp523
    tmp525 = triton_helpers.maximum(tmp3, tmp524)
    tmp526 = tmp514 * tmp525
    tmp527 = tmp525 - tmp526
    tmp528 = triton_helpers.maximum(tmp3, tmp527)
    tmp529 = tmp514 + tmp528
    tmp531 = -tmp530
    tmp533 = -tmp532
    tmp534 = triton_helpers.minimum(tmp531, tmp533)
    tmp536 = -tmp535
    tmp537 = triton_helpers.minimum(tmp534, tmp536)
    tmp539 = tmp537 - tmp538
    tmp540 = triton_helpers.maximum(tmp3, tmp539)
    tmp541 = tmp529 * tmp540
    tmp542 = tmp540 - tmp541
    tmp543 = triton_helpers.maximum(tmp3, tmp542)
    tmp544 = tmp529 + tmp543
    tmp546 = -tmp545
    tmp548 = -tmp547
    tmp549 = triton_helpers.minimum(tmp546, tmp548)
    tmp551 = -tmp550
    tmp552 = triton_helpers.minimum(tmp549, tmp551)
    tmp554 = tmp552 - tmp553
    tmp555 = triton_helpers.maximum(tmp3, tmp554)
    tmp556 = tmp544 * tmp555
    tmp557 = tmp555 - tmp556
    tmp558 = triton_helpers.maximum(tmp3, tmp557)
    tmp559 = tmp544 + tmp558
    tmp561 = -tmp560
    tmp563 = -tmp562
    tmp564 = triton_helpers.minimum(tmp561, tmp563)
    tmp566 = -tmp565
    tmp567 = triton_helpers.minimum(tmp564, tmp566)
    tmp569 = tmp567 - tmp568
    tmp570 = triton_helpers.maximum(tmp3, tmp569)
    tmp571 = tmp559 * tmp570
    tmp572 = tmp570 - tmp571
    tmp573 = triton_helpers.maximum(tmp3, tmp572)
    tmp574 = tmp559 + tmp573
    tmp576 = -tmp575
    tmp578 = -tmp577
    tmp579 = triton_helpers.minimum(tmp576, tmp578)
    tmp581 = -tmp580
    tmp582 = triton_helpers.minimum(tmp579, tmp581)
    tmp584 = tmp582 - tmp583
    tmp585 = triton_helpers.maximum(tmp3, tmp584)
    tmp586 = tmp574 * tmp585
    tmp587 = tmp585 - tmp586
    tmp588 = triton_helpers.maximum(tmp3, tmp587)
    tmp589 = tmp574 + tmp588
    tmp591 = -tmp590
    tmp593 = -tmp592
    tmp594 = triton_helpers.minimum(tmp591, tmp593)
    tmp596 = -tmp595
    tmp597 = triton_helpers.minimum(tmp594, tmp596)
    tmp599 = tmp597 - tmp598
    tmp600 = triton_helpers.maximum(tmp3, tmp599)
    tmp601 = tmp589 * tmp600
    tmp602 = tmp600 - tmp601
    tmp603 = triton_helpers.maximum(tmp3, tmp602)
    tmp604 = tmp589 + tmp603
    tmp606 = -tmp605
    tmp608 = -tmp607
    tmp609 = triton_helpers.minimum(tmp606, tmp608)
    tmp611 = -tmp610
    tmp612 = triton_helpers.minimum(tmp609, tmp611)
    tmp614 = tmp612 - tmp613
    tmp615 = triton_helpers.maximum(tmp3, tmp614)
    tmp616 = tmp604 * tmp615
    tmp617 = tmp615 - tmp616
    tmp618 = triton_helpers.maximum(tmp3, tmp617)
    tmp619 = tmp604 + tmp618
    tmp621 = -tmp620
    tmp623 = -tmp622
    tmp624 = triton_helpers.minimum(tmp621, tmp623)
    tmp626 = -tmp625
    tmp627 = triton_helpers.minimum(tmp624, tmp626)
    tmp629 = tmp627 - tmp628
    tmp630 = triton_helpers.maximum(tmp3, tmp629)
    tmp631 = tmp619 * tmp630
    tmp632 = tmp630 - tmp631
    tmp633 = triton_helpers.maximum(tmp3, tmp632)
    tmp634 = tmp619 + tmp633
    tmp636 = -tmp635
    tmp638 = -tmp637
    tmp639 = triton_helpers.minimum(tmp636, tmp638)
    tmp641 = -tmp640
    tmp642 = triton_helpers.minimum(tmp639, tmp641)
    tmp644 = tmp642 - tmp643
    tmp645 = triton_helpers.maximum(tmp3, tmp644)
    tmp646 = tmp634 * tmp645
    tmp647 = tmp645 - tmp646
    tmp648 = triton_helpers.maximum(tmp3, tmp647)
    tmp649 = tmp634 + tmp648
    tmp651 = -tmp650
    tmp653 = -tmp652
    tmp654 = triton_helpers.minimum(tmp651, tmp653)
    tmp656 = -tmp655
    tmp657 = triton_helpers.minimum(tmp654, tmp656)
    tmp659 = tmp657 - tmp658
    tmp660 = triton_helpers.maximum(tmp3, tmp659)
    tmp661 = tmp649 * tmp660
    tmp662 = tmp660 - tmp661
    tmp663 = triton_helpers.maximum(tmp3, tmp662)
    tmp664 = tmp649 + tmp663
    tmp666 = -tmp665
    tmp668 = -tmp667
    tmp669 = triton_helpers.minimum(tmp666, tmp668)
    tmp671 = -tmp670
    tmp672 = triton_helpers.minimum(tmp669, tmp671)
    tmp674 = tmp672 - tmp673
    tmp675 = triton_helpers.maximum(tmp3, tmp674)
    tmp676 = tmp664 * tmp675
    tmp677 = tmp675 - tmp676
    tmp678 = triton_helpers.maximum(tmp3, tmp677)
    tmp679 = tmp664 + tmp678
    tmp681 = -tmp680
    tmp683 = -tmp682
    tmp684 = triton_helpers.minimum(tmp681, tmp683)
    tmp686 = -tmp685
    tmp687 = triton_helpers.minimum(tmp684, tmp686)
    tmp689 = tmp687 - tmp688
    tmp690 = triton_helpers.maximum(tmp3, tmp689)
    tmp691 = tmp679 * tmp690
    tmp692 = tmp690 - tmp691
    tmp693 = triton_helpers.maximum(tmp3, tmp692)
    tmp694 = tmp679 + tmp693
    tmp696 = -tmp695
    tmp698 = -tmp697
    tmp699 = triton_helpers.minimum(tmp696, tmp698)
    tmp701 = -tmp700
    tmp702 = triton_helpers.minimum(tmp699, tmp701)
    tmp704 = tmp702 - tmp703
    tmp705 = triton_helpers.maximum(tmp3, tmp704)
    tmp706 = tmp694 * tmp705
    tmp707 = tmp705 - tmp706
    tmp708 = triton_helpers.maximum(tmp3, tmp707)
    tmp709 = tmp694 + tmp708
    tmp711 = -tmp710
    tmp713 = -tmp712
    tmp714 = triton_helpers.minimum(tmp711, tmp713)
    tmp716 = -tmp715
    tmp717 = triton_helpers.minimum(tmp714, tmp716)
    tmp719 = tmp717 - tmp718
    tmp720 = triton_helpers.maximum(tmp3, tmp719)
    tmp721 = tmp709 * tmp720
    tmp722 = tmp720 - tmp721
    tmp723 = triton_helpers.maximum(tmp3, tmp722)
    tmp724 = tmp709 + tmp723
    tmp726 = -tmp725
    tmp728 = -tmp727
    tmp729 = triton_helpers.minimum(tmp726, tmp728)
    tmp731 = -tmp730
    tmp732 = triton_helpers.minimum(tmp729, tmp731)
    tmp734 = tmp732 - tmp733
    tmp735 = triton_helpers.maximum(tmp3, tmp734)
    tmp736 = tmp724 * tmp735
    tmp737 = tmp735 - tmp736
    tmp738 = triton_helpers.maximum(tmp3, tmp737)
    tmp739 = tmp724 + tmp738
    tmp741 = -tmp740
    tmp743 = -tmp742
    tmp744 = triton_helpers.minimum(tmp741, tmp743)
    tmp746 = -tmp745
    tmp747 = triton_helpers.minimum(tmp744, tmp746)
    tmp749 = tmp747 - tmp748
    tmp750 = triton_helpers.maximum(tmp3, tmp749)
    tmp751 = tmp739 * tmp750
    tmp752 = tmp750 - tmp751
    tmp753 = triton_helpers.maximum(tmp3, tmp752)
    tmp754 = tmp739 + tmp753
    tl.store(in_out_ptr22 + x0, tmp754, xmask)


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, 4, 4, 4), (64, 16, 4, 1), torch.float32)
        buf4 = empty_strided_cuda((4, 4, 4, 4), (64, 16, 4, 1), torch.float32)
        buf8 = empty_strided_cuda((4, 4, 4, 4), (64, 16, 4, 1), torch.float32)
        buf16 = empty_strided_cuda((4, 4, 4, 4), (64, 16, 4, 1), torch.float32)
        buf20 = empty_strided_cuda((4, 4, 4, 4), (64, 16, 4, 1), torch.float32)
        buf24 = empty_strided_cuda((4, 4, 4, 4), (64, 16, 4, 1), torch.float32)
        get_raw_stream(0)
        triton_poi_fused_neg_0[grid(256)](arg0_1, buf0, buf4, buf8, buf16,
            buf20, buf24, 256, XBLOCK=128, num_warps=4, num_stages=1)
        buf1 = torch.ops.aten.max_pool3d_with_indices.default(buf0, [3, 1, 
            1], [1, 1, 1], [1, 0, 0])
        del buf0
        buf2 = buf1[0]
        del buf1
        buf5 = torch.ops.aten.max_pool3d_with_indices.default(buf4, [1, 3, 
            1], [1, 1, 1], [0, 1, 0])
        del buf4
        buf6 = buf5[0]
        del buf5
        buf9 = torch.ops.aten.max_pool3d_with_indices.default(buf8, [1, 1, 
            3], [1, 1, 1], [0, 0, 1])
        del buf8
        buf10 = buf9[0]
        del buf9
        buf12 = buf10
        del buf10
        triton_poi_fused_minimum_neg_1[grid(256)](buf12, buf2, buf6, 256,
            XBLOCK=256, num_warps=4, num_stages=1)
        buf13 = torch.ops.aten.max_pool3d_with_indices.default(buf12, [3, 3,
            3], [1, 1, 1], [1, 1, 1])
        buf14 = buf13[0]
        del buf13
        buf17 = torch.ops.aten.max_pool3d_with_indices.default(buf16, [3, 1,
            1], [1, 1, 1], [1, 0, 0])
        buf18 = buf17[0]
        del buf17
        buf21 = torch.ops.aten.max_pool3d_with_indices.default(buf20, [1, 3,
            1], [1, 1, 1], [0, 1, 0])
        buf22 = buf21[0]
        del buf21
        buf25 = torch.ops.aten.max_pool3d_with_indices.default(buf24, [1, 1,
            3], [1, 1, 1], [0, 0, 1])
        buf26 = buf25[0]
        del buf25
        buf28 = buf24
        del buf24
        buf32 = buf20
        del buf20
        buf36 = buf16
        del buf16
        buf44 = buf12
        del buf12
        buf48 = buf6
        del buf6
        buf52 = buf2
        del buf2
        triton_poi_fused_minimum_neg_2[grid(256)](buf18, buf26, buf22,
            buf28, buf32, buf36, buf44, buf48, buf52, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf29 = torch.ops.aten.max_pool3d_with_indices.default(buf28, [3, 1,
            1], [1, 1, 1], [1, 0, 0])
        del buf28
        buf30 = buf29[0]
        del buf29
        buf33 = torch.ops.aten.max_pool3d_with_indices.default(buf32, [1, 3,
            1], [1, 1, 1], [0, 1, 0])
        del buf32
        buf34 = buf33[0]
        del buf33
        buf37 = torch.ops.aten.max_pool3d_with_indices.default(buf36, [1, 1,
            3], [1, 1, 1], [0, 0, 1])
        del buf36
        buf38 = buf37[0]
        del buf37
        buf40 = buf30
        del buf30
        triton_poi_fused_minimum_neg_3[grid(256)](buf40, buf38, buf34, 256,
            XBLOCK=256, num_warps=4, num_stages=1)
        buf41 = torch.ops.aten.max_pool3d_with_indices.default(buf40, [3, 3,
            3], [1, 1, 1], [1, 1, 1])
        buf42 = buf41[0]
        del buf41
        buf45 = torch.ops.aten.max_pool3d_with_indices.default(buf44, [3, 1,
            1], [1, 1, 1], [1, 0, 0])
        buf46 = buf45[0]
        del buf45
        buf49 = torch.ops.aten.max_pool3d_with_indices.default(buf48, [1, 3,
            1], [1, 1, 1], [0, 1, 0])
        buf50 = buf49[0]
        del buf49
        buf53 = torch.ops.aten.max_pool3d_with_indices.default(buf52, [1, 1,
            3], [1, 1, 1], [0, 0, 1])
        buf54 = buf53[0]
        del buf53
        buf56 = buf52
        del buf52
        buf60 = buf48
        del buf48
        buf64 = buf44
        del buf44
        buf72 = buf40
        del buf40
        buf76 = buf38
        del buf38
        buf80 = buf34
        del buf34
        triton_poi_fused_minimum_neg_2[grid(256)](buf46, buf54, buf50,
            buf56, buf60, buf64, buf72, buf76, buf80, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf57 = torch.ops.aten.max_pool3d_with_indices.default(buf56, [3, 1,
            1], [1, 1, 1], [1, 0, 0])
        del buf56
        buf58 = buf57[0]
        del buf57
        buf61 = torch.ops.aten.max_pool3d_with_indices.default(buf60, [1, 3,
            1], [1, 1, 1], [0, 1, 0])
        del buf60
        buf62 = buf61[0]
        del buf61
        buf65 = torch.ops.aten.max_pool3d_with_indices.default(buf64, [1, 1,
            3], [1, 1, 1], [0, 0, 1])
        del buf64
        buf66 = buf65[0]
        del buf65
        buf68 = buf58
        del buf58
        triton_poi_fused_minimum_neg_3[grid(256)](buf68, buf66, buf62, 256,
            XBLOCK=256, num_warps=4, num_stages=1)
        buf69 = torch.ops.aten.max_pool3d_with_indices.default(buf68, [3, 3,
            3], [1, 1, 1], [1, 1, 1])
        buf70 = buf69[0]
        del buf69
        buf73 = torch.ops.aten.max_pool3d_with_indices.default(buf72, [3, 1,
            1], [1, 1, 1], [1, 0, 0])
        buf74 = buf73[0]
        del buf73
        buf77 = torch.ops.aten.max_pool3d_with_indices.default(buf76, [1, 3,
            1], [1, 1, 1], [0, 1, 0])
        buf78 = buf77[0]
        del buf77
        buf81 = torch.ops.aten.max_pool3d_with_indices.default(buf80, [1, 1,
            3], [1, 1, 1], [0, 0, 1])
        buf82 = buf81[0]
        del buf81
        buf84 = buf80
        del buf80
        buf88 = buf76
        del buf76
        buf92 = buf72
        del buf72
        buf100 = buf68
        del buf68
        buf104 = buf66
        del buf66
        buf108 = buf62
        del buf62
        triton_poi_fused_minimum_neg_2[grid(256)](buf74, buf82, buf78,
            buf84, buf88, buf92, buf100, buf104, buf108, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf85 = torch.ops.aten.max_pool3d_with_indices.default(buf84, [3, 1,
            1], [1, 1, 1], [1, 0, 0])
        del buf84
        buf86 = buf85[0]
        del buf85
        buf89 = torch.ops.aten.max_pool3d_with_indices.default(buf88, [1, 3,
            1], [1, 1, 1], [0, 1, 0])
        del buf88
        buf90 = buf89[0]
        del buf89
        buf93 = torch.ops.aten.max_pool3d_with_indices.default(buf92, [1, 1,
            3], [1, 1, 1], [0, 0, 1])
        del buf92
        buf94 = buf93[0]
        del buf93
        buf96 = buf86
        del buf86
        triton_poi_fused_minimum_neg_3[grid(256)](buf96, buf94, buf90, 256,
            XBLOCK=256, num_warps=4, num_stages=1)
        buf97 = torch.ops.aten.max_pool3d_with_indices.default(buf96, [3, 3,
            3], [1, 1, 1], [1, 1, 1])
        buf98 = buf97[0]
        del buf97
        buf101 = torch.ops.aten.max_pool3d_with_indices.default(buf100, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf102 = buf101[0]
        del buf101
        buf105 = torch.ops.aten.max_pool3d_with_indices.default(buf104, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf106 = buf105[0]
        del buf105
        buf109 = torch.ops.aten.max_pool3d_with_indices.default(buf108, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf110 = buf109[0]
        del buf109
        buf112 = buf108
        del buf108
        buf116 = buf104
        del buf104
        buf120 = buf100
        del buf100
        buf128 = buf96
        del buf96
        buf132 = buf94
        del buf94
        buf136 = buf90
        del buf90
        triton_poi_fused_minimum_neg_2[grid(256)](buf102, buf110, buf106,
            buf112, buf116, buf120, buf128, buf132, buf136, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf113 = torch.ops.aten.max_pool3d_with_indices.default(buf112, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf112
        buf114 = buf113[0]
        del buf113
        buf117 = torch.ops.aten.max_pool3d_with_indices.default(buf116, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf116
        buf118 = buf117[0]
        del buf117
        buf121 = torch.ops.aten.max_pool3d_with_indices.default(buf120, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf120
        buf122 = buf121[0]
        del buf121
        buf124 = buf114
        del buf114
        triton_poi_fused_minimum_neg_3[grid(256)](buf124, buf122, buf118, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf125 = torch.ops.aten.max_pool3d_with_indices.default(buf124, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf126 = buf125[0]
        del buf125
        buf129 = torch.ops.aten.max_pool3d_with_indices.default(buf128, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf130 = buf129[0]
        del buf129
        buf133 = torch.ops.aten.max_pool3d_with_indices.default(buf132, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf134 = buf133[0]
        del buf133
        buf137 = torch.ops.aten.max_pool3d_with_indices.default(buf136, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf138 = buf137[0]
        del buf137
        buf140 = buf136
        del buf136
        buf144 = buf132
        del buf132
        buf148 = buf128
        del buf128
        buf156 = buf124
        del buf124
        buf160 = buf122
        del buf122
        buf164 = buf118
        del buf118
        triton_poi_fused_minimum_neg_2[grid(256)](buf130, buf138, buf134,
            buf140, buf144, buf148, buf156, buf160, buf164, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf141 = torch.ops.aten.max_pool3d_with_indices.default(buf140, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf140
        buf142 = buf141[0]
        del buf141
        buf145 = torch.ops.aten.max_pool3d_with_indices.default(buf144, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf144
        buf146 = buf145[0]
        del buf145
        buf149 = torch.ops.aten.max_pool3d_with_indices.default(buf148, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf148
        buf150 = buf149[0]
        del buf149
        buf152 = buf142
        del buf142
        triton_poi_fused_minimum_neg_3[grid(256)](buf152, buf150, buf146, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf153 = torch.ops.aten.max_pool3d_with_indices.default(buf152, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf154 = buf153[0]
        del buf153
        buf157 = torch.ops.aten.max_pool3d_with_indices.default(buf156, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf158 = buf157[0]
        del buf157
        buf161 = torch.ops.aten.max_pool3d_with_indices.default(buf160, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf162 = buf161[0]
        del buf161
        buf165 = torch.ops.aten.max_pool3d_with_indices.default(buf164, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf166 = buf165[0]
        del buf165
        buf168 = buf164
        del buf164
        buf172 = buf160
        del buf160
        buf176 = buf156
        del buf156
        buf184 = buf152
        del buf152
        buf188 = buf150
        del buf150
        buf192 = buf146
        del buf146
        triton_poi_fused_minimum_neg_2[grid(256)](buf158, buf166, buf162,
            buf168, buf172, buf176, buf184, buf188, buf192, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf169 = torch.ops.aten.max_pool3d_with_indices.default(buf168, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf168
        buf170 = buf169[0]
        del buf169
        buf173 = torch.ops.aten.max_pool3d_with_indices.default(buf172, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf172
        buf174 = buf173[0]
        del buf173
        buf177 = torch.ops.aten.max_pool3d_with_indices.default(buf176, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf176
        buf178 = buf177[0]
        del buf177
        buf180 = buf170
        del buf170
        triton_poi_fused_minimum_neg_3[grid(256)](buf180, buf178, buf174, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf181 = torch.ops.aten.max_pool3d_with_indices.default(buf180, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf182 = buf181[0]
        del buf181
        buf185 = torch.ops.aten.max_pool3d_with_indices.default(buf184, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf186 = buf185[0]
        del buf185
        buf189 = torch.ops.aten.max_pool3d_with_indices.default(buf188, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf190 = buf189[0]
        del buf189
        buf193 = torch.ops.aten.max_pool3d_with_indices.default(buf192, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf194 = buf193[0]
        del buf193
        buf196 = buf192
        del buf192
        buf200 = buf188
        del buf188
        buf204 = buf184
        del buf184
        buf212 = buf180
        del buf180
        buf216 = buf178
        del buf178
        buf220 = buf174
        del buf174
        triton_poi_fused_minimum_neg_2[grid(256)](buf186, buf194, buf190,
            buf196, buf200, buf204, buf212, buf216, buf220, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf197 = torch.ops.aten.max_pool3d_with_indices.default(buf196, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf196
        buf198 = buf197[0]
        del buf197
        buf201 = torch.ops.aten.max_pool3d_with_indices.default(buf200, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf200
        buf202 = buf201[0]
        del buf201
        buf205 = torch.ops.aten.max_pool3d_with_indices.default(buf204, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf204
        buf206 = buf205[0]
        del buf205
        buf208 = buf198
        del buf198
        triton_poi_fused_minimum_neg_3[grid(256)](buf208, buf206, buf202, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf209 = torch.ops.aten.max_pool3d_with_indices.default(buf208, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf210 = buf209[0]
        del buf209
        buf213 = torch.ops.aten.max_pool3d_with_indices.default(buf212, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf214 = buf213[0]
        del buf213
        buf217 = torch.ops.aten.max_pool3d_with_indices.default(buf216, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf218 = buf217[0]
        del buf217
        buf221 = torch.ops.aten.max_pool3d_with_indices.default(buf220, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf222 = buf221[0]
        del buf221
        buf224 = buf220
        del buf220
        buf228 = buf216
        del buf216
        buf232 = buf212
        del buf212
        buf240 = buf208
        del buf208
        buf244 = buf206
        del buf206
        buf248 = buf202
        del buf202
        triton_poi_fused_minimum_neg_2[grid(256)](buf214, buf222, buf218,
            buf224, buf228, buf232, buf240, buf244, buf248, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf225 = torch.ops.aten.max_pool3d_with_indices.default(buf224, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf224
        buf226 = buf225[0]
        del buf225
        buf229 = torch.ops.aten.max_pool3d_with_indices.default(buf228, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf228
        buf230 = buf229[0]
        del buf229
        buf233 = torch.ops.aten.max_pool3d_with_indices.default(buf232, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf232
        buf234 = buf233[0]
        del buf233
        buf236 = buf226
        del buf226
        triton_poi_fused_minimum_neg_3[grid(256)](buf236, buf234, buf230, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf237 = torch.ops.aten.max_pool3d_with_indices.default(buf236, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf238 = buf237[0]
        del buf237
        buf241 = torch.ops.aten.max_pool3d_with_indices.default(buf240, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf242 = buf241[0]
        del buf241
        buf245 = torch.ops.aten.max_pool3d_with_indices.default(buf244, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf246 = buf245[0]
        del buf245
        buf249 = torch.ops.aten.max_pool3d_with_indices.default(buf248, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf250 = buf249[0]
        del buf249
        buf252 = buf248
        del buf248
        buf256 = buf244
        del buf244
        buf260 = buf240
        del buf240
        buf268 = buf236
        del buf236
        buf272 = buf234
        del buf234
        buf276 = buf230
        del buf230
        triton_poi_fused_minimum_neg_2[grid(256)](buf242, buf250, buf246,
            buf252, buf256, buf260, buf268, buf272, buf276, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf253 = torch.ops.aten.max_pool3d_with_indices.default(buf252, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf252
        buf254 = buf253[0]
        del buf253
        buf257 = torch.ops.aten.max_pool3d_with_indices.default(buf256, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf256
        buf258 = buf257[0]
        del buf257
        buf261 = torch.ops.aten.max_pool3d_with_indices.default(buf260, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf260
        buf262 = buf261[0]
        del buf261
        buf264 = buf254
        del buf254
        triton_poi_fused_minimum_neg_3[grid(256)](buf264, buf262, buf258, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf265 = torch.ops.aten.max_pool3d_with_indices.default(buf264, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf266 = buf265[0]
        del buf265
        buf269 = torch.ops.aten.max_pool3d_with_indices.default(buf268, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf270 = buf269[0]
        del buf269
        buf273 = torch.ops.aten.max_pool3d_with_indices.default(buf272, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf274 = buf273[0]
        del buf273
        buf277 = torch.ops.aten.max_pool3d_with_indices.default(buf276, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf278 = buf277[0]
        del buf277
        buf280 = buf276
        del buf276
        buf284 = buf272
        del buf272
        buf288 = buf268
        del buf268
        buf296 = buf264
        del buf264
        buf300 = buf262
        del buf262
        buf304 = buf258
        del buf258
        triton_poi_fused_minimum_neg_2[grid(256)](buf270, buf278, buf274,
            buf280, buf284, buf288, buf296, buf300, buf304, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf281 = torch.ops.aten.max_pool3d_with_indices.default(buf280, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf280
        buf282 = buf281[0]
        del buf281
        buf285 = torch.ops.aten.max_pool3d_with_indices.default(buf284, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf284
        buf286 = buf285[0]
        del buf285
        buf289 = torch.ops.aten.max_pool3d_with_indices.default(buf288, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf288
        buf290 = buf289[0]
        del buf289
        buf292 = buf282
        del buf282
        triton_poi_fused_minimum_neg_3[grid(256)](buf292, buf290, buf286, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf293 = torch.ops.aten.max_pool3d_with_indices.default(buf292, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf294 = buf293[0]
        del buf293
        buf297 = torch.ops.aten.max_pool3d_with_indices.default(buf296, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf298 = buf297[0]
        del buf297
        buf301 = torch.ops.aten.max_pool3d_with_indices.default(buf300, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf302 = buf301[0]
        del buf301
        buf305 = torch.ops.aten.max_pool3d_with_indices.default(buf304, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf306 = buf305[0]
        del buf305
        buf308 = buf304
        del buf304
        buf312 = buf300
        del buf300
        buf316 = buf296
        del buf296
        buf324 = buf292
        del buf292
        buf328 = buf290
        del buf290
        buf332 = buf286
        del buf286
        triton_poi_fused_minimum_neg_2[grid(256)](buf298, buf306, buf302,
            buf308, buf312, buf316, buf324, buf328, buf332, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf309 = torch.ops.aten.max_pool3d_with_indices.default(buf308, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf308
        buf310 = buf309[0]
        del buf309
        buf313 = torch.ops.aten.max_pool3d_with_indices.default(buf312, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf312
        buf314 = buf313[0]
        del buf313
        buf317 = torch.ops.aten.max_pool3d_with_indices.default(buf316, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf316
        buf318 = buf317[0]
        del buf317
        buf320 = buf310
        del buf310
        triton_poi_fused_minimum_neg_3[grid(256)](buf320, buf318, buf314, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf321 = torch.ops.aten.max_pool3d_with_indices.default(buf320, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf322 = buf321[0]
        del buf321
        buf325 = torch.ops.aten.max_pool3d_with_indices.default(buf324, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf326 = buf325[0]
        del buf325
        buf329 = torch.ops.aten.max_pool3d_with_indices.default(buf328, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf330 = buf329[0]
        del buf329
        buf333 = torch.ops.aten.max_pool3d_with_indices.default(buf332, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf334 = buf333[0]
        del buf333
        buf336 = buf332
        del buf332
        buf340 = buf328
        del buf328
        buf344 = buf324
        del buf324
        buf352 = buf320
        del buf320
        buf356 = buf318
        del buf318
        buf360 = buf314
        del buf314
        triton_poi_fused_minimum_neg_2[grid(256)](buf326, buf334, buf330,
            buf336, buf340, buf344, buf352, buf356, buf360, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf337 = torch.ops.aten.max_pool3d_with_indices.default(buf336, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf336
        buf338 = buf337[0]
        del buf337
        buf341 = torch.ops.aten.max_pool3d_with_indices.default(buf340, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf340
        buf342 = buf341[0]
        del buf341
        buf345 = torch.ops.aten.max_pool3d_with_indices.default(buf344, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf344
        buf346 = buf345[0]
        del buf345
        buf348 = buf338
        del buf338
        triton_poi_fused_minimum_neg_3[grid(256)](buf348, buf346, buf342, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf349 = torch.ops.aten.max_pool3d_with_indices.default(buf348, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf350 = buf349[0]
        del buf349
        buf353 = torch.ops.aten.max_pool3d_with_indices.default(buf352, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf354 = buf353[0]
        del buf353
        buf357 = torch.ops.aten.max_pool3d_with_indices.default(buf356, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf358 = buf357[0]
        del buf357
        buf361 = torch.ops.aten.max_pool3d_with_indices.default(buf360, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf362 = buf361[0]
        del buf361
        buf364 = buf360
        del buf360
        buf368 = buf356
        del buf356
        buf372 = buf352
        del buf352
        buf380 = buf348
        del buf348
        buf384 = buf346
        del buf346
        buf388 = buf342
        del buf342
        triton_poi_fused_minimum_neg_2[grid(256)](buf354, buf362, buf358,
            buf364, buf368, buf372, buf380, buf384, buf388, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf365 = torch.ops.aten.max_pool3d_with_indices.default(buf364, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf364
        buf366 = buf365[0]
        del buf365
        buf369 = torch.ops.aten.max_pool3d_with_indices.default(buf368, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf368
        buf370 = buf369[0]
        del buf369
        buf373 = torch.ops.aten.max_pool3d_with_indices.default(buf372, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf372
        buf374 = buf373[0]
        del buf373
        buf376 = buf366
        del buf366
        triton_poi_fused_minimum_neg_3[grid(256)](buf376, buf374, buf370, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf377 = torch.ops.aten.max_pool3d_with_indices.default(buf376, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf378 = buf377[0]
        del buf377
        buf381 = torch.ops.aten.max_pool3d_with_indices.default(buf380, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf382 = buf381[0]
        del buf381
        buf385 = torch.ops.aten.max_pool3d_with_indices.default(buf384, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf386 = buf385[0]
        del buf385
        buf389 = torch.ops.aten.max_pool3d_with_indices.default(buf388, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf390 = buf389[0]
        del buf389
        buf392 = buf388
        del buf388
        buf396 = buf384
        del buf384
        buf400 = buf380
        del buf380
        buf408 = buf376
        del buf376
        buf412 = buf374
        del buf374
        buf416 = buf370
        del buf370
        triton_poi_fused_minimum_neg_2[grid(256)](buf382, buf390, buf386,
            buf392, buf396, buf400, buf408, buf412, buf416, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf393 = torch.ops.aten.max_pool3d_with_indices.default(buf392, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf392
        buf394 = buf393[0]
        del buf393
        buf397 = torch.ops.aten.max_pool3d_with_indices.default(buf396, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf396
        buf398 = buf397[0]
        del buf397
        buf401 = torch.ops.aten.max_pool3d_with_indices.default(buf400, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf400
        buf402 = buf401[0]
        del buf401
        buf404 = buf394
        del buf394
        triton_poi_fused_minimum_neg_3[grid(256)](buf404, buf402, buf398, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf405 = torch.ops.aten.max_pool3d_with_indices.default(buf404, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf406 = buf405[0]
        del buf405
        buf409 = torch.ops.aten.max_pool3d_with_indices.default(buf408, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf410 = buf409[0]
        del buf409
        buf413 = torch.ops.aten.max_pool3d_with_indices.default(buf412, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf414 = buf413[0]
        del buf413
        buf417 = torch.ops.aten.max_pool3d_with_indices.default(buf416, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf418 = buf417[0]
        del buf417
        buf420 = buf416
        del buf416
        buf424 = buf412
        del buf412
        buf428 = buf408
        del buf408
        buf436 = buf404
        del buf404
        buf440 = buf402
        del buf402
        buf444 = buf398
        del buf398
        triton_poi_fused_minimum_neg_2[grid(256)](buf410, buf418, buf414,
            buf420, buf424, buf428, buf436, buf440, buf444, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf421 = torch.ops.aten.max_pool3d_with_indices.default(buf420, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf420
        buf422 = buf421[0]
        del buf421
        buf425 = torch.ops.aten.max_pool3d_with_indices.default(buf424, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf424
        buf426 = buf425[0]
        del buf425
        buf429 = torch.ops.aten.max_pool3d_with_indices.default(buf428, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf428
        buf430 = buf429[0]
        del buf429
        buf432 = buf422
        del buf422
        triton_poi_fused_minimum_neg_3[grid(256)](buf432, buf430, buf426, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf433 = torch.ops.aten.max_pool3d_with_indices.default(buf432, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf434 = buf433[0]
        del buf433
        buf437 = torch.ops.aten.max_pool3d_with_indices.default(buf436, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf438 = buf437[0]
        del buf437
        buf441 = torch.ops.aten.max_pool3d_with_indices.default(buf440, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf442 = buf441[0]
        del buf441
        buf445 = torch.ops.aten.max_pool3d_with_indices.default(buf444, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf446 = buf445[0]
        del buf445
        buf448 = buf444
        del buf444
        buf452 = buf440
        del buf440
        buf456 = buf436
        del buf436
        buf464 = buf432
        del buf432
        buf468 = buf430
        del buf430
        buf472 = buf426
        del buf426
        triton_poi_fused_minimum_neg_2[grid(256)](buf438, buf446, buf442,
            buf448, buf452, buf456, buf464, buf468, buf472, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf449 = torch.ops.aten.max_pool3d_with_indices.default(buf448, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf448
        buf450 = buf449[0]
        del buf449
        buf453 = torch.ops.aten.max_pool3d_with_indices.default(buf452, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf452
        buf454 = buf453[0]
        del buf453
        buf457 = torch.ops.aten.max_pool3d_with_indices.default(buf456, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf456
        buf458 = buf457[0]
        del buf457
        buf460 = buf450
        del buf450
        triton_poi_fused_minimum_neg_3[grid(256)](buf460, buf458, buf454, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf461 = torch.ops.aten.max_pool3d_with_indices.default(buf460, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf462 = buf461[0]
        del buf461
        buf465 = torch.ops.aten.max_pool3d_with_indices.default(buf464, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf466 = buf465[0]
        del buf465
        buf469 = torch.ops.aten.max_pool3d_with_indices.default(buf468, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf470 = buf469[0]
        del buf469
        buf473 = torch.ops.aten.max_pool3d_with_indices.default(buf472, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf474 = buf473[0]
        del buf473
        buf476 = buf472
        del buf472
        buf480 = buf468
        del buf468
        buf484 = buf464
        del buf464
        buf492 = buf460
        del buf460
        buf496 = buf458
        del buf458
        buf500 = buf454
        del buf454
        triton_poi_fused_minimum_neg_2[grid(256)](buf466, buf474, buf470,
            buf476, buf480, buf484, buf492, buf496, buf500, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf477 = torch.ops.aten.max_pool3d_with_indices.default(buf476, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf476
        buf478 = buf477[0]
        del buf477
        buf481 = torch.ops.aten.max_pool3d_with_indices.default(buf480, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf480
        buf482 = buf481[0]
        del buf481
        buf485 = torch.ops.aten.max_pool3d_with_indices.default(buf484, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf484
        buf486 = buf485[0]
        del buf485
        buf488 = buf478
        del buf478
        triton_poi_fused_minimum_neg_3[grid(256)](buf488, buf486, buf482, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf489 = torch.ops.aten.max_pool3d_with_indices.default(buf488, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf490 = buf489[0]
        del buf489
        buf493 = torch.ops.aten.max_pool3d_with_indices.default(buf492, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf494 = buf493[0]
        del buf493
        buf497 = torch.ops.aten.max_pool3d_with_indices.default(buf496, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf498 = buf497[0]
        del buf497
        buf501 = torch.ops.aten.max_pool3d_with_indices.default(buf500, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf502 = buf501[0]
        del buf501
        buf504 = buf500
        del buf500
        buf508 = buf496
        del buf496
        buf512 = buf492
        del buf492
        buf520 = buf488
        del buf488
        buf524 = buf486
        del buf486
        buf528 = buf482
        del buf482
        triton_poi_fused_minimum_neg_2[grid(256)](buf494, buf502, buf498,
            buf504, buf508, buf512, buf520, buf524, buf528, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf505 = torch.ops.aten.max_pool3d_with_indices.default(buf504, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf504
        buf506 = buf505[0]
        del buf505
        buf509 = torch.ops.aten.max_pool3d_with_indices.default(buf508, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf508
        buf510 = buf509[0]
        del buf509
        buf513 = torch.ops.aten.max_pool3d_with_indices.default(buf512, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf512
        buf514 = buf513[0]
        del buf513
        buf516 = buf506
        del buf506
        triton_poi_fused_minimum_neg_3[grid(256)](buf516, buf514, buf510, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf517 = torch.ops.aten.max_pool3d_with_indices.default(buf516, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf518 = buf517[0]
        del buf517
        buf521 = torch.ops.aten.max_pool3d_with_indices.default(buf520, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf522 = buf521[0]
        del buf521
        buf525 = torch.ops.aten.max_pool3d_with_indices.default(buf524, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf526 = buf525[0]
        del buf525
        buf529 = torch.ops.aten.max_pool3d_with_indices.default(buf528, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf530 = buf529[0]
        del buf529
        buf532 = buf528
        del buf528
        buf536 = buf524
        del buf524
        buf540 = buf520
        del buf520
        buf548 = buf516
        del buf516
        buf552 = buf514
        del buf514
        buf556 = buf510
        del buf510
        triton_poi_fused_minimum_neg_2[grid(256)](buf522, buf530, buf526,
            buf532, buf536, buf540, buf548, buf552, buf556, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf533 = torch.ops.aten.max_pool3d_with_indices.default(buf532, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf532
        buf534 = buf533[0]
        del buf533
        buf537 = torch.ops.aten.max_pool3d_with_indices.default(buf536, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf536
        buf538 = buf537[0]
        del buf537
        buf541 = torch.ops.aten.max_pool3d_with_indices.default(buf540, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf540
        buf542 = buf541[0]
        del buf541
        buf544 = buf534
        del buf534
        triton_poi_fused_minimum_neg_3[grid(256)](buf544, buf542, buf538, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf545 = torch.ops.aten.max_pool3d_with_indices.default(buf544, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf546 = buf545[0]
        del buf545
        buf549 = torch.ops.aten.max_pool3d_with_indices.default(buf548, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf550 = buf549[0]
        del buf549
        buf553 = torch.ops.aten.max_pool3d_with_indices.default(buf552, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf554 = buf553[0]
        del buf553
        buf557 = torch.ops.aten.max_pool3d_with_indices.default(buf556, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf558 = buf557[0]
        del buf557
        buf560 = buf556
        del buf556
        buf564 = buf552
        del buf552
        buf568 = buf548
        del buf548
        buf576 = buf544
        del buf544
        buf580 = buf542
        del buf542
        buf584 = buf538
        del buf538
        triton_poi_fused_minimum_neg_2[grid(256)](buf550, buf558, buf554,
            buf560, buf564, buf568, buf576, buf580, buf584, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf561 = torch.ops.aten.max_pool3d_with_indices.default(buf560, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf560
        buf562 = buf561[0]
        del buf561
        buf565 = torch.ops.aten.max_pool3d_with_indices.default(buf564, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf564
        buf566 = buf565[0]
        del buf565
        buf569 = torch.ops.aten.max_pool3d_with_indices.default(buf568, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf568
        buf570 = buf569[0]
        del buf569
        buf572 = buf562
        del buf562
        triton_poi_fused_minimum_neg_3[grid(256)](buf572, buf570, buf566, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf573 = torch.ops.aten.max_pool3d_with_indices.default(buf572, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf574 = buf573[0]
        del buf573
        buf577 = torch.ops.aten.max_pool3d_with_indices.default(buf576, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf578 = buf577[0]
        del buf577
        buf581 = torch.ops.aten.max_pool3d_with_indices.default(buf580, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf582 = buf581[0]
        del buf581
        buf585 = torch.ops.aten.max_pool3d_with_indices.default(buf584, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf586 = buf585[0]
        del buf585
        buf588 = buf584
        del buf584
        buf592 = buf580
        del buf580
        buf596 = buf576
        del buf576
        buf604 = buf572
        del buf572
        buf608 = buf570
        del buf570
        buf612 = buf566
        del buf566
        triton_poi_fused_minimum_neg_2[grid(256)](buf578, buf586, buf582,
            buf588, buf592, buf596, buf604, buf608, buf612, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf589 = torch.ops.aten.max_pool3d_with_indices.default(buf588, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf588
        buf590 = buf589[0]
        del buf589
        buf593 = torch.ops.aten.max_pool3d_with_indices.default(buf592, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf592
        buf594 = buf593[0]
        del buf593
        buf597 = torch.ops.aten.max_pool3d_with_indices.default(buf596, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf596
        buf598 = buf597[0]
        del buf597
        buf600 = buf590
        del buf590
        triton_poi_fused_minimum_neg_3[grid(256)](buf600, buf598, buf594, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf601 = torch.ops.aten.max_pool3d_with_indices.default(buf600, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf602 = buf601[0]
        del buf601
        buf605 = torch.ops.aten.max_pool3d_with_indices.default(buf604, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf606 = buf605[0]
        del buf605
        buf609 = torch.ops.aten.max_pool3d_with_indices.default(buf608, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf610 = buf609[0]
        del buf609
        buf613 = torch.ops.aten.max_pool3d_with_indices.default(buf612, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf614 = buf613[0]
        del buf613
        buf616 = buf612
        del buf612
        buf620 = buf608
        del buf608
        buf624 = buf604
        del buf604
        buf632 = buf600
        del buf600
        buf636 = buf598
        del buf598
        buf640 = buf594
        del buf594
        triton_poi_fused_minimum_neg_2[grid(256)](buf606, buf614, buf610,
            buf616, buf620, buf624, buf632, buf636, buf640, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf617 = torch.ops.aten.max_pool3d_with_indices.default(buf616, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf616
        buf618 = buf617[0]
        del buf617
        buf621 = torch.ops.aten.max_pool3d_with_indices.default(buf620, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf620
        buf622 = buf621[0]
        del buf621
        buf625 = torch.ops.aten.max_pool3d_with_indices.default(buf624, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf624
        buf626 = buf625[0]
        del buf625
        buf628 = buf618
        del buf618
        triton_poi_fused_minimum_neg_3[grid(256)](buf628, buf626, buf622, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf629 = torch.ops.aten.max_pool3d_with_indices.default(buf628, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf630 = buf629[0]
        del buf629
        buf633 = torch.ops.aten.max_pool3d_with_indices.default(buf632, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf634 = buf633[0]
        del buf633
        buf637 = torch.ops.aten.max_pool3d_with_indices.default(buf636, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf638 = buf637[0]
        del buf637
        buf641 = torch.ops.aten.max_pool3d_with_indices.default(buf640, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf642 = buf641[0]
        del buf641
        buf644 = buf640
        del buf640
        buf648 = buf636
        del buf636
        buf652 = buf632
        del buf632
        buf660 = buf628
        del buf628
        buf664 = buf626
        del buf626
        buf668 = buf622
        del buf622
        triton_poi_fused_minimum_neg_2[grid(256)](buf634, buf642, buf638,
            buf644, buf648, buf652, buf660, buf664, buf668, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf645 = torch.ops.aten.max_pool3d_with_indices.default(buf644, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf644
        buf646 = buf645[0]
        del buf645
        buf649 = torch.ops.aten.max_pool3d_with_indices.default(buf648, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf648
        buf650 = buf649[0]
        del buf649
        buf653 = torch.ops.aten.max_pool3d_with_indices.default(buf652, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf652
        buf654 = buf653[0]
        del buf653
        buf656 = buf646
        del buf646
        triton_poi_fused_minimum_neg_3[grid(256)](buf656, buf654, buf650, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf657 = torch.ops.aten.max_pool3d_with_indices.default(buf656, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf658 = buf657[0]
        del buf657
        buf661 = torch.ops.aten.max_pool3d_with_indices.default(buf660, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf662 = buf661[0]
        del buf661
        buf665 = torch.ops.aten.max_pool3d_with_indices.default(buf664, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf666 = buf665[0]
        del buf665
        buf669 = torch.ops.aten.max_pool3d_with_indices.default(buf668, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf670 = buf669[0]
        del buf669
        buf672 = buf668
        del buf668
        buf676 = buf664
        del buf664
        buf680 = buf660
        del buf660
        buf688 = buf656
        del buf656
        buf692 = buf654
        del buf654
        buf696 = buf650
        del buf650
        triton_poi_fused_minimum_neg_2[grid(256)](buf662, buf670, buf666,
            buf672, buf676, buf680, buf688, buf692, buf696, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf673 = torch.ops.aten.max_pool3d_with_indices.default(buf672, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf672
        buf674 = buf673[0]
        del buf673
        buf677 = torch.ops.aten.max_pool3d_with_indices.default(buf676, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf676
        buf678 = buf677[0]
        del buf677
        buf681 = torch.ops.aten.max_pool3d_with_indices.default(buf680, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf680
        buf682 = buf681[0]
        del buf681
        buf684 = buf674
        del buf674
        triton_poi_fused_minimum_neg_3[grid(256)](buf684, buf682, buf678, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf685 = torch.ops.aten.max_pool3d_with_indices.default(buf684, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf686 = buf685[0]
        del buf685
        buf689 = torch.ops.aten.max_pool3d_with_indices.default(buf688, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf690 = buf689[0]
        del buf689
        buf693 = torch.ops.aten.max_pool3d_with_indices.default(buf692, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf694 = buf693[0]
        del buf693
        buf697 = torch.ops.aten.max_pool3d_with_indices.default(buf696, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf698 = buf697[0]
        del buf697
        buf700 = buf696
        del buf696
        buf704 = buf692
        del buf692
        buf708 = buf688
        del buf688
        buf716 = buf684
        del buf684
        buf720 = buf682
        del buf682
        buf724 = buf678
        del buf678
        triton_poi_fused_minimum_neg_2[grid(256)](buf690, buf698, buf694,
            buf700, buf704, buf708, buf716, buf720, buf724, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf701 = torch.ops.aten.max_pool3d_with_indices.default(buf700, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf700
        buf702 = buf701[0]
        del buf701
        buf705 = torch.ops.aten.max_pool3d_with_indices.default(buf704, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf704
        buf706 = buf705[0]
        del buf705
        buf709 = torch.ops.aten.max_pool3d_with_indices.default(buf708, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf708
        buf710 = buf709[0]
        del buf709
        buf712 = buf702
        del buf702
        triton_poi_fused_minimum_neg_3[grid(256)](buf712, buf710, buf706, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf713 = torch.ops.aten.max_pool3d_with_indices.default(buf712, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf714 = buf713[0]
        del buf713
        buf717 = torch.ops.aten.max_pool3d_with_indices.default(buf716, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf718 = buf717[0]
        del buf717
        buf721 = torch.ops.aten.max_pool3d_with_indices.default(buf720, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf722 = buf721[0]
        del buf721
        buf725 = torch.ops.aten.max_pool3d_with_indices.default(buf724, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf726 = buf725[0]
        del buf725
        buf728 = buf724
        del buf724
        buf732 = buf720
        del buf720
        buf736 = buf716
        del buf716
        buf744 = buf712
        del buf712
        buf748 = buf710
        del buf710
        buf752 = buf706
        del buf706
        triton_poi_fused_minimum_neg_2[grid(256)](buf718, buf726, buf722,
            buf728, buf732, buf736, buf744, buf748, buf752, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf729 = torch.ops.aten.max_pool3d_with_indices.default(buf728, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf728
        buf730 = buf729[0]
        del buf729
        buf733 = torch.ops.aten.max_pool3d_with_indices.default(buf732, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf732
        buf734 = buf733[0]
        del buf733
        buf737 = torch.ops.aten.max_pool3d_with_indices.default(buf736, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf736
        buf738 = buf737[0]
        del buf737
        buf740 = buf730
        del buf730
        triton_poi_fused_minimum_neg_3[grid(256)](buf740, buf738, buf734, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf741 = torch.ops.aten.max_pool3d_with_indices.default(buf740, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf742 = buf741[0]
        del buf741
        buf745 = torch.ops.aten.max_pool3d_with_indices.default(buf744, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf746 = buf745[0]
        del buf745
        buf749 = torch.ops.aten.max_pool3d_with_indices.default(buf748, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf750 = buf749[0]
        del buf749
        buf753 = torch.ops.aten.max_pool3d_with_indices.default(buf752, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf754 = buf753[0]
        del buf753
        buf756 = buf752
        del buf752
        buf760 = buf748
        del buf748
        buf764 = buf744
        del buf744
        buf772 = buf740
        del buf740
        buf776 = buf738
        del buf738
        buf780 = buf734
        del buf734
        triton_poi_fused_minimum_neg_2[grid(256)](buf746, buf754, buf750,
            buf756, buf760, buf764, buf772, buf776, buf780, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf757 = torch.ops.aten.max_pool3d_with_indices.default(buf756, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf756
        buf758 = buf757[0]
        del buf757
        buf761 = torch.ops.aten.max_pool3d_with_indices.default(buf760, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf760
        buf762 = buf761[0]
        del buf761
        buf765 = torch.ops.aten.max_pool3d_with_indices.default(buf764, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf764
        buf766 = buf765[0]
        del buf765
        buf768 = buf758
        del buf758
        triton_poi_fused_minimum_neg_3[grid(256)](buf768, buf766, buf762, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf769 = torch.ops.aten.max_pool3d_with_indices.default(buf768, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf770 = buf769[0]
        del buf769
        buf773 = torch.ops.aten.max_pool3d_with_indices.default(buf772, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf774 = buf773[0]
        del buf773
        buf777 = torch.ops.aten.max_pool3d_with_indices.default(buf776, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf778 = buf777[0]
        del buf777
        buf781 = torch.ops.aten.max_pool3d_with_indices.default(buf780, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf782 = buf781[0]
        del buf781
        buf784 = buf780
        del buf780
        buf788 = buf776
        del buf776
        buf792 = buf772
        del buf772
        buf800 = buf768
        del buf768
        buf804 = buf766
        del buf766
        buf808 = buf762
        del buf762
        triton_poi_fused_minimum_neg_2[grid(256)](buf774, buf782, buf778,
            buf784, buf788, buf792, buf800, buf804, buf808, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf785 = torch.ops.aten.max_pool3d_with_indices.default(buf784, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf784
        buf786 = buf785[0]
        del buf785
        buf789 = torch.ops.aten.max_pool3d_with_indices.default(buf788, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf788
        buf790 = buf789[0]
        del buf789
        buf793 = torch.ops.aten.max_pool3d_with_indices.default(buf792, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf792
        buf794 = buf793[0]
        del buf793
        buf796 = buf786
        del buf786
        triton_poi_fused_minimum_neg_3[grid(256)](buf796, buf794, buf790, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf797 = torch.ops.aten.max_pool3d_with_indices.default(buf796, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf798 = buf797[0]
        del buf797
        buf801 = torch.ops.aten.max_pool3d_with_indices.default(buf800, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf802 = buf801[0]
        del buf801
        buf805 = torch.ops.aten.max_pool3d_with_indices.default(buf804, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf806 = buf805[0]
        del buf805
        buf809 = torch.ops.aten.max_pool3d_with_indices.default(buf808, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf810 = buf809[0]
        del buf809
        buf812 = buf808
        del buf808
        buf816 = buf804
        del buf804
        buf820 = buf800
        del buf800
        buf828 = buf796
        del buf796
        buf832 = buf794
        del buf794
        buf836 = buf790
        del buf790
        triton_poi_fused_minimum_neg_2[grid(256)](buf802, buf810, buf806,
            buf812, buf816, buf820, buf828, buf832, buf836, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf813 = torch.ops.aten.max_pool3d_with_indices.default(buf812, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf812
        buf814 = buf813[0]
        del buf813
        buf817 = torch.ops.aten.max_pool3d_with_indices.default(buf816, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf816
        buf818 = buf817[0]
        del buf817
        buf821 = torch.ops.aten.max_pool3d_with_indices.default(buf820, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf820
        buf822 = buf821[0]
        del buf821
        buf824 = buf814
        del buf814
        triton_poi_fused_minimum_neg_3[grid(256)](buf824, buf822, buf818, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf825 = torch.ops.aten.max_pool3d_with_indices.default(buf824, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf826 = buf825[0]
        del buf825
        buf829 = torch.ops.aten.max_pool3d_with_indices.default(buf828, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf830 = buf829[0]
        del buf829
        buf833 = torch.ops.aten.max_pool3d_with_indices.default(buf832, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf834 = buf833[0]
        del buf833
        buf837 = torch.ops.aten.max_pool3d_with_indices.default(buf836, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf838 = buf837[0]
        del buf837
        buf840 = buf836
        del buf836
        buf844 = buf832
        del buf832
        buf848 = buf828
        del buf828
        buf856 = buf824
        del buf824
        buf860 = buf822
        del buf822
        buf864 = buf818
        del buf818
        triton_poi_fused_minimum_neg_2[grid(256)](buf830, buf838, buf834,
            buf840, buf844, buf848, buf856, buf860, buf864, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf841 = torch.ops.aten.max_pool3d_with_indices.default(buf840, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf840
        buf842 = buf841[0]
        del buf841
        buf845 = torch.ops.aten.max_pool3d_with_indices.default(buf844, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf844
        buf846 = buf845[0]
        del buf845
        buf849 = torch.ops.aten.max_pool3d_with_indices.default(buf848, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf848
        buf850 = buf849[0]
        del buf849
        buf852 = buf842
        del buf842
        triton_poi_fused_minimum_neg_3[grid(256)](buf852, buf850, buf846, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf853 = torch.ops.aten.max_pool3d_with_indices.default(buf852, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf854 = buf853[0]
        del buf853
        buf857 = torch.ops.aten.max_pool3d_with_indices.default(buf856, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf858 = buf857[0]
        del buf857
        buf861 = torch.ops.aten.max_pool3d_with_indices.default(buf860, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf862 = buf861[0]
        del buf861
        buf865 = torch.ops.aten.max_pool3d_with_indices.default(buf864, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf866 = buf865[0]
        del buf865
        buf868 = buf864
        del buf864
        buf872 = buf860
        del buf860
        buf876 = buf856
        del buf856
        buf884 = buf852
        del buf852
        buf888 = buf850
        del buf850
        buf892 = buf846
        del buf846
        triton_poi_fused_minimum_neg_2[grid(256)](buf858, buf866, buf862,
            buf868, buf872, buf876, buf884, buf888, buf892, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf869 = torch.ops.aten.max_pool3d_with_indices.default(buf868, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf868
        buf870 = buf869[0]
        del buf869
        buf873 = torch.ops.aten.max_pool3d_with_indices.default(buf872, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf872
        buf874 = buf873[0]
        del buf873
        buf877 = torch.ops.aten.max_pool3d_with_indices.default(buf876, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf876
        buf878 = buf877[0]
        del buf877
        buf880 = buf870
        del buf870
        triton_poi_fused_minimum_neg_3[grid(256)](buf880, buf878, buf874, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf881 = torch.ops.aten.max_pool3d_with_indices.default(buf880, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf882 = buf881[0]
        del buf881
        buf885 = torch.ops.aten.max_pool3d_with_indices.default(buf884, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf886 = buf885[0]
        del buf885
        buf889 = torch.ops.aten.max_pool3d_with_indices.default(buf888, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf890 = buf889[0]
        del buf889
        buf893 = torch.ops.aten.max_pool3d_with_indices.default(buf892, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf894 = buf893[0]
        del buf893
        buf896 = buf892
        del buf892
        buf900 = buf888
        del buf888
        buf904 = buf884
        del buf884
        buf912 = buf880
        del buf880
        buf916 = buf878
        del buf878
        buf920 = buf874
        del buf874
        triton_poi_fused_minimum_neg_2[grid(256)](buf886, buf894, buf890,
            buf896, buf900, buf904, buf912, buf916, buf920, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf897 = torch.ops.aten.max_pool3d_with_indices.default(buf896, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf896
        buf898 = buf897[0]
        del buf897
        buf901 = torch.ops.aten.max_pool3d_with_indices.default(buf900, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf900
        buf902 = buf901[0]
        del buf901
        buf905 = torch.ops.aten.max_pool3d_with_indices.default(buf904, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf904
        buf906 = buf905[0]
        del buf905
        buf908 = buf898
        del buf898
        triton_poi_fused_minimum_neg_3[grid(256)](buf908, buf906, buf902, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf909 = torch.ops.aten.max_pool3d_with_indices.default(buf908, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf910 = buf909[0]
        del buf909
        buf913 = torch.ops.aten.max_pool3d_with_indices.default(buf912, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf914 = buf913[0]
        del buf913
        buf917 = torch.ops.aten.max_pool3d_with_indices.default(buf916, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf918 = buf917[0]
        del buf917
        buf921 = torch.ops.aten.max_pool3d_with_indices.default(buf920, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf922 = buf921[0]
        del buf921
        buf924 = buf920
        del buf920
        buf928 = buf916
        del buf916
        buf932 = buf912
        del buf912
        buf940 = buf908
        del buf908
        buf944 = buf906
        del buf906
        buf948 = buf902
        del buf902
        triton_poi_fused_minimum_neg_2[grid(256)](buf914, buf922, buf918,
            buf924, buf928, buf932, buf940, buf944, buf948, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf925 = torch.ops.aten.max_pool3d_with_indices.default(buf924, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf924
        buf926 = buf925[0]
        del buf925
        buf929 = torch.ops.aten.max_pool3d_with_indices.default(buf928, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf928
        buf930 = buf929[0]
        del buf929
        buf933 = torch.ops.aten.max_pool3d_with_indices.default(buf932, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf932
        buf934 = buf933[0]
        del buf933
        buf936 = buf926
        del buf926
        triton_poi_fused_minimum_neg_3[grid(256)](buf936, buf934, buf930, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf937 = torch.ops.aten.max_pool3d_with_indices.default(buf936, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf938 = buf937[0]
        del buf937
        buf941 = torch.ops.aten.max_pool3d_with_indices.default(buf940, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf942 = buf941[0]
        del buf941
        buf945 = torch.ops.aten.max_pool3d_with_indices.default(buf944, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf946 = buf945[0]
        del buf945
        buf949 = torch.ops.aten.max_pool3d_with_indices.default(buf948, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf950 = buf949[0]
        del buf949
        buf952 = buf948
        del buf948
        buf956 = buf944
        del buf944
        buf960 = buf940
        del buf940
        buf968 = buf936
        del buf936
        buf972 = buf934
        del buf934
        buf976 = buf930
        del buf930
        triton_poi_fused_minimum_neg_2[grid(256)](buf942, buf950, buf946,
            buf952, buf956, buf960, buf968, buf972, buf976, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        buf953 = torch.ops.aten.max_pool3d_with_indices.default(buf952, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf952
        buf954 = buf953[0]
        del buf953
        buf957 = torch.ops.aten.max_pool3d_with_indices.default(buf956, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf956
        buf958 = buf957[0]
        del buf957
        buf961 = torch.ops.aten.max_pool3d_with_indices.default(buf960, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf960
        buf962 = buf961[0]
        del buf961
        buf964 = buf954
        del buf954
        triton_poi_fused_minimum_neg_3[grid(256)](buf964, buf962, buf958, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf965 = torch.ops.aten.max_pool3d_with_indices.default(buf964, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf966 = buf965[0]
        del buf965
        buf969 = torch.ops.aten.max_pool3d_with_indices.default(buf968, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf970 = buf969[0]
        del buf969
        buf973 = torch.ops.aten.max_pool3d_with_indices.default(buf972, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        buf974 = buf973[0]
        del buf973
        buf977 = torch.ops.aten.max_pool3d_with_indices.default(buf976, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        buf978 = buf977[0]
        del buf977
        buf980 = buf976
        del buf976
        buf984 = buf972
        del buf972
        buf988 = buf968
        del buf968
        buf996 = buf964
        del buf964
        buf1000 = buf962
        del buf962
        buf1004 = buf958
        del buf958
        triton_poi_fused_minimum_neg_2[grid(256)](buf970, buf978, buf974,
            buf980, buf984, buf988, buf996, buf1000, buf1004, 256, XBLOCK=
            128, num_warps=4, num_stages=1)
        buf981 = torch.ops.aten.max_pool3d_with_indices.default(buf980, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        del buf980
        buf982 = buf981[0]
        del buf981
        buf985 = torch.ops.aten.max_pool3d_with_indices.default(buf984, [1,
            3, 1], [1, 1, 1], [0, 1, 0])
        del buf984
        buf986 = buf985[0]
        del buf985
        buf989 = torch.ops.aten.max_pool3d_with_indices.default(buf988, [1,
            1, 3], [1, 1, 1], [0, 0, 1])
        del buf988
        buf990 = buf989[0]
        del buf989
        buf992 = buf982
        del buf982
        triton_poi_fused_minimum_neg_3[grid(256)](buf992, buf990, buf986, 
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf993 = torch.ops.aten.max_pool3d_with_indices.default(buf992, [3,
            3, 3], [1, 1, 1], [1, 1, 1])
        buf994 = buf993[0]
        del buf993
        buf997 = torch.ops.aten.max_pool3d_with_indices.default(buf996, [3,
            1, 1], [1, 1, 1], [1, 0, 0])
        buf998 = buf997[0]
        del buf997
        buf1001 = torch.ops.aten.max_pool3d_with_indices.default(buf1000, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1002 = buf1001[0]
        del buf1001
        buf1005 = torch.ops.aten.max_pool3d_with_indices.default(buf1004, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1006 = buf1005[0]
        del buf1005
        buf1008 = buf1004
        del buf1004
        buf1012 = buf1000
        del buf1000
        buf1016 = buf996
        del buf996
        buf1024 = buf992
        del buf992
        buf1028 = buf990
        del buf990
        buf1032 = buf986
        del buf986
        triton_poi_fused_minimum_neg_2[grid(256)](buf998, buf1006, buf1002,
            buf1008, buf1012, buf1016, buf1024, buf1028, buf1032, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1009 = torch.ops.aten.max_pool3d_with_indices.default(buf1008, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1008
        buf1010 = buf1009[0]
        del buf1009
        buf1013 = torch.ops.aten.max_pool3d_with_indices.default(buf1012, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1012
        buf1014 = buf1013[0]
        del buf1013
        buf1017 = torch.ops.aten.max_pool3d_with_indices.default(buf1016, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1016
        buf1018 = buf1017[0]
        del buf1017
        buf1020 = buf1010
        del buf1010
        triton_poi_fused_minimum_neg_3[grid(256)](buf1020, buf1018, buf1014,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1021 = torch.ops.aten.max_pool3d_with_indices.default(buf1020, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1022 = buf1021[0]
        del buf1021
        buf1025 = torch.ops.aten.max_pool3d_with_indices.default(buf1024, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1026 = buf1025[0]
        del buf1025
        buf1029 = torch.ops.aten.max_pool3d_with_indices.default(buf1028, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1030 = buf1029[0]
        del buf1029
        buf1033 = torch.ops.aten.max_pool3d_with_indices.default(buf1032, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1034 = buf1033[0]
        del buf1033
        buf1036 = buf1032
        del buf1032
        buf1040 = buf1028
        del buf1028
        buf1044 = buf1024
        del buf1024
        buf1052 = buf1020
        del buf1020
        buf1056 = buf1018
        del buf1018
        buf1060 = buf1014
        del buf1014
        triton_poi_fused_minimum_neg_2[grid(256)](buf1026, buf1034, buf1030,
            buf1036, buf1040, buf1044, buf1052, buf1056, buf1060, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1037 = torch.ops.aten.max_pool3d_with_indices.default(buf1036, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1036
        buf1038 = buf1037[0]
        del buf1037
        buf1041 = torch.ops.aten.max_pool3d_with_indices.default(buf1040, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1040
        buf1042 = buf1041[0]
        del buf1041
        buf1045 = torch.ops.aten.max_pool3d_with_indices.default(buf1044, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1044
        buf1046 = buf1045[0]
        del buf1045
        buf1048 = buf1038
        del buf1038
        triton_poi_fused_minimum_neg_3[grid(256)](buf1048, buf1046, buf1042,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1049 = torch.ops.aten.max_pool3d_with_indices.default(buf1048, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1050 = buf1049[0]
        del buf1049
        buf1053 = torch.ops.aten.max_pool3d_with_indices.default(buf1052, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1054 = buf1053[0]
        del buf1053
        buf1057 = torch.ops.aten.max_pool3d_with_indices.default(buf1056, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1058 = buf1057[0]
        del buf1057
        buf1061 = torch.ops.aten.max_pool3d_with_indices.default(buf1060, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1062 = buf1061[0]
        del buf1061
        buf1064 = buf1060
        del buf1060
        buf1068 = buf1056
        del buf1056
        buf1072 = buf1052
        del buf1052
        buf1080 = buf1048
        del buf1048
        buf1084 = buf1046
        del buf1046
        buf1088 = buf1042
        del buf1042
        triton_poi_fused_minimum_neg_2[grid(256)](buf1054, buf1062, buf1058,
            buf1064, buf1068, buf1072, buf1080, buf1084, buf1088, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1065 = torch.ops.aten.max_pool3d_with_indices.default(buf1064, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1064
        buf1066 = buf1065[0]
        del buf1065
        buf1069 = torch.ops.aten.max_pool3d_with_indices.default(buf1068, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1068
        buf1070 = buf1069[0]
        del buf1069
        buf1073 = torch.ops.aten.max_pool3d_with_indices.default(buf1072, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1072
        buf1074 = buf1073[0]
        del buf1073
        buf1076 = buf1066
        del buf1066
        triton_poi_fused_minimum_neg_3[grid(256)](buf1076, buf1074, buf1070,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1077 = torch.ops.aten.max_pool3d_with_indices.default(buf1076, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1078 = buf1077[0]
        del buf1077
        buf1081 = torch.ops.aten.max_pool3d_with_indices.default(buf1080, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1082 = buf1081[0]
        del buf1081
        buf1085 = torch.ops.aten.max_pool3d_with_indices.default(buf1084, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1086 = buf1085[0]
        del buf1085
        buf1089 = torch.ops.aten.max_pool3d_with_indices.default(buf1088, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1090 = buf1089[0]
        del buf1089
        buf1092 = buf1088
        del buf1088
        buf1096 = buf1084
        del buf1084
        buf1100 = buf1080
        del buf1080
        buf1108 = buf1076
        del buf1076
        buf1112 = buf1074
        del buf1074
        buf1116 = buf1070
        del buf1070
        triton_poi_fused_minimum_neg_2[grid(256)](buf1082, buf1090, buf1086,
            buf1092, buf1096, buf1100, buf1108, buf1112, buf1116, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1093 = torch.ops.aten.max_pool3d_with_indices.default(buf1092, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1092
        buf1094 = buf1093[0]
        del buf1093
        buf1097 = torch.ops.aten.max_pool3d_with_indices.default(buf1096, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1096
        buf1098 = buf1097[0]
        del buf1097
        buf1101 = torch.ops.aten.max_pool3d_with_indices.default(buf1100, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1100
        buf1102 = buf1101[0]
        del buf1101
        buf1104 = buf1094
        del buf1094
        triton_poi_fused_minimum_neg_3[grid(256)](buf1104, buf1102, buf1098,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1105 = torch.ops.aten.max_pool3d_with_indices.default(buf1104, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1106 = buf1105[0]
        del buf1105
        buf1109 = torch.ops.aten.max_pool3d_with_indices.default(buf1108, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1110 = buf1109[0]
        del buf1109
        buf1113 = torch.ops.aten.max_pool3d_with_indices.default(buf1112, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1114 = buf1113[0]
        del buf1113
        buf1117 = torch.ops.aten.max_pool3d_with_indices.default(buf1116, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1118 = buf1117[0]
        del buf1117
        buf1120 = buf1116
        del buf1116
        buf1124 = buf1112
        del buf1112
        buf1128 = buf1108
        del buf1108
        buf1136 = buf1104
        del buf1104
        buf1140 = buf1102
        del buf1102
        buf1144 = buf1098
        del buf1098
        triton_poi_fused_minimum_neg_2[grid(256)](buf1110, buf1118, buf1114,
            buf1120, buf1124, buf1128, buf1136, buf1140, buf1144, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1121 = torch.ops.aten.max_pool3d_with_indices.default(buf1120, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1120
        buf1122 = buf1121[0]
        del buf1121
        buf1125 = torch.ops.aten.max_pool3d_with_indices.default(buf1124, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1124
        buf1126 = buf1125[0]
        del buf1125
        buf1129 = torch.ops.aten.max_pool3d_with_indices.default(buf1128, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1128
        buf1130 = buf1129[0]
        del buf1129
        buf1132 = buf1122
        del buf1122
        triton_poi_fused_minimum_neg_3[grid(256)](buf1132, buf1130, buf1126,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1133 = torch.ops.aten.max_pool3d_with_indices.default(buf1132, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1134 = buf1133[0]
        del buf1133
        buf1137 = torch.ops.aten.max_pool3d_with_indices.default(buf1136, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1138 = buf1137[0]
        del buf1137
        buf1141 = torch.ops.aten.max_pool3d_with_indices.default(buf1140, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1142 = buf1141[0]
        del buf1141
        buf1145 = torch.ops.aten.max_pool3d_with_indices.default(buf1144, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1146 = buf1145[0]
        del buf1145
        buf1148 = buf1144
        del buf1144
        buf1152 = buf1140
        del buf1140
        buf1156 = buf1136
        del buf1136
        buf1164 = buf1132
        del buf1132
        buf1168 = buf1130
        del buf1130
        buf1172 = buf1126
        del buf1126
        triton_poi_fused_minimum_neg_2[grid(256)](buf1138, buf1146, buf1142,
            buf1148, buf1152, buf1156, buf1164, buf1168, buf1172, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1149 = torch.ops.aten.max_pool3d_with_indices.default(buf1148, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1148
        buf1150 = buf1149[0]
        del buf1149
        buf1153 = torch.ops.aten.max_pool3d_with_indices.default(buf1152, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1152
        buf1154 = buf1153[0]
        del buf1153
        buf1157 = torch.ops.aten.max_pool3d_with_indices.default(buf1156, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1156
        buf1158 = buf1157[0]
        del buf1157
        buf1160 = buf1150
        del buf1150
        triton_poi_fused_minimum_neg_3[grid(256)](buf1160, buf1158, buf1154,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1161 = torch.ops.aten.max_pool3d_with_indices.default(buf1160, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1162 = buf1161[0]
        del buf1161
        buf1165 = torch.ops.aten.max_pool3d_with_indices.default(buf1164, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1166 = buf1165[0]
        del buf1165
        buf1169 = torch.ops.aten.max_pool3d_with_indices.default(buf1168, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1170 = buf1169[0]
        del buf1169
        buf1173 = torch.ops.aten.max_pool3d_with_indices.default(buf1172, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1174 = buf1173[0]
        del buf1173
        buf1176 = buf1172
        del buf1172
        buf1180 = buf1168
        del buf1168
        buf1184 = buf1164
        del buf1164
        buf1192 = buf1160
        del buf1160
        buf1196 = buf1158
        del buf1158
        buf1200 = buf1154
        del buf1154
        triton_poi_fused_minimum_neg_2[grid(256)](buf1166, buf1174, buf1170,
            buf1176, buf1180, buf1184, buf1192, buf1196, buf1200, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1177 = torch.ops.aten.max_pool3d_with_indices.default(buf1176, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1176
        buf1178 = buf1177[0]
        del buf1177
        buf1181 = torch.ops.aten.max_pool3d_with_indices.default(buf1180, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1180
        buf1182 = buf1181[0]
        del buf1181
        buf1185 = torch.ops.aten.max_pool3d_with_indices.default(buf1184, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1184
        buf1186 = buf1185[0]
        del buf1185
        buf1188 = buf1178
        del buf1178
        triton_poi_fused_minimum_neg_3[grid(256)](buf1188, buf1186, buf1182,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1189 = torch.ops.aten.max_pool3d_with_indices.default(buf1188, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1190 = buf1189[0]
        del buf1189
        buf1193 = torch.ops.aten.max_pool3d_with_indices.default(buf1192, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1194 = buf1193[0]
        del buf1193
        buf1197 = torch.ops.aten.max_pool3d_with_indices.default(buf1196, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1198 = buf1197[0]
        del buf1197
        buf1201 = torch.ops.aten.max_pool3d_with_indices.default(buf1200, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1202 = buf1201[0]
        del buf1201
        buf1204 = buf1200
        del buf1200
        buf1208 = buf1196
        del buf1196
        buf1212 = buf1192
        del buf1192
        buf1220 = buf1188
        del buf1188
        buf1224 = buf1186
        del buf1186
        buf1228 = buf1182
        del buf1182
        triton_poi_fused_minimum_neg_2[grid(256)](buf1194, buf1202, buf1198,
            buf1204, buf1208, buf1212, buf1220, buf1224, buf1228, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1205 = torch.ops.aten.max_pool3d_with_indices.default(buf1204, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1204
        buf1206 = buf1205[0]
        del buf1205
        buf1209 = torch.ops.aten.max_pool3d_with_indices.default(buf1208, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1208
        buf1210 = buf1209[0]
        del buf1209
        buf1213 = torch.ops.aten.max_pool3d_with_indices.default(buf1212, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1212
        buf1214 = buf1213[0]
        del buf1213
        buf1216 = buf1206
        del buf1206
        triton_poi_fused_minimum_neg_3[grid(256)](buf1216, buf1214, buf1210,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1217 = torch.ops.aten.max_pool3d_with_indices.default(buf1216, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1218 = buf1217[0]
        del buf1217
        buf1221 = torch.ops.aten.max_pool3d_with_indices.default(buf1220, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1222 = buf1221[0]
        del buf1221
        buf1225 = torch.ops.aten.max_pool3d_with_indices.default(buf1224, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1226 = buf1225[0]
        del buf1225
        buf1229 = torch.ops.aten.max_pool3d_with_indices.default(buf1228, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1230 = buf1229[0]
        del buf1229
        buf1232 = buf1228
        del buf1228
        buf1236 = buf1224
        del buf1224
        buf1240 = buf1220
        del buf1220
        buf1248 = buf1216
        del buf1216
        buf1252 = buf1214
        del buf1214
        buf1256 = buf1210
        del buf1210
        triton_poi_fused_minimum_neg_2[grid(256)](buf1222, buf1230, buf1226,
            buf1232, buf1236, buf1240, buf1248, buf1252, buf1256, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1233 = torch.ops.aten.max_pool3d_with_indices.default(buf1232, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1232
        buf1234 = buf1233[0]
        del buf1233
        buf1237 = torch.ops.aten.max_pool3d_with_indices.default(buf1236, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1236
        buf1238 = buf1237[0]
        del buf1237
        buf1241 = torch.ops.aten.max_pool3d_with_indices.default(buf1240, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1240
        buf1242 = buf1241[0]
        del buf1241
        buf1244 = buf1234
        del buf1234
        triton_poi_fused_minimum_neg_3[grid(256)](buf1244, buf1242, buf1238,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1245 = torch.ops.aten.max_pool3d_with_indices.default(buf1244, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1246 = buf1245[0]
        del buf1245
        buf1249 = torch.ops.aten.max_pool3d_with_indices.default(buf1248, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1250 = buf1249[0]
        del buf1249
        buf1253 = torch.ops.aten.max_pool3d_with_indices.default(buf1252, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1254 = buf1253[0]
        del buf1253
        buf1257 = torch.ops.aten.max_pool3d_with_indices.default(buf1256, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1258 = buf1257[0]
        del buf1257
        buf1260 = buf1256
        del buf1256
        buf1264 = buf1252
        del buf1252
        buf1268 = buf1248
        del buf1248
        buf1276 = buf1244
        del buf1244
        buf1280 = buf1242
        del buf1242
        buf1284 = buf1238
        del buf1238
        triton_poi_fused_minimum_neg_2[grid(256)](buf1250, buf1258, buf1254,
            buf1260, buf1264, buf1268, buf1276, buf1280, buf1284, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1261 = torch.ops.aten.max_pool3d_with_indices.default(buf1260, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1260
        buf1262 = buf1261[0]
        del buf1261
        buf1265 = torch.ops.aten.max_pool3d_with_indices.default(buf1264, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1264
        buf1266 = buf1265[0]
        del buf1265
        buf1269 = torch.ops.aten.max_pool3d_with_indices.default(buf1268, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1268
        buf1270 = buf1269[0]
        del buf1269
        buf1272 = buf1262
        del buf1262
        triton_poi_fused_minimum_neg_3[grid(256)](buf1272, buf1270, buf1266,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1273 = torch.ops.aten.max_pool3d_with_indices.default(buf1272, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1274 = buf1273[0]
        del buf1273
        buf1277 = torch.ops.aten.max_pool3d_with_indices.default(buf1276, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1278 = buf1277[0]
        del buf1277
        buf1281 = torch.ops.aten.max_pool3d_with_indices.default(buf1280, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1282 = buf1281[0]
        del buf1281
        buf1285 = torch.ops.aten.max_pool3d_with_indices.default(buf1284, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1286 = buf1285[0]
        del buf1285
        buf1288 = buf1284
        del buf1284
        buf1292 = buf1280
        del buf1280
        buf1296 = buf1276
        del buf1276
        buf1304 = buf1272
        del buf1272
        buf1308 = buf1270
        del buf1270
        buf1312 = buf1266
        del buf1266
        triton_poi_fused_minimum_neg_2[grid(256)](buf1278, buf1286, buf1282,
            buf1288, buf1292, buf1296, buf1304, buf1308, buf1312, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1289 = torch.ops.aten.max_pool3d_with_indices.default(buf1288, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1288
        buf1290 = buf1289[0]
        del buf1289
        buf1293 = torch.ops.aten.max_pool3d_with_indices.default(buf1292, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1292
        buf1294 = buf1293[0]
        del buf1293
        buf1297 = torch.ops.aten.max_pool3d_with_indices.default(buf1296, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1296
        buf1298 = buf1297[0]
        del buf1297
        buf1300 = buf1290
        del buf1290
        triton_poi_fused_minimum_neg_3[grid(256)](buf1300, buf1298, buf1294,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1301 = torch.ops.aten.max_pool3d_with_indices.default(buf1300, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1302 = buf1301[0]
        del buf1301
        buf1305 = torch.ops.aten.max_pool3d_with_indices.default(buf1304, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1306 = buf1305[0]
        del buf1305
        buf1309 = torch.ops.aten.max_pool3d_with_indices.default(buf1308, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1310 = buf1309[0]
        del buf1309
        buf1313 = torch.ops.aten.max_pool3d_with_indices.default(buf1312, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1314 = buf1313[0]
        del buf1313
        buf1316 = buf1312
        del buf1312
        buf1320 = buf1308
        del buf1308
        buf1324 = buf1304
        del buf1304
        buf1332 = buf1300
        del buf1300
        buf1336 = buf1298
        del buf1298
        buf1340 = buf1294
        del buf1294
        triton_poi_fused_minimum_neg_2[grid(256)](buf1306, buf1314, buf1310,
            buf1316, buf1320, buf1324, buf1332, buf1336, buf1340, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1317 = torch.ops.aten.max_pool3d_with_indices.default(buf1316, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1316
        buf1318 = buf1317[0]
        del buf1317
        buf1321 = torch.ops.aten.max_pool3d_with_indices.default(buf1320, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1320
        buf1322 = buf1321[0]
        del buf1321
        buf1325 = torch.ops.aten.max_pool3d_with_indices.default(buf1324, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1324
        buf1326 = buf1325[0]
        del buf1325
        buf1328 = buf1318
        del buf1318
        triton_poi_fused_minimum_neg_3[grid(256)](buf1328, buf1326, buf1322,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1329 = torch.ops.aten.max_pool3d_with_indices.default(buf1328, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1330 = buf1329[0]
        del buf1329
        buf1333 = torch.ops.aten.max_pool3d_with_indices.default(buf1332, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1334 = buf1333[0]
        del buf1333
        buf1337 = torch.ops.aten.max_pool3d_with_indices.default(buf1336, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1338 = buf1337[0]
        del buf1337
        buf1341 = torch.ops.aten.max_pool3d_with_indices.default(buf1340, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1342 = buf1341[0]
        del buf1341
        buf1344 = buf1340
        del buf1340
        buf1348 = buf1336
        del buf1336
        buf1352 = buf1332
        del buf1332
        buf1360 = buf1328
        del buf1328
        buf1364 = buf1326
        del buf1326
        buf1368 = buf1322
        del buf1322
        triton_poi_fused_minimum_neg_2[grid(256)](buf1334, buf1342, buf1338,
            buf1344, buf1348, buf1352, buf1360, buf1364, buf1368, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1345 = torch.ops.aten.max_pool3d_with_indices.default(buf1344, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1344
        buf1346 = buf1345[0]
        del buf1345
        buf1349 = torch.ops.aten.max_pool3d_with_indices.default(buf1348, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1348
        buf1350 = buf1349[0]
        del buf1349
        buf1353 = torch.ops.aten.max_pool3d_with_indices.default(buf1352, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1352
        buf1354 = buf1353[0]
        del buf1353
        buf1356 = buf1346
        del buf1346
        triton_poi_fused_minimum_neg_3[grid(256)](buf1356, buf1354, buf1350,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1357 = torch.ops.aten.max_pool3d_with_indices.default(buf1356, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1358 = buf1357[0]
        del buf1357
        buf1361 = torch.ops.aten.max_pool3d_with_indices.default(buf1360, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1362 = buf1361[0]
        del buf1361
        buf1365 = torch.ops.aten.max_pool3d_with_indices.default(buf1364, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1366 = buf1365[0]
        del buf1365
        buf1369 = torch.ops.aten.max_pool3d_with_indices.default(buf1368, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1370 = buf1369[0]
        del buf1369
        buf1372 = buf1368
        del buf1368
        buf1376 = buf1364
        del buf1364
        buf1380 = buf1360
        del buf1360
        buf1388 = buf1356
        del buf1356
        buf1392 = buf1354
        del buf1354
        buf1396 = buf1350
        del buf1350
        triton_poi_fused_minimum_neg_2[grid(256)](buf1362, buf1370, buf1366,
            buf1372, buf1376, buf1380, buf1388, buf1392, buf1396, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1373 = torch.ops.aten.max_pool3d_with_indices.default(buf1372, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1372
        buf1374 = buf1373[0]
        del buf1373
        buf1377 = torch.ops.aten.max_pool3d_with_indices.default(buf1376, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1376
        buf1378 = buf1377[0]
        del buf1377
        buf1381 = torch.ops.aten.max_pool3d_with_indices.default(buf1380, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1380
        buf1382 = buf1381[0]
        del buf1381
        buf1384 = buf1374
        del buf1374
        triton_poi_fused_minimum_neg_3[grid(256)](buf1384, buf1382, buf1378,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        del buf1378
        del buf1382
        buf1385 = torch.ops.aten.max_pool3d_with_indices.default(buf1384, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        del buf1384
        buf1386 = buf1385[0]
        del buf1385
        buf1389 = torch.ops.aten.max_pool3d_with_indices.default(buf1388, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1390 = buf1389[0]
        del buf1389
        buf1393 = torch.ops.aten.max_pool3d_with_indices.default(buf1392, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1394 = buf1393[0]
        del buf1393
        buf1397 = torch.ops.aten.max_pool3d_with_indices.default(buf1396, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1398 = buf1397[0]
        del buf1397
        buf1400 = buf1396
        del buf1396
        buf1404 = buf1392
        del buf1392
        buf1408 = buf1388
        del buf1388
        triton_poi_fused_minimum_neg_4[grid(256)](buf1390, buf1398, buf1394,
            buf1400, buf1404, buf1408, 256, XBLOCK=256, num_warps=4,
            num_stages=1)
        buf1401 = torch.ops.aten.max_pool3d_with_indices.default(buf1400, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1402 = buf1401[0]
        del buf1401
        buf1405 = torch.ops.aten.max_pool3d_with_indices.default(buf1404, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1406 = buf1405[0]
        del buf1405
        buf1409 = torch.ops.aten.max_pool3d_with_indices.default(buf1408, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1410 = buf1409[0]
        del buf1409
        buf1412 = buf1402
        del buf1402
        triton_poi_fused_minimum_neg_3[grid(256)](buf1412, buf1410, buf1406,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1413 = torch.ops.aten.max_pool3d_with_indices.default(buf1412, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1414 = buf1413[0]
        del buf1413
        buf1416 = buf1412
        del buf1412
        buf1420 = buf1410
        del buf1410
        buf1424 = buf1406
        del buf1406
        buf1432 = buf1408
        del buf1408
        buf1436 = buf1404
        del buf1404
        buf1440 = buf1400
        del buf1400
        triton_poi_fused_neg_0[grid(256)](arg1_1, buf1416, buf1420, buf1424,
            buf1432, buf1436, buf1440, 256, XBLOCK=128, num_warps=4,
            num_stages=1)
        buf1417 = torch.ops.aten.max_pool3d_with_indices.default(buf1416, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1416
        buf1418 = buf1417[0]
        del buf1417
        buf1421 = torch.ops.aten.max_pool3d_with_indices.default(buf1420, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1420
        buf1422 = buf1421[0]
        del buf1421
        buf1425 = torch.ops.aten.max_pool3d_with_indices.default(buf1424, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1424
        buf1426 = buf1425[0]
        del buf1425
        buf1428 = buf1418
        del buf1418
        triton_poi_fused_minimum_neg_3[grid(256)](buf1428, buf1426, buf1422,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1429 = torch.ops.aten.max_pool3d_with_indices.default(buf1428, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1430 = buf1429[0]
        del buf1429
        buf1433 = torch.ops.aten.max_pool3d_with_indices.default(buf1432, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1434 = buf1433[0]
        del buf1433
        buf1437 = torch.ops.aten.max_pool3d_with_indices.default(buf1436, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1438 = buf1437[0]
        del buf1437
        buf1441 = torch.ops.aten.max_pool3d_with_indices.default(buf1440, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1442 = buf1441[0]
        del buf1441
        buf1444 = buf1440
        del buf1440
        buf1448 = buf1436
        del buf1436
        buf1452 = buf1432
        del buf1432
        buf1460 = buf1428
        del buf1428
        buf1464 = buf1426
        del buf1426
        buf1468 = buf1422
        del buf1422
        triton_poi_fused_minimum_neg_2[grid(256)](buf1434, buf1442, buf1438,
            buf1444, buf1448, buf1452, buf1460, buf1464, buf1468, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1445 = torch.ops.aten.max_pool3d_with_indices.default(buf1444, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1444
        buf1446 = buf1445[0]
        del buf1445
        buf1449 = torch.ops.aten.max_pool3d_with_indices.default(buf1448, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1448
        buf1450 = buf1449[0]
        del buf1449
        buf1453 = torch.ops.aten.max_pool3d_with_indices.default(buf1452, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1452
        buf1454 = buf1453[0]
        del buf1453
        buf1456 = buf1446
        del buf1446
        triton_poi_fused_minimum_neg_3[grid(256)](buf1456, buf1454, buf1450,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1457 = torch.ops.aten.max_pool3d_with_indices.default(buf1456, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1458 = buf1457[0]
        del buf1457
        buf1461 = torch.ops.aten.max_pool3d_with_indices.default(buf1460, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1462 = buf1461[0]
        del buf1461
        buf1465 = torch.ops.aten.max_pool3d_with_indices.default(buf1464, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1466 = buf1465[0]
        del buf1465
        buf1469 = torch.ops.aten.max_pool3d_with_indices.default(buf1468, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1470 = buf1469[0]
        del buf1469
        buf1472 = buf1468
        del buf1468
        buf1476 = buf1464
        del buf1464
        buf1480 = buf1460
        del buf1460
        buf1488 = buf1456
        del buf1456
        buf1492 = buf1454
        del buf1454
        buf1496 = buf1450
        del buf1450
        triton_poi_fused_minimum_neg_2[grid(256)](buf1462, buf1470, buf1466,
            buf1472, buf1476, buf1480, buf1488, buf1492, buf1496, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1473 = torch.ops.aten.max_pool3d_with_indices.default(buf1472, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1472
        buf1474 = buf1473[0]
        del buf1473
        buf1477 = torch.ops.aten.max_pool3d_with_indices.default(buf1476, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1476
        buf1478 = buf1477[0]
        del buf1477
        buf1481 = torch.ops.aten.max_pool3d_with_indices.default(buf1480, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1480
        buf1482 = buf1481[0]
        del buf1481
        buf1484 = buf1474
        del buf1474
        triton_poi_fused_minimum_neg_3[grid(256)](buf1484, buf1482, buf1478,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1485 = torch.ops.aten.max_pool3d_with_indices.default(buf1484, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1486 = buf1485[0]
        del buf1485
        buf1489 = torch.ops.aten.max_pool3d_with_indices.default(buf1488, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1490 = buf1489[0]
        del buf1489
        buf1493 = torch.ops.aten.max_pool3d_with_indices.default(buf1492, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1494 = buf1493[0]
        del buf1493
        buf1497 = torch.ops.aten.max_pool3d_with_indices.default(buf1496, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1498 = buf1497[0]
        del buf1497
        buf1500 = buf1496
        del buf1496
        buf1504 = buf1492
        del buf1492
        buf1508 = buf1488
        del buf1488
        buf1516 = buf1484
        del buf1484
        buf1520 = buf1482
        del buf1482
        buf1524 = buf1478
        del buf1478
        triton_poi_fused_minimum_neg_2[grid(256)](buf1490, buf1498, buf1494,
            buf1500, buf1504, buf1508, buf1516, buf1520, buf1524, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1501 = torch.ops.aten.max_pool3d_with_indices.default(buf1500, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1500
        buf1502 = buf1501[0]
        del buf1501
        buf1505 = torch.ops.aten.max_pool3d_with_indices.default(buf1504, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1504
        buf1506 = buf1505[0]
        del buf1505
        buf1509 = torch.ops.aten.max_pool3d_with_indices.default(buf1508, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1508
        buf1510 = buf1509[0]
        del buf1509
        buf1512 = buf1502
        del buf1502
        triton_poi_fused_minimum_neg_3[grid(256)](buf1512, buf1510, buf1506,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1513 = torch.ops.aten.max_pool3d_with_indices.default(buf1512, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1514 = buf1513[0]
        del buf1513
        buf1517 = torch.ops.aten.max_pool3d_with_indices.default(buf1516, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1518 = buf1517[0]
        del buf1517
        buf1521 = torch.ops.aten.max_pool3d_with_indices.default(buf1520, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1522 = buf1521[0]
        del buf1521
        buf1525 = torch.ops.aten.max_pool3d_with_indices.default(buf1524, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1526 = buf1525[0]
        del buf1525
        buf1528 = buf1524
        del buf1524
        buf1532 = buf1520
        del buf1520
        buf1536 = buf1516
        del buf1516
        buf1544 = buf1512
        del buf1512
        buf1548 = buf1510
        del buf1510
        buf1552 = buf1506
        del buf1506
        triton_poi_fused_minimum_neg_2[grid(256)](buf1518, buf1526, buf1522,
            buf1528, buf1532, buf1536, buf1544, buf1548, buf1552, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1529 = torch.ops.aten.max_pool3d_with_indices.default(buf1528, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1528
        buf1530 = buf1529[0]
        del buf1529
        buf1533 = torch.ops.aten.max_pool3d_with_indices.default(buf1532, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1532
        buf1534 = buf1533[0]
        del buf1533
        buf1537 = torch.ops.aten.max_pool3d_with_indices.default(buf1536, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1536
        buf1538 = buf1537[0]
        del buf1537
        buf1540 = buf1530
        del buf1530
        triton_poi_fused_minimum_neg_3[grid(256)](buf1540, buf1538, buf1534,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1541 = torch.ops.aten.max_pool3d_with_indices.default(buf1540, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1542 = buf1541[0]
        del buf1541
        buf1545 = torch.ops.aten.max_pool3d_with_indices.default(buf1544, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1546 = buf1545[0]
        del buf1545
        buf1549 = torch.ops.aten.max_pool3d_with_indices.default(buf1548, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1550 = buf1549[0]
        del buf1549
        buf1553 = torch.ops.aten.max_pool3d_with_indices.default(buf1552, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1554 = buf1553[0]
        del buf1553
        buf1556 = buf1552
        del buf1552
        buf1560 = buf1548
        del buf1548
        buf1564 = buf1544
        del buf1544
        buf1572 = buf1540
        del buf1540
        buf1576 = buf1538
        del buf1538
        buf1580 = buf1534
        del buf1534
        triton_poi_fused_minimum_neg_2[grid(256)](buf1546, buf1554, buf1550,
            buf1556, buf1560, buf1564, buf1572, buf1576, buf1580, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1557 = torch.ops.aten.max_pool3d_with_indices.default(buf1556, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1556
        buf1558 = buf1557[0]
        del buf1557
        buf1561 = torch.ops.aten.max_pool3d_with_indices.default(buf1560, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1560
        buf1562 = buf1561[0]
        del buf1561
        buf1565 = torch.ops.aten.max_pool3d_with_indices.default(buf1564, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1564
        buf1566 = buf1565[0]
        del buf1565
        buf1568 = buf1558
        del buf1558
        triton_poi_fused_minimum_neg_3[grid(256)](buf1568, buf1566, buf1562,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1569 = torch.ops.aten.max_pool3d_with_indices.default(buf1568, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1570 = buf1569[0]
        del buf1569
        buf1573 = torch.ops.aten.max_pool3d_with_indices.default(buf1572, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1574 = buf1573[0]
        del buf1573
        buf1577 = torch.ops.aten.max_pool3d_with_indices.default(buf1576, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1578 = buf1577[0]
        del buf1577
        buf1581 = torch.ops.aten.max_pool3d_with_indices.default(buf1580, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1582 = buf1581[0]
        del buf1581
        buf1584 = buf1580
        del buf1580
        buf1588 = buf1576
        del buf1576
        buf1592 = buf1572
        del buf1572
        buf1600 = buf1568
        del buf1568
        buf1604 = buf1566
        del buf1566
        buf1608 = buf1562
        del buf1562
        triton_poi_fused_minimum_neg_2[grid(256)](buf1574, buf1582, buf1578,
            buf1584, buf1588, buf1592, buf1600, buf1604, buf1608, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1585 = torch.ops.aten.max_pool3d_with_indices.default(buf1584, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1584
        buf1586 = buf1585[0]
        del buf1585
        buf1589 = torch.ops.aten.max_pool3d_with_indices.default(buf1588, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1588
        buf1590 = buf1589[0]
        del buf1589
        buf1593 = torch.ops.aten.max_pool3d_with_indices.default(buf1592, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1592
        buf1594 = buf1593[0]
        del buf1593
        buf1596 = buf1586
        del buf1586
        triton_poi_fused_minimum_neg_3[grid(256)](buf1596, buf1594, buf1590,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1597 = torch.ops.aten.max_pool3d_with_indices.default(buf1596, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1598 = buf1597[0]
        del buf1597
        buf1601 = torch.ops.aten.max_pool3d_with_indices.default(buf1600, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1602 = buf1601[0]
        del buf1601
        buf1605 = torch.ops.aten.max_pool3d_with_indices.default(buf1604, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1606 = buf1605[0]
        del buf1605
        buf1609 = torch.ops.aten.max_pool3d_with_indices.default(buf1608, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1610 = buf1609[0]
        del buf1609
        buf1612 = buf1608
        del buf1608
        buf1616 = buf1604
        del buf1604
        buf1620 = buf1600
        del buf1600
        buf1628 = buf1596
        del buf1596
        buf1632 = buf1594
        del buf1594
        buf1636 = buf1590
        del buf1590
        triton_poi_fused_minimum_neg_2[grid(256)](buf1602, buf1610, buf1606,
            buf1612, buf1616, buf1620, buf1628, buf1632, buf1636, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1613 = torch.ops.aten.max_pool3d_with_indices.default(buf1612, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1612
        buf1614 = buf1613[0]
        del buf1613
        buf1617 = torch.ops.aten.max_pool3d_with_indices.default(buf1616, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1616
        buf1618 = buf1617[0]
        del buf1617
        buf1621 = torch.ops.aten.max_pool3d_with_indices.default(buf1620, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1620
        buf1622 = buf1621[0]
        del buf1621
        buf1624 = buf1614
        del buf1614
        triton_poi_fused_minimum_neg_3[grid(256)](buf1624, buf1622, buf1618,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1625 = torch.ops.aten.max_pool3d_with_indices.default(buf1624, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1626 = buf1625[0]
        del buf1625
        buf1629 = torch.ops.aten.max_pool3d_with_indices.default(buf1628, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1630 = buf1629[0]
        del buf1629
        buf1633 = torch.ops.aten.max_pool3d_with_indices.default(buf1632, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1634 = buf1633[0]
        del buf1633
        buf1637 = torch.ops.aten.max_pool3d_with_indices.default(buf1636, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1638 = buf1637[0]
        del buf1637
        buf1640 = buf1636
        del buf1636
        buf1644 = buf1632
        del buf1632
        buf1648 = buf1628
        del buf1628
        buf1656 = buf1624
        del buf1624
        buf1660 = buf1622
        del buf1622
        buf1664 = buf1618
        del buf1618
        triton_poi_fused_minimum_neg_2[grid(256)](buf1630, buf1638, buf1634,
            buf1640, buf1644, buf1648, buf1656, buf1660, buf1664, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1641 = torch.ops.aten.max_pool3d_with_indices.default(buf1640, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1640
        buf1642 = buf1641[0]
        del buf1641
        buf1645 = torch.ops.aten.max_pool3d_with_indices.default(buf1644, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1644
        buf1646 = buf1645[0]
        del buf1645
        buf1649 = torch.ops.aten.max_pool3d_with_indices.default(buf1648, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1648
        buf1650 = buf1649[0]
        del buf1649
        buf1652 = buf1642
        del buf1642
        triton_poi_fused_minimum_neg_3[grid(256)](buf1652, buf1650, buf1646,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1653 = torch.ops.aten.max_pool3d_with_indices.default(buf1652, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1654 = buf1653[0]
        del buf1653
        buf1657 = torch.ops.aten.max_pool3d_with_indices.default(buf1656, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1658 = buf1657[0]
        del buf1657
        buf1661 = torch.ops.aten.max_pool3d_with_indices.default(buf1660, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1662 = buf1661[0]
        del buf1661
        buf1665 = torch.ops.aten.max_pool3d_with_indices.default(buf1664, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1666 = buf1665[0]
        del buf1665
        buf1668 = buf1664
        del buf1664
        buf1672 = buf1660
        del buf1660
        buf1676 = buf1656
        del buf1656
        buf1684 = buf1652
        del buf1652
        buf1688 = buf1650
        del buf1650
        buf1692 = buf1646
        del buf1646
        triton_poi_fused_minimum_neg_2[grid(256)](buf1658, buf1666, buf1662,
            buf1668, buf1672, buf1676, buf1684, buf1688, buf1692, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1669 = torch.ops.aten.max_pool3d_with_indices.default(buf1668, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1668
        buf1670 = buf1669[0]
        del buf1669
        buf1673 = torch.ops.aten.max_pool3d_with_indices.default(buf1672, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1672
        buf1674 = buf1673[0]
        del buf1673
        buf1677 = torch.ops.aten.max_pool3d_with_indices.default(buf1676, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1676
        buf1678 = buf1677[0]
        del buf1677
        buf1680 = buf1670
        del buf1670
        triton_poi_fused_minimum_neg_3[grid(256)](buf1680, buf1678, buf1674,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1681 = torch.ops.aten.max_pool3d_with_indices.default(buf1680, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1682 = buf1681[0]
        del buf1681
        buf1685 = torch.ops.aten.max_pool3d_with_indices.default(buf1684, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1686 = buf1685[0]
        del buf1685
        buf1689 = torch.ops.aten.max_pool3d_with_indices.default(buf1688, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1690 = buf1689[0]
        del buf1689
        buf1693 = torch.ops.aten.max_pool3d_with_indices.default(buf1692, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1694 = buf1693[0]
        del buf1693
        buf1696 = buf1692
        del buf1692
        buf1700 = buf1688
        del buf1688
        buf1704 = buf1684
        del buf1684
        buf1712 = buf1680
        del buf1680
        buf1716 = buf1678
        del buf1678
        buf1720 = buf1674
        del buf1674
        triton_poi_fused_minimum_neg_2[grid(256)](buf1686, buf1694, buf1690,
            buf1696, buf1700, buf1704, buf1712, buf1716, buf1720, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1697 = torch.ops.aten.max_pool3d_with_indices.default(buf1696, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1696
        buf1698 = buf1697[0]
        del buf1697
        buf1701 = torch.ops.aten.max_pool3d_with_indices.default(buf1700, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1700
        buf1702 = buf1701[0]
        del buf1701
        buf1705 = torch.ops.aten.max_pool3d_with_indices.default(buf1704, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1704
        buf1706 = buf1705[0]
        del buf1705
        buf1708 = buf1698
        del buf1698
        triton_poi_fused_minimum_neg_3[grid(256)](buf1708, buf1706, buf1702,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1709 = torch.ops.aten.max_pool3d_with_indices.default(buf1708, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1710 = buf1709[0]
        del buf1709
        buf1713 = torch.ops.aten.max_pool3d_with_indices.default(buf1712, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1714 = buf1713[0]
        del buf1713
        buf1717 = torch.ops.aten.max_pool3d_with_indices.default(buf1716, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1718 = buf1717[0]
        del buf1717
        buf1721 = torch.ops.aten.max_pool3d_with_indices.default(buf1720, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1722 = buf1721[0]
        del buf1721
        buf1724 = buf1720
        del buf1720
        buf1728 = buf1716
        del buf1716
        buf1732 = buf1712
        del buf1712
        buf1740 = buf1708
        del buf1708
        buf1744 = buf1706
        del buf1706
        buf1748 = buf1702
        del buf1702
        triton_poi_fused_minimum_neg_2[grid(256)](buf1714, buf1722, buf1718,
            buf1724, buf1728, buf1732, buf1740, buf1744, buf1748, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1725 = torch.ops.aten.max_pool3d_with_indices.default(buf1724, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1724
        buf1726 = buf1725[0]
        del buf1725
        buf1729 = torch.ops.aten.max_pool3d_with_indices.default(buf1728, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1728
        buf1730 = buf1729[0]
        del buf1729
        buf1733 = torch.ops.aten.max_pool3d_with_indices.default(buf1732, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1732
        buf1734 = buf1733[0]
        del buf1733
        buf1736 = buf1726
        del buf1726
        triton_poi_fused_minimum_neg_3[grid(256)](buf1736, buf1734, buf1730,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1737 = torch.ops.aten.max_pool3d_with_indices.default(buf1736, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1738 = buf1737[0]
        del buf1737
        buf1741 = torch.ops.aten.max_pool3d_with_indices.default(buf1740, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1742 = buf1741[0]
        del buf1741
        buf1745 = torch.ops.aten.max_pool3d_with_indices.default(buf1744, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1746 = buf1745[0]
        del buf1745
        buf1749 = torch.ops.aten.max_pool3d_with_indices.default(buf1748, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1750 = buf1749[0]
        del buf1749
        buf1752 = buf1748
        del buf1748
        buf1756 = buf1744
        del buf1744
        buf1760 = buf1740
        del buf1740
        buf1768 = buf1736
        del buf1736
        buf1772 = buf1734
        del buf1734
        buf1776 = buf1730
        del buf1730
        triton_poi_fused_minimum_neg_2[grid(256)](buf1742, buf1750, buf1746,
            buf1752, buf1756, buf1760, buf1768, buf1772, buf1776, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1753 = torch.ops.aten.max_pool3d_with_indices.default(buf1752, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1752
        buf1754 = buf1753[0]
        del buf1753
        buf1757 = torch.ops.aten.max_pool3d_with_indices.default(buf1756, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1756
        buf1758 = buf1757[0]
        del buf1757
        buf1761 = torch.ops.aten.max_pool3d_with_indices.default(buf1760, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1760
        buf1762 = buf1761[0]
        del buf1761
        buf1764 = buf1754
        del buf1754
        triton_poi_fused_minimum_neg_3[grid(256)](buf1764, buf1762, buf1758,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1765 = torch.ops.aten.max_pool3d_with_indices.default(buf1764, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1766 = buf1765[0]
        del buf1765
        buf1769 = torch.ops.aten.max_pool3d_with_indices.default(buf1768, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1770 = buf1769[0]
        del buf1769
        buf1773 = torch.ops.aten.max_pool3d_with_indices.default(buf1772, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1774 = buf1773[0]
        del buf1773
        buf1777 = torch.ops.aten.max_pool3d_with_indices.default(buf1776, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1778 = buf1777[0]
        del buf1777
        buf1780 = buf1776
        del buf1776
        buf1784 = buf1772
        del buf1772
        buf1788 = buf1768
        del buf1768
        buf1796 = buf1764
        del buf1764
        buf1800 = buf1762
        del buf1762
        buf1804 = buf1758
        del buf1758
        triton_poi_fused_minimum_neg_2[grid(256)](buf1770, buf1778, buf1774,
            buf1780, buf1784, buf1788, buf1796, buf1800, buf1804, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1781 = torch.ops.aten.max_pool3d_with_indices.default(buf1780, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1780
        buf1782 = buf1781[0]
        del buf1781
        buf1785 = torch.ops.aten.max_pool3d_with_indices.default(buf1784, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1784
        buf1786 = buf1785[0]
        del buf1785
        buf1789 = torch.ops.aten.max_pool3d_with_indices.default(buf1788, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1788
        buf1790 = buf1789[0]
        del buf1789
        buf1792 = buf1782
        del buf1782
        triton_poi_fused_minimum_neg_3[grid(256)](buf1792, buf1790, buf1786,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1793 = torch.ops.aten.max_pool3d_with_indices.default(buf1792, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1794 = buf1793[0]
        del buf1793
        buf1797 = torch.ops.aten.max_pool3d_with_indices.default(buf1796, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1798 = buf1797[0]
        del buf1797
        buf1801 = torch.ops.aten.max_pool3d_with_indices.default(buf1800, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1802 = buf1801[0]
        del buf1801
        buf1805 = torch.ops.aten.max_pool3d_with_indices.default(buf1804, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1806 = buf1805[0]
        del buf1805
        buf1808 = buf1804
        del buf1804
        buf1812 = buf1800
        del buf1800
        buf1816 = buf1796
        del buf1796
        buf1824 = buf1792
        del buf1792
        buf1828 = buf1790
        del buf1790
        buf1832 = buf1786
        del buf1786
        triton_poi_fused_minimum_neg_2[grid(256)](buf1798, buf1806, buf1802,
            buf1808, buf1812, buf1816, buf1824, buf1828, buf1832, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1809 = torch.ops.aten.max_pool3d_with_indices.default(buf1808, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1808
        buf1810 = buf1809[0]
        del buf1809
        buf1813 = torch.ops.aten.max_pool3d_with_indices.default(buf1812, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1812
        buf1814 = buf1813[0]
        del buf1813
        buf1817 = torch.ops.aten.max_pool3d_with_indices.default(buf1816, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1816
        buf1818 = buf1817[0]
        del buf1817
        buf1820 = buf1810
        del buf1810
        triton_poi_fused_minimum_neg_3[grid(256)](buf1820, buf1818, buf1814,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1821 = torch.ops.aten.max_pool3d_with_indices.default(buf1820, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1822 = buf1821[0]
        del buf1821
        buf1825 = torch.ops.aten.max_pool3d_with_indices.default(buf1824, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1826 = buf1825[0]
        del buf1825
        buf1829 = torch.ops.aten.max_pool3d_with_indices.default(buf1828, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1830 = buf1829[0]
        del buf1829
        buf1833 = torch.ops.aten.max_pool3d_with_indices.default(buf1832, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1834 = buf1833[0]
        del buf1833
        buf1836 = buf1832
        del buf1832
        buf1840 = buf1828
        del buf1828
        buf1844 = buf1824
        del buf1824
        buf1852 = buf1820
        del buf1820
        buf1856 = buf1818
        del buf1818
        buf1860 = buf1814
        del buf1814
        triton_poi_fused_minimum_neg_2[grid(256)](buf1826, buf1834, buf1830,
            buf1836, buf1840, buf1844, buf1852, buf1856, buf1860, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1837 = torch.ops.aten.max_pool3d_with_indices.default(buf1836, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1836
        buf1838 = buf1837[0]
        del buf1837
        buf1841 = torch.ops.aten.max_pool3d_with_indices.default(buf1840, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1840
        buf1842 = buf1841[0]
        del buf1841
        buf1845 = torch.ops.aten.max_pool3d_with_indices.default(buf1844, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1844
        buf1846 = buf1845[0]
        del buf1845
        buf1848 = buf1838
        del buf1838
        triton_poi_fused_minimum_neg_3[grid(256)](buf1848, buf1846, buf1842,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1849 = torch.ops.aten.max_pool3d_with_indices.default(buf1848, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1850 = buf1849[0]
        del buf1849
        buf1853 = torch.ops.aten.max_pool3d_with_indices.default(buf1852, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1854 = buf1853[0]
        del buf1853
        buf1857 = torch.ops.aten.max_pool3d_with_indices.default(buf1856, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1858 = buf1857[0]
        del buf1857
        buf1861 = torch.ops.aten.max_pool3d_with_indices.default(buf1860, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1862 = buf1861[0]
        del buf1861
        buf1864 = buf1860
        del buf1860
        buf1868 = buf1856
        del buf1856
        buf1872 = buf1852
        del buf1852
        buf1880 = buf1848
        del buf1848
        buf1884 = buf1846
        del buf1846
        buf1888 = buf1842
        del buf1842
        triton_poi_fused_minimum_neg_2[grid(256)](buf1854, buf1862, buf1858,
            buf1864, buf1868, buf1872, buf1880, buf1884, buf1888, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1865 = torch.ops.aten.max_pool3d_with_indices.default(buf1864, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1864
        buf1866 = buf1865[0]
        del buf1865
        buf1869 = torch.ops.aten.max_pool3d_with_indices.default(buf1868, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1868
        buf1870 = buf1869[0]
        del buf1869
        buf1873 = torch.ops.aten.max_pool3d_with_indices.default(buf1872, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1872
        buf1874 = buf1873[0]
        del buf1873
        buf1876 = buf1866
        del buf1866
        triton_poi_fused_minimum_neg_3[grid(256)](buf1876, buf1874, buf1870,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1877 = torch.ops.aten.max_pool3d_with_indices.default(buf1876, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1878 = buf1877[0]
        del buf1877
        buf1881 = torch.ops.aten.max_pool3d_with_indices.default(buf1880, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1882 = buf1881[0]
        del buf1881
        buf1885 = torch.ops.aten.max_pool3d_with_indices.default(buf1884, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1886 = buf1885[0]
        del buf1885
        buf1889 = torch.ops.aten.max_pool3d_with_indices.default(buf1888, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1890 = buf1889[0]
        del buf1889
        buf1892 = buf1888
        del buf1888
        buf1896 = buf1884
        del buf1884
        buf1900 = buf1880
        del buf1880
        buf1908 = buf1876
        del buf1876
        buf1912 = buf1874
        del buf1874
        buf1916 = buf1870
        del buf1870
        triton_poi_fused_minimum_neg_2[grid(256)](buf1882, buf1890, buf1886,
            buf1892, buf1896, buf1900, buf1908, buf1912, buf1916, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1893 = torch.ops.aten.max_pool3d_with_indices.default(buf1892, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1892
        buf1894 = buf1893[0]
        del buf1893
        buf1897 = torch.ops.aten.max_pool3d_with_indices.default(buf1896, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1896
        buf1898 = buf1897[0]
        del buf1897
        buf1901 = torch.ops.aten.max_pool3d_with_indices.default(buf1900, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1900
        buf1902 = buf1901[0]
        del buf1901
        buf1904 = buf1894
        del buf1894
        triton_poi_fused_minimum_neg_3[grid(256)](buf1904, buf1902, buf1898,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1905 = torch.ops.aten.max_pool3d_with_indices.default(buf1904, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1906 = buf1905[0]
        del buf1905
        buf1909 = torch.ops.aten.max_pool3d_with_indices.default(buf1908, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1910 = buf1909[0]
        del buf1909
        buf1913 = torch.ops.aten.max_pool3d_with_indices.default(buf1912, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1914 = buf1913[0]
        del buf1913
        buf1917 = torch.ops.aten.max_pool3d_with_indices.default(buf1916, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1918 = buf1917[0]
        del buf1917
        buf1920 = buf1916
        del buf1916
        buf1924 = buf1912
        del buf1912
        buf1928 = buf1908
        del buf1908
        buf1936 = buf1904
        del buf1904
        buf1940 = buf1902
        del buf1902
        buf1944 = buf1898
        del buf1898
        triton_poi_fused_minimum_neg_2[grid(256)](buf1910, buf1918, buf1914,
            buf1920, buf1924, buf1928, buf1936, buf1940, buf1944, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1921 = torch.ops.aten.max_pool3d_with_indices.default(buf1920, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1920
        buf1922 = buf1921[0]
        del buf1921
        buf1925 = torch.ops.aten.max_pool3d_with_indices.default(buf1924, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1924
        buf1926 = buf1925[0]
        del buf1925
        buf1929 = torch.ops.aten.max_pool3d_with_indices.default(buf1928, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1928
        buf1930 = buf1929[0]
        del buf1929
        buf1932 = buf1922
        del buf1922
        triton_poi_fused_minimum_neg_3[grid(256)](buf1932, buf1930, buf1926,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1933 = torch.ops.aten.max_pool3d_with_indices.default(buf1932, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1934 = buf1933[0]
        del buf1933
        buf1937 = torch.ops.aten.max_pool3d_with_indices.default(buf1936, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1938 = buf1937[0]
        del buf1937
        buf1941 = torch.ops.aten.max_pool3d_with_indices.default(buf1940, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1942 = buf1941[0]
        del buf1941
        buf1945 = torch.ops.aten.max_pool3d_with_indices.default(buf1944, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1946 = buf1945[0]
        del buf1945
        buf1948 = buf1944
        del buf1944
        buf1952 = buf1940
        del buf1940
        buf1956 = buf1936
        del buf1936
        buf1964 = buf1932
        del buf1932
        buf1968 = buf1930
        del buf1930
        buf1972 = buf1926
        del buf1926
        triton_poi_fused_minimum_neg_2[grid(256)](buf1938, buf1946, buf1942,
            buf1948, buf1952, buf1956, buf1964, buf1968, buf1972, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1949 = torch.ops.aten.max_pool3d_with_indices.default(buf1948, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1948
        buf1950 = buf1949[0]
        del buf1949
        buf1953 = torch.ops.aten.max_pool3d_with_indices.default(buf1952, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1952
        buf1954 = buf1953[0]
        del buf1953
        buf1957 = torch.ops.aten.max_pool3d_with_indices.default(buf1956, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1956
        buf1958 = buf1957[0]
        del buf1957
        buf1960 = buf1950
        del buf1950
        triton_poi_fused_minimum_neg_3[grid(256)](buf1960, buf1958, buf1954,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1961 = torch.ops.aten.max_pool3d_with_indices.default(buf1960, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1962 = buf1961[0]
        del buf1961
        buf1965 = torch.ops.aten.max_pool3d_with_indices.default(buf1964, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1966 = buf1965[0]
        del buf1965
        buf1969 = torch.ops.aten.max_pool3d_with_indices.default(buf1968, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1970 = buf1969[0]
        del buf1969
        buf1973 = torch.ops.aten.max_pool3d_with_indices.default(buf1972, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf1974 = buf1973[0]
        del buf1973
        buf1976 = buf1972
        del buf1972
        buf1980 = buf1968
        del buf1968
        buf1984 = buf1964
        del buf1964
        buf1992 = buf1960
        del buf1960
        buf1996 = buf1958
        del buf1958
        buf2000 = buf1954
        del buf1954
        triton_poi_fused_minimum_neg_2[grid(256)](buf1966, buf1974, buf1970,
            buf1976, buf1980, buf1984, buf1992, buf1996, buf2000, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf1977 = torch.ops.aten.max_pool3d_with_indices.default(buf1976, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf1976
        buf1978 = buf1977[0]
        del buf1977
        buf1981 = torch.ops.aten.max_pool3d_with_indices.default(buf1980, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf1980
        buf1982 = buf1981[0]
        del buf1981
        buf1985 = torch.ops.aten.max_pool3d_with_indices.default(buf1984, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf1984
        buf1986 = buf1985[0]
        del buf1985
        buf1988 = buf1978
        del buf1978
        triton_poi_fused_minimum_neg_3[grid(256)](buf1988, buf1986, buf1982,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf1989 = torch.ops.aten.max_pool3d_with_indices.default(buf1988, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf1990 = buf1989[0]
        del buf1989
        buf1993 = torch.ops.aten.max_pool3d_with_indices.default(buf1992, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf1994 = buf1993[0]
        del buf1993
        buf1997 = torch.ops.aten.max_pool3d_with_indices.default(buf1996, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf1998 = buf1997[0]
        del buf1997
        buf2001 = torch.ops.aten.max_pool3d_with_indices.default(buf2000, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2002 = buf2001[0]
        del buf2001
        buf2004 = buf2000
        del buf2000
        buf2008 = buf1996
        del buf1996
        buf2012 = buf1992
        del buf1992
        buf2020 = buf1988
        del buf1988
        buf2024 = buf1986
        del buf1986
        buf2028 = buf1982
        del buf1982
        triton_poi_fused_minimum_neg_2[grid(256)](buf1994, buf2002, buf1998,
            buf2004, buf2008, buf2012, buf2020, buf2024, buf2028, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2005 = torch.ops.aten.max_pool3d_with_indices.default(buf2004, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2004
        buf2006 = buf2005[0]
        del buf2005
        buf2009 = torch.ops.aten.max_pool3d_with_indices.default(buf2008, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2008
        buf2010 = buf2009[0]
        del buf2009
        buf2013 = torch.ops.aten.max_pool3d_with_indices.default(buf2012, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2012
        buf2014 = buf2013[0]
        del buf2013
        buf2016 = buf2006
        del buf2006
        triton_poi_fused_minimum_neg_3[grid(256)](buf2016, buf2014, buf2010,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2017 = torch.ops.aten.max_pool3d_with_indices.default(buf2016, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2018 = buf2017[0]
        del buf2017
        buf2021 = torch.ops.aten.max_pool3d_with_indices.default(buf2020, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2022 = buf2021[0]
        del buf2021
        buf2025 = torch.ops.aten.max_pool3d_with_indices.default(buf2024, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2026 = buf2025[0]
        del buf2025
        buf2029 = torch.ops.aten.max_pool3d_with_indices.default(buf2028, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2030 = buf2029[0]
        del buf2029
        buf2032 = buf2028
        del buf2028
        buf2036 = buf2024
        del buf2024
        buf2040 = buf2020
        del buf2020
        buf2048 = buf2016
        del buf2016
        buf2052 = buf2014
        del buf2014
        buf2056 = buf2010
        del buf2010
        triton_poi_fused_minimum_neg_2[grid(256)](buf2022, buf2030, buf2026,
            buf2032, buf2036, buf2040, buf2048, buf2052, buf2056, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2033 = torch.ops.aten.max_pool3d_with_indices.default(buf2032, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2032
        buf2034 = buf2033[0]
        del buf2033
        buf2037 = torch.ops.aten.max_pool3d_with_indices.default(buf2036, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2036
        buf2038 = buf2037[0]
        del buf2037
        buf2041 = torch.ops.aten.max_pool3d_with_indices.default(buf2040, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2040
        buf2042 = buf2041[0]
        del buf2041
        buf2044 = buf2034
        del buf2034
        triton_poi_fused_minimum_neg_3[grid(256)](buf2044, buf2042, buf2038,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2045 = torch.ops.aten.max_pool3d_with_indices.default(buf2044, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2046 = buf2045[0]
        del buf2045
        buf2049 = torch.ops.aten.max_pool3d_with_indices.default(buf2048, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2050 = buf2049[0]
        del buf2049
        buf2053 = torch.ops.aten.max_pool3d_with_indices.default(buf2052, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2054 = buf2053[0]
        del buf2053
        buf2057 = torch.ops.aten.max_pool3d_with_indices.default(buf2056, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2058 = buf2057[0]
        del buf2057
        buf2060 = buf2056
        del buf2056
        buf2064 = buf2052
        del buf2052
        buf2068 = buf2048
        del buf2048
        buf2076 = buf2044
        del buf2044
        buf2080 = buf2042
        del buf2042
        buf2084 = buf2038
        del buf2038
        triton_poi_fused_minimum_neg_2[grid(256)](buf2050, buf2058, buf2054,
            buf2060, buf2064, buf2068, buf2076, buf2080, buf2084, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2061 = torch.ops.aten.max_pool3d_with_indices.default(buf2060, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2060
        buf2062 = buf2061[0]
        del buf2061
        buf2065 = torch.ops.aten.max_pool3d_with_indices.default(buf2064, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2064
        buf2066 = buf2065[0]
        del buf2065
        buf2069 = torch.ops.aten.max_pool3d_with_indices.default(buf2068, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2068
        buf2070 = buf2069[0]
        del buf2069
        buf2072 = buf2062
        del buf2062
        triton_poi_fused_minimum_neg_3[grid(256)](buf2072, buf2070, buf2066,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2073 = torch.ops.aten.max_pool3d_with_indices.default(buf2072, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2074 = buf2073[0]
        del buf2073
        buf2077 = torch.ops.aten.max_pool3d_with_indices.default(buf2076, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2078 = buf2077[0]
        del buf2077
        buf2081 = torch.ops.aten.max_pool3d_with_indices.default(buf2080, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2082 = buf2081[0]
        del buf2081
        buf2085 = torch.ops.aten.max_pool3d_with_indices.default(buf2084, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2086 = buf2085[0]
        del buf2085
        buf2088 = buf2084
        del buf2084
        buf2092 = buf2080
        del buf2080
        buf2096 = buf2076
        del buf2076
        buf2104 = buf2072
        del buf2072
        buf2108 = buf2070
        del buf2070
        buf2112 = buf2066
        del buf2066
        triton_poi_fused_minimum_neg_2[grid(256)](buf2078, buf2086, buf2082,
            buf2088, buf2092, buf2096, buf2104, buf2108, buf2112, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2089 = torch.ops.aten.max_pool3d_with_indices.default(buf2088, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2088
        buf2090 = buf2089[0]
        del buf2089
        buf2093 = torch.ops.aten.max_pool3d_with_indices.default(buf2092, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2092
        buf2094 = buf2093[0]
        del buf2093
        buf2097 = torch.ops.aten.max_pool3d_with_indices.default(buf2096, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2096
        buf2098 = buf2097[0]
        del buf2097
        buf2100 = buf2090
        del buf2090
        triton_poi_fused_minimum_neg_3[grid(256)](buf2100, buf2098, buf2094,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2101 = torch.ops.aten.max_pool3d_with_indices.default(buf2100, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2102 = buf2101[0]
        del buf2101
        buf2105 = torch.ops.aten.max_pool3d_with_indices.default(buf2104, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2106 = buf2105[0]
        del buf2105
        buf2109 = torch.ops.aten.max_pool3d_with_indices.default(buf2108, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2110 = buf2109[0]
        del buf2109
        buf2113 = torch.ops.aten.max_pool3d_with_indices.default(buf2112, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2114 = buf2113[0]
        del buf2113
        buf2116 = buf2112
        del buf2112
        buf2120 = buf2108
        del buf2108
        buf2124 = buf2104
        del buf2104
        buf2132 = buf2100
        del buf2100
        buf2136 = buf2098
        del buf2098
        buf2140 = buf2094
        del buf2094
        triton_poi_fused_minimum_neg_2[grid(256)](buf2106, buf2114, buf2110,
            buf2116, buf2120, buf2124, buf2132, buf2136, buf2140, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2117 = torch.ops.aten.max_pool3d_with_indices.default(buf2116, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2116
        buf2118 = buf2117[0]
        del buf2117
        buf2121 = torch.ops.aten.max_pool3d_with_indices.default(buf2120, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2120
        buf2122 = buf2121[0]
        del buf2121
        buf2125 = torch.ops.aten.max_pool3d_with_indices.default(buf2124, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2124
        buf2126 = buf2125[0]
        del buf2125
        buf2128 = buf2118
        del buf2118
        triton_poi_fused_minimum_neg_3[grid(256)](buf2128, buf2126, buf2122,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2129 = torch.ops.aten.max_pool3d_with_indices.default(buf2128, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2130 = buf2129[0]
        del buf2129
        buf2133 = torch.ops.aten.max_pool3d_with_indices.default(buf2132, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2134 = buf2133[0]
        del buf2133
        buf2137 = torch.ops.aten.max_pool3d_with_indices.default(buf2136, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2138 = buf2137[0]
        del buf2137
        buf2141 = torch.ops.aten.max_pool3d_with_indices.default(buf2140, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2142 = buf2141[0]
        del buf2141
        buf2144 = buf2140
        del buf2140
        buf2148 = buf2136
        del buf2136
        buf2152 = buf2132
        del buf2132
        buf2160 = buf2128
        del buf2128
        buf2164 = buf2126
        del buf2126
        buf2168 = buf2122
        del buf2122
        triton_poi_fused_minimum_neg_2[grid(256)](buf2134, buf2142, buf2138,
            buf2144, buf2148, buf2152, buf2160, buf2164, buf2168, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2145 = torch.ops.aten.max_pool3d_with_indices.default(buf2144, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2144
        buf2146 = buf2145[0]
        del buf2145
        buf2149 = torch.ops.aten.max_pool3d_with_indices.default(buf2148, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2148
        buf2150 = buf2149[0]
        del buf2149
        buf2153 = torch.ops.aten.max_pool3d_with_indices.default(buf2152, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2152
        buf2154 = buf2153[0]
        del buf2153
        buf2156 = buf2146
        del buf2146
        triton_poi_fused_minimum_neg_3[grid(256)](buf2156, buf2154, buf2150,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2157 = torch.ops.aten.max_pool3d_with_indices.default(buf2156, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2158 = buf2157[0]
        del buf2157
        buf2161 = torch.ops.aten.max_pool3d_with_indices.default(buf2160, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2162 = buf2161[0]
        del buf2161
        buf2165 = torch.ops.aten.max_pool3d_with_indices.default(buf2164, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2166 = buf2165[0]
        del buf2165
        buf2169 = torch.ops.aten.max_pool3d_with_indices.default(buf2168, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2170 = buf2169[0]
        del buf2169
        buf2172 = buf2168
        del buf2168
        buf2176 = buf2164
        del buf2164
        buf2180 = buf2160
        del buf2160
        buf2188 = buf2156
        del buf2156
        buf2192 = buf2154
        del buf2154
        buf2196 = buf2150
        del buf2150
        triton_poi_fused_minimum_neg_2[grid(256)](buf2162, buf2170, buf2166,
            buf2172, buf2176, buf2180, buf2188, buf2192, buf2196, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2173 = torch.ops.aten.max_pool3d_with_indices.default(buf2172, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2172
        buf2174 = buf2173[0]
        del buf2173
        buf2177 = torch.ops.aten.max_pool3d_with_indices.default(buf2176, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2176
        buf2178 = buf2177[0]
        del buf2177
        buf2181 = torch.ops.aten.max_pool3d_with_indices.default(buf2180, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2180
        buf2182 = buf2181[0]
        del buf2181
        buf2184 = buf2174
        del buf2174
        triton_poi_fused_minimum_neg_3[grid(256)](buf2184, buf2182, buf2178,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2185 = torch.ops.aten.max_pool3d_with_indices.default(buf2184, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2186 = buf2185[0]
        del buf2185
        buf2189 = torch.ops.aten.max_pool3d_with_indices.default(buf2188, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2190 = buf2189[0]
        del buf2189
        buf2193 = torch.ops.aten.max_pool3d_with_indices.default(buf2192, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2194 = buf2193[0]
        del buf2193
        buf2197 = torch.ops.aten.max_pool3d_with_indices.default(buf2196, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2198 = buf2197[0]
        del buf2197
        buf2200 = buf2196
        del buf2196
        buf2204 = buf2192
        del buf2192
        buf2208 = buf2188
        del buf2188
        buf2216 = buf2184
        del buf2184
        buf2220 = buf2182
        del buf2182
        buf2224 = buf2178
        del buf2178
        triton_poi_fused_minimum_neg_2[grid(256)](buf2190, buf2198, buf2194,
            buf2200, buf2204, buf2208, buf2216, buf2220, buf2224, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2201 = torch.ops.aten.max_pool3d_with_indices.default(buf2200, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2200
        buf2202 = buf2201[0]
        del buf2201
        buf2205 = torch.ops.aten.max_pool3d_with_indices.default(buf2204, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2204
        buf2206 = buf2205[0]
        del buf2205
        buf2209 = torch.ops.aten.max_pool3d_with_indices.default(buf2208, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2208
        buf2210 = buf2209[0]
        del buf2209
        buf2212 = buf2202
        del buf2202
        triton_poi_fused_minimum_neg_3[grid(256)](buf2212, buf2210, buf2206,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2213 = torch.ops.aten.max_pool3d_with_indices.default(buf2212, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2214 = buf2213[0]
        del buf2213
        buf2217 = torch.ops.aten.max_pool3d_with_indices.default(buf2216, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2218 = buf2217[0]
        del buf2217
        buf2221 = torch.ops.aten.max_pool3d_with_indices.default(buf2220, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2222 = buf2221[0]
        del buf2221
        buf2225 = torch.ops.aten.max_pool3d_with_indices.default(buf2224, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2226 = buf2225[0]
        del buf2225
        buf2228 = buf2224
        del buf2224
        buf2232 = buf2220
        del buf2220
        buf2236 = buf2216
        del buf2216
        buf2244 = buf2212
        del buf2212
        buf2248 = buf2210
        del buf2210
        buf2252 = buf2206
        del buf2206
        triton_poi_fused_minimum_neg_2[grid(256)](buf2218, buf2226, buf2222,
            buf2228, buf2232, buf2236, buf2244, buf2248, buf2252, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2229 = torch.ops.aten.max_pool3d_with_indices.default(buf2228, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2228
        buf2230 = buf2229[0]
        del buf2229
        buf2233 = torch.ops.aten.max_pool3d_with_indices.default(buf2232, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2232
        buf2234 = buf2233[0]
        del buf2233
        buf2237 = torch.ops.aten.max_pool3d_with_indices.default(buf2236, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2236
        buf2238 = buf2237[0]
        del buf2237
        buf2240 = buf2230
        del buf2230
        triton_poi_fused_minimum_neg_3[grid(256)](buf2240, buf2238, buf2234,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2241 = torch.ops.aten.max_pool3d_with_indices.default(buf2240, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2242 = buf2241[0]
        del buf2241
        buf2245 = torch.ops.aten.max_pool3d_with_indices.default(buf2244, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2246 = buf2245[0]
        del buf2245
        buf2249 = torch.ops.aten.max_pool3d_with_indices.default(buf2248, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2250 = buf2249[0]
        del buf2249
        buf2253 = torch.ops.aten.max_pool3d_with_indices.default(buf2252, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2254 = buf2253[0]
        del buf2253
        buf2256 = buf2252
        del buf2252
        buf2260 = buf2248
        del buf2248
        buf2264 = buf2244
        del buf2244
        buf2272 = buf2240
        del buf2240
        buf2276 = buf2238
        del buf2238
        buf2280 = buf2234
        del buf2234
        triton_poi_fused_minimum_neg_2[grid(256)](buf2246, buf2254, buf2250,
            buf2256, buf2260, buf2264, buf2272, buf2276, buf2280, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2257 = torch.ops.aten.max_pool3d_with_indices.default(buf2256, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2256
        buf2258 = buf2257[0]
        del buf2257
        buf2261 = torch.ops.aten.max_pool3d_with_indices.default(buf2260, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2260
        buf2262 = buf2261[0]
        del buf2261
        buf2265 = torch.ops.aten.max_pool3d_with_indices.default(buf2264, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2264
        buf2266 = buf2265[0]
        del buf2265
        buf2268 = buf2258
        del buf2258
        triton_poi_fused_minimum_neg_3[grid(256)](buf2268, buf2266, buf2262,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2269 = torch.ops.aten.max_pool3d_with_indices.default(buf2268, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2270 = buf2269[0]
        del buf2269
        buf2273 = torch.ops.aten.max_pool3d_with_indices.default(buf2272, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2274 = buf2273[0]
        del buf2273
        buf2277 = torch.ops.aten.max_pool3d_with_indices.default(buf2276, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2278 = buf2277[0]
        del buf2277
        buf2281 = torch.ops.aten.max_pool3d_with_indices.default(buf2280, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2282 = buf2281[0]
        del buf2281
        buf2284 = buf2280
        del buf2280
        buf2288 = buf2276
        del buf2276
        buf2292 = buf2272
        del buf2272
        buf2300 = buf2268
        del buf2268
        buf2304 = buf2266
        del buf2266
        buf2308 = buf2262
        del buf2262
        triton_poi_fused_minimum_neg_2[grid(256)](buf2274, buf2282, buf2278,
            buf2284, buf2288, buf2292, buf2300, buf2304, buf2308, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2285 = torch.ops.aten.max_pool3d_with_indices.default(buf2284, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2284
        buf2286 = buf2285[0]
        del buf2285
        buf2289 = torch.ops.aten.max_pool3d_with_indices.default(buf2288, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2288
        buf2290 = buf2289[0]
        del buf2289
        buf2293 = torch.ops.aten.max_pool3d_with_indices.default(buf2292, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2292
        buf2294 = buf2293[0]
        del buf2293
        buf2296 = buf2286
        del buf2286
        triton_poi_fused_minimum_neg_3[grid(256)](buf2296, buf2294, buf2290,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2297 = torch.ops.aten.max_pool3d_with_indices.default(buf2296, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2298 = buf2297[0]
        del buf2297
        buf2301 = torch.ops.aten.max_pool3d_with_indices.default(buf2300, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2302 = buf2301[0]
        del buf2301
        buf2305 = torch.ops.aten.max_pool3d_with_indices.default(buf2304, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2306 = buf2305[0]
        del buf2305
        buf2309 = torch.ops.aten.max_pool3d_with_indices.default(buf2308, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2310 = buf2309[0]
        del buf2309
        buf2312 = buf2308
        del buf2308
        buf2316 = buf2304
        del buf2304
        buf2320 = buf2300
        del buf2300
        buf2328 = buf2296
        del buf2296
        buf2332 = buf2294
        del buf2294
        buf2336 = buf2290
        del buf2290
        triton_poi_fused_minimum_neg_2[grid(256)](buf2302, buf2310, buf2306,
            buf2312, buf2316, buf2320, buf2328, buf2332, buf2336, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2313 = torch.ops.aten.max_pool3d_with_indices.default(buf2312, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2312
        buf2314 = buf2313[0]
        del buf2313
        buf2317 = torch.ops.aten.max_pool3d_with_indices.default(buf2316, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2316
        buf2318 = buf2317[0]
        del buf2317
        buf2321 = torch.ops.aten.max_pool3d_with_indices.default(buf2320, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2320
        buf2322 = buf2321[0]
        del buf2321
        buf2324 = buf2314
        del buf2314
        triton_poi_fused_minimum_neg_3[grid(256)](buf2324, buf2322, buf2318,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2325 = torch.ops.aten.max_pool3d_with_indices.default(buf2324, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2326 = buf2325[0]
        del buf2325
        buf2329 = torch.ops.aten.max_pool3d_with_indices.default(buf2328, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2330 = buf2329[0]
        del buf2329
        buf2333 = torch.ops.aten.max_pool3d_with_indices.default(buf2332, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2334 = buf2333[0]
        del buf2333
        buf2337 = torch.ops.aten.max_pool3d_with_indices.default(buf2336, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2338 = buf2337[0]
        del buf2337
        buf2340 = buf2336
        del buf2336
        buf2344 = buf2332
        del buf2332
        buf2348 = buf2328
        del buf2328
        buf2356 = buf2324
        del buf2324
        buf2360 = buf2322
        del buf2322
        buf2364 = buf2318
        del buf2318
        triton_poi_fused_minimum_neg_2[grid(256)](buf2330, buf2338, buf2334,
            buf2340, buf2344, buf2348, buf2356, buf2360, buf2364, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2341 = torch.ops.aten.max_pool3d_with_indices.default(buf2340, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2340
        buf2342 = buf2341[0]
        del buf2341
        buf2345 = torch.ops.aten.max_pool3d_with_indices.default(buf2344, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2344
        buf2346 = buf2345[0]
        del buf2345
        buf2349 = torch.ops.aten.max_pool3d_with_indices.default(buf2348, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2348
        buf2350 = buf2349[0]
        del buf2349
        buf2352 = buf2342
        del buf2342
        triton_poi_fused_minimum_neg_3[grid(256)](buf2352, buf2350, buf2346,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2353 = torch.ops.aten.max_pool3d_with_indices.default(buf2352, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2354 = buf2353[0]
        del buf2353
        buf2357 = torch.ops.aten.max_pool3d_with_indices.default(buf2356, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2358 = buf2357[0]
        del buf2357
        buf2361 = torch.ops.aten.max_pool3d_with_indices.default(buf2360, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2362 = buf2361[0]
        del buf2361
        buf2365 = torch.ops.aten.max_pool3d_with_indices.default(buf2364, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2366 = buf2365[0]
        del buf2365
        buf2368 = buf2364
        del buf2364
        buf2372 = buf2360
        del buf2360
        buf2376 = buf2356
        del buf2356
        buf2384 = buf2352
        del buf2352
        buf2388 = buf2350
        del buf2350
        buf2392 = buf2346
        del buf2346
        triton_poi_fused_minimum_neg_2[grid(256)](buf2358, buf2366, buf2362,
            buf2368, buf2372, buf2376, buf2384, buf2388, buf2392, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2369 = torch.ops.aten.max_pool3d_with_indices.default(buf2368, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2368
        buf2370 = buf2369[0]
        del buf2369
        buf2373 = torch.ops.aten.max_pool3d_with_indices.default(buf2372, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2372
        buf2374 = buf2373[0]
        del buf2373
        buf2377 = torch.ops.aten.max_pool3d_with_indices.default(buf2376, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2376
        buf2378 = buf2377[0]
        del buf2377
        buf2380 = buf2370
        del buf2370
        triton_poi_fused_minimum_neg_3[grid(256)](buf2380, buf2378, buf2374,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2381 = torch.ops.aten.max_pool3d_with_indices.default(buf2380, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2382 = buf2381[0]
        del buf2381
        buf2385 = torch.ops.aten.max_pool3d_with_indices.default(buf2384, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2386 = buf2385[0]
        del buf2385
        buf2389 = torch.ops.aten.max_pool3d_with_indices.default(buf2388, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2390 = buf2389[0]
        del buf2389
        buf2393 = torch.ops.aten.max_pool3d_with_indices.default(buf2392, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2394 = buf2393[0]
        del buf2393
        buf2396 = buf2392
        del buf2392
        buf2400 = buf2388
        del buf2388
        buf2404 = buf2384
        del buf2384
        buf2412 = buf2380
        del buf2380
        buf2416 = buf2378
        del buf2378
        buf2420 = buf2374
        del buf2374
        triton_poi_fused_minimum_neg_2[grid(256)](buf2386, buf2394, buf2390,
            buf2396, buf2400, buf2404, buf2412, buf2416, buf2420, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2397 = torch.ops.aten.max_pool3d_with_indices.default(buf2396, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2396
        buf2398 = buf2397[0]
        del buf2397
        buf2401 = torch.ops.aten.max_pool3d_with_indices.default(buf2400, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2400
        buf2402 = buf2401[0]
        del buf2401
        buf2405 = torch.ops.aten.max_pool3d_with_indices.default(buf2404, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2404
        buf2406 = buf2405[0]
        del buf2405
        buf2408 = buf2398
        del buf2398
        triton_poi_fused_minimum_neg_3[grid(256)](buf2408, buf2406, buf2402,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2409 = torch.ops.aten.max_pool3d_with_indices.default(buf2408, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2410 = buf2409[0]
        del buf2409
        buf2413 = torch.ops.aten.max_pool3d_with_indices.default(buf2412, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2414 = buf2413[0]
        del buf2413
        buf2417 = torch.ops.aten.max_pool3d_with_indices.default(buf2416, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2418 = buf2417[0]
        del buf2417
        buf2421 = torch.ops.aten.max_pool3d_with_indices.default(buf2420, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2422 = buf2421[0]
        del buf2421
        buf2424 = buf2420
        del buf2420
        buf2428 = buf2416
        del buf2416
        buf2432 = buf2412
        del buf2412
        buf2440 = buf2408
        del buf2408
        buf2444 = buf2406
        del buf2406
        buf2448 = buf2402
        del buf2402
        triton_poi_fused_minimum_neg_2[grid(256)](buf2414, buf2422, buf2418,
            buf2424, buf2428, buf2432, buf2440, buf2444, buf2448, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2425 = torch.ops.aten.max_pool3d_with_indices.default(buf2424, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2424
        buf2426 = buf2425[0]
        del buf2425
        buf2429 = torch.ops.aten.max_pool3d_with_indices.default(buf2428, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2428
        buf2430 = buf2429[0]
        del buf2429
        buf2433 = torch.ops.aten.max_pool3d_with_indices.default(buf2432, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2432
        buf2434 = buf2433[0]
        del buf2433
        buf2436 = buf2426
        del buf2426
        triton_poi_fused_minimum_neg_3[grid(256)](buf2436, buf2434, buf2430,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2437 = torch.ops.aten.max_pool3d_with_indices.default(buf2436, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2438 = buf2437[0]
        del buf2437
        buf2441 = torch.ops.aten.max_pool3d_with_indices.default(buf2440, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2442 = buf2441[0]
        del buf2441
        buf2445 = torch.ops.aten.max_pool3d_with_indices.default(buf2444, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2446 = buf2445[0]
        del buf2445
        buf2449 = torch.ops.aten.max_pool3d_with_indices.default(buf2448, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2450 = buf2449[0]
        del buf2449
        buf2452 = buf2448
        del buf2448
        buf2456 = buf2444
        del buf2444
        buf2460 = buf2440
        del buf2440
        buf2468 = buf2436
        del buf2436
        buf2472 = buf2434
        del buf2434
        buf2476 = buf2430
        del buf2430
        triton_poi_fused_minimum_neg_2[grid(256)](buf2442, buf2450, buf2446,
            buf2452, buf2456, buf2460, buf2468, buf2472, buf2476, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2453 = torch.ops.aten.max_pool3d_with_indices.default(buf2452, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2452
        buf2454 = buf2453[0]
        del buf2453
        buf2457 = torch.ops.aten.max_pool3d_with_indices.default(buf2456, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2456
        buf2458 = buf2457[0]
        del buf2457
        buf2461 = torch.ops.aten.max_pool3d_with_indices.default(buf2460, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2460
        buf2462 = buf2461[0]
        del buf2461
        buf2464 = buf2454
        del buf2454
        triton_poi_fused_minimum_neg_3[grid(256)](buf2464, buf2462, buf2458,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2465 = torch.ops.aten.max_pool3d_with_indices.default(buf2464, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2466 = buf2465[0]
        del buf2465
        buf2469 = torch.ops.aten.max_pool3d_with_indices.default(buf2468, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2470 = buf2469[0]
        del buf2469
        buf2473 = torch.ops.aten.max_pool3d_with_indices.default(buf2472, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2474 = buf2473[0]
        del buf2473
        buf2477 = torch.ops.aten.max_pool3d_with_indices.default(buf2476, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2478 = buf2477[0]
        del buf2477
        buf2480 = buf2476
        del buf2476
        buf2484 = buf2472
        del buf2472
        buf2488 = buf2468
        del buf2468
        buf2496 = buf2464
        del buf2464
        buf2500 = buf2462
        del buf2462
        buf2504 = buf2458
        del buf2458
        triton_poi_fused_minimum_neg_2[grid(256)](buf2470, buf2478, buf2474,
            buf2480, buf2484, buf2488, buf2496, buf2500, buf2504, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2481 = torch.ops.aten.max_pool3d_with_indices.default(buf2480, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2480
        buf2482 = buf2481[0]
        del buf2481
        buf2485 = torch.ops.aten.max_pool3d_with_indices.default(buf2484, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2484
        buf2486 = buf2485[0]
        del buf2485
        buf2489 = torch.ops.aten.max_pool3d_with_indices.default(buf2488, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2488
        buf2490 = buf2489[0]
        del buf2489
        buf2492 = buf2482
        del buf2482
        triton_poi_fused_minimum_neg_3[grid(256)](buf2492, buf2490, buf2486,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2493 = torch.ops.aten.max_pool3d_with_indices.default(buf2492, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2494 = buf2493[0]
        del buf2493
        buf2497 = torch.ops.aten.max_pool3d_with_indices.default(buf2496, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2498 = buf2497[0]
        del buf2497
        buf2501 = torch.ops.aten.max_pool3d_with_indices.default(buf2500, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2502 = buf2501[0]
        del buf2501
        buf2505 = torch.ops.aten.max_pool3d_with_indices.default(buf2504, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2506 = buf2505[0]
        del buf2505
        buf2508 = buf2504
        del buf2504
        buf2512 = buf2500
        del buf2500
        buf2516 = buf2496
        del buf2496
        buf2524 = buf2492
        del buf2492
        buf2528 = buf2490
        del buf2490
        buf2532 = buf2486
        del buf2486
        triton_poi_fused_minimum_neg_2[grid(256)](buf2498, buf2506, buf2502,
            buf2508, buf2512, buf2516, buf2524, buf2528, buf2532, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2509 = torch.ops.aten.max_pool3d_with_indices.default(buf2508, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2508
        buf2510 = buf2509[0]
        del buf2509
        buf2513 = torch.ops.aten.max_pool3d_with_indices.default(buf2512, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2512
        buf2514 = buf2513[0]
        del buf2513
        buf2517 = torch.ops.aten.max_pool3d_with_indices.default(buf2516, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2516
        buf2518 = buf2517[0]
        del buf2517
        buf2520 = buf2510
        del buf2510
        triton_poi_fused_minimum_neg_3[grid(256)](buf2520, buf2518, buf2514,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2521 = torch.ops.aten.max_pool3d_with_indices.default(buf2520, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2522 = buf2521[0]
        del buf2521
        buf2525 = torch.ops.aten.max_pool3d_with_indices.default(buf2524, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2526 = buf2525[0]
        del buf2525
        buf2529 = torch.ops.aten.max_pool3d_with_indices.default(buf2528, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2530 = buf2529[0]
        del buf2529
        buf2533 = torch.ops.aten.max_pool3d_with_indices.default(buf2532, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2534 = buf2533[0]
        del buf2533
        buf2536 = buf2532
        del buf2532
        buf2540 = buf2528
        del buf2528
        buf2544 = buf2524
        del buf2524
        buf2552 = buf2520
        del buf2520
        buf2556 = buf2518
        del buf2518
        buf2560 = buf2514
        del buf2514
        triton_poi_fused_minimum_neg_2[grid(256)](buf2526, buf2534, buf2530,
            buf2536, buf2540, buf2544, buf2552, buf2556, buf2560, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2537 = torch.ops.aten.max_pool3d_with_indices.default(buf2536, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2536
        buf2538 = buf2537[0]
        del buf2537
        buf2541 = torch.ops.aten.max_pool3d_with_indices.default(buf2540, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2540
        buf2542 = buf2541[0]
        del buf2541
        buf2545 = torch.ops.aten.max_pool3d_with_indices.default(buf2544, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2544
        buf2546 = buf2545[0]
        del buf2545
        buf2548 = buf2538
        del buf2538
        triton_poi_fused_minimum_neg_3[grid(256)](buf2548, buf2546, buf2542,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2549 = torch.ops.aten.max_pool3d_with_indices.default(buf2548, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2550 = buf2549[0]
        del buf2549
        buf2553 = torch.ops.aten.max_pool3d_with_indices.default(buf2552, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2554 = buf2553[0]
        del buf2553
        buf2557 = torch.ops.aten.max_pool3d_with_indices.default(buf2556, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2558 = buf2557[0]
        del buf2557
        buf2561 = torch.ops.aten.max_pool3d_with_indices.default(buf2560, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2562 = buf2561[0]
        del buf2561
        buf2564 = buf2560
        del buf2560
        buf2568 = buf2556
        del buf2556
        buf2572 = buf2552
        del buf2552
        buf2580 = buf2548
        del buf2548
        buf2584 = buf2546
        del buf2546
        buf2588 = buf2542
        del buf2542
        triton_poi_fused_minimum_neg_2[grid(256)](buf2554, buf2562, buf2558,
            buf2564, buf2568, buf2572, buf2580, buf2584, buf2588, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2565 = torch.ops.aten.max_pool3d_with_indices.default(buf2564, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2564
        buf2566 = buf2565[0]
        del buf2565
        buf2569 = torch.ops.aten.max_pool3d_with_indices.default(buf2568, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2568
        buf2570 = buf2569[0]
        del buf2569
        buf2573 = torch.ops.aten.max_pool3d_with_indices.default(buf2572, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2572
        buf2574 = buf2573[0]
        del buf2573
        buf2576 = buf2566
        del buf2566
        triton_poi_fused_minimum_neg_3[grid(256)](buf2576, buf2574, buf2570,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2577 = torch.ops.aten.max_pool3d_with_indices.default(buf2576, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2578 = buf2577[0]
        del buf2577
        buf2581 = torch.ops.aten.max_pool3d_with_indices.default(buf2580, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2582 = buf2581[0]
        del buf2581
        buf2585 = torch.ops.aten.max_pool3d_with_indices.default(buf2584, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2586 = buf2585[0]
        del buf2585
        buf2589 = torch.ops.aten.max_pool3d_with_indices.default(buf2588, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2590 = buf2589[0]
        del buf2589
        buf2592 = buf2588
        del buf2588
        buf2596 = buf2584
        del buf2584
        buf2600 = buf2580
        del buf2580
        buf2608 = buf2576
        del buf2576
        buf2612 = buf2574
        del buf2574
        buf2616 = buf2570
        del buf2570
        triton_poi_fused_minimum_neg_2[grid(256)](buf2582, buf2590, buf2586,
            buf2592, buf2596, buf2600, buf2608, buf2612, buf2616, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2593 = torch.ops.aten.max_pool3d_with_indices.default(buf2592, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2592
        buf2594 = buf2593[0]
        del buf2593
        buf2597 = torch.ops.aten.max_pool3d_with_indices.default(buf2596, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2596
        buf2598 = buf2597[0]
        del buf2597
        buf2601 = torch.ops.aten.max_pool3d_with_indices.default(buf2600, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2600
        buf2602 = buf2601[0]
        del buf2601
        buf2604 = buf2594
        del buf2594
        triton_poi_fused_minimum_neg_3[grid(256)](buf2604, buf2602, buf2598,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2605 = torch.ops.aten.max_pool3d_with_indices.default(buf2604, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2606 = buf2605[0]
        del buf2605
        buf2609 = torch.ops.aten.max_pool3d_with_indices.default(buf2608, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2610 = buf2609[0]
        del buf2609
        buf2613 = torch.ops.aten.max_pool3d_with_indices.default(buf2612, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2614 = buf2613[0]
        del buf2613
        buf2617 = torch.ops.aten.max_pool3d_with_indices.default(buf2616, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2618 = buf2617[0]
        del buf2617
        buf2620 = buf2616
        del buf2616
        buf2624 = buf2612
        del buf2612
        buf2628 = buf2608
        del buf2608
        buf2636 = buf2604
        del buf2604
        buf2640 = buf2602
        del buf2602
        buf2644 = buf2598
        del buf2598
        triton_poi_fused_minimum_neg_2[grid(256)](buf2610, buf2618, buf2614,
            buf2620, buf2624, buf2628, buf2636, buf2640, buf2644, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2621 = torch.ops.aten.max_pool3d_with_indices.default(buf2620, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2620
        buf2622 = buf2621[0]
        del buf2621
        buf2625 = torch.ops.aten.max_pool3d_with_indices.default(buf2624, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2624
        buf2626 = buf2625[0]
        del buf2625
        buf2629 = torch.ops.aten.max_pool3d_with_indices.default(buf2628, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2628
        buf2630 = buf2629[0]
        del buf2629
        buf2632 = buf2622
        del buf2622
        triton_poi_fused_minimum_neg_3[grid(256)](buf2632, buf2630, buf2626,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2633 = torch.ops.aten.max_pool3d_with_indices.default(buf2632, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2634 = buf2633[0]
        del buf2633
        buf2637 = torch.ops.aten.max_pool3d_with_indices.default(buf2636, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2638 = buf2637[0]
        del buf2637
        buf2641 = torch.ops.aten.max_pool3d_with_indices.default(buf2640, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2642 = buf2641[0]
        del buf2641
        buf2645 = torch.ops.aten.max_pool3d_with_indices.default(buf2644, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2646 = buf2645[0]
        del buf2645
        buf2648 = buf2644
        del buf2644
        buf2652 = buf2640
        del buf2640
        buf2656 = buf2636
        del buf2636
        buf2664 = buf2632
        del buf2632
        buf2668 = buf2630
        del buf2630
        buf2672 = buf2626
        del buf2626
        triton_poi_fused_minimum_neg_2[grid(256)](buf2638, buf2646, buf2642,
            buf2648, buf2652, buf2656, buf2664, buf2668, buf2672, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2649 = torch.ops.aten.max_pool3d_with_indices.default(buf2648, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2648
        buf2650 = buf2649[0]
        del buf2649
        buf2653 = torch.ops.aten.max_pool3d_with_indices.default(buf2652, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2652
        buf2654 = buf2653[0]
        del buf2653
        buf2657 = torch.ops.aten.max_pool3d_with_indices.default(buf2656, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2656
        buf2658 = buf2657[0]
        del buf2657
        buf2660 = buf2650
        del buf2650
        triton_poi_fused_minimum_neg_3[grid(256)](buf2660, buf2658, buf2654,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2661 = torch.ops.aten.max_pool3d_with_indices.default(buf2660, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2662 = buf2661[0]
        del buf2661
        buf2665 = torch.ops.aten.max_pool3d_with_indices.default(buf2664, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2666 = buf2665[0]
        del buf2665
        buf2669 = torch.ops.aten.max_pool3d_with_indices.default(buf2668, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2670 = buf2669[0]
        del buf2669
        buf2673 = torch.ops.aten.max_pool3d_with_indices.default(buf2672, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2674 = buf2673[0]
        del buf2673
        buf2676 = buf2672
        del buf2672
        buf2680 = buf2668
        del buf2668
        buf2684 = buf2664
        del buf2664
        buf2692 = buf2660
        del buf2660
        buf2696 = buf2658
        del buf2658
        buf2700 = buf2654
        del buf2654
        triton_poi_fused_minimum_neg_2[grid(256)](buf2666, buf2674, buf2670,
            buf2676, buf2680, buf2684, buf2692, buf2696, buf2700, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2677 = torch.ops.aten.max_pool3d_with_indices.default(buf2676, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2676
        buf2678 = buf2677[0]
        del buf2677
        buf2681 = torch.ops.aten.max_pool3d_with_indices.default(buf2680, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2680
        buf2682 = buf2681[0]
        del buf2681
        buf2685 = torch.ops.aten.max_pool3d_with_indices.default(buf2684, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2684
        buf2686 = buf2685[0]
        del buf2685
        buf2688 = buf2678
        del buf2678
        triton_poi_fused_minimum_neg_3[grid(256)](buf2688, buf2686, buf2682,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2689 = torch.ops.aten.max_pool3d_with_indices.default(buf2688, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2690 = buf2689[0]
        del buf2689
        buf2693 = torch.ops.aten.max_pool3d_with_indices.default(buf2692, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2694 = buf2693[0]
        del buf2693
        buf2697 = torch.ops.aten.max_pool3d_with_indices.default(buf2696, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2698 = buf2697[0]
        del buf2697
        buf2701 = torch.ops.aten.max_pool3d_with_indices.default(buf2700, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2702 = buf2701[0]
        del buf2701
        buf2704 = buf2700
        del buf2700
        buf2708 = buf2696
        del buf2696
        buf2712 = buf2692
        del buf2692
        buf2720 = buf2688
        del buf2688
        buf2724 = buf2686
        del buf2686
        buf2728 = buf2682
        del buf2682
        triton_poi_fused_minimum_neg_2[grid(256)](buf2694, buf2702, buf2698,
            buf2704, buf2708, buf2712, buf2720, buf2724, buf2728, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2705 = torch.ops.aten.max_pool3d_with_indices.default(buf2704, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2704
        buf2706 = buf2705[0]
        del buf2705
        buf2709 = torch.ops.aten.max_pool3d_with_indices.default(buf2708, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2708
        buf2710 = buf2709[0]
        del buf2709
        buf2713 = torch.ops.aten.max_pool3d_with_indices.default(buf2712, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2712
        buf2714 = buf2713[0]
        del buf2713
        buf2716 = buf2706
        del buf2706
        triton_poi_fused_minimum_neg_3[grid(256)](buf2716, buf2714, buf2710,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2717 = torch.ops.aten.max_pool3d_with_indices.default(buf2716, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2718 = buf2717[0]
        del buf2717
        buf2721 = torch.ops.aten.max_pool3d_with_indices.default(buf2720, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2722 = buf2721[0]
        del buf2721
        buf2725 = torch.ops.aten.max_pool3d_with_indices.default(buf2724, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2726 = buf2725[0]
        del buf2725
        buf2729 = torch.ops.aten.max_pool3d_with_indices.default(buf2728, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2730 = buf2729[0]
        del buf2729
        buf2732 = buf2728
        del buf2728
        buf2736 = buf2724
        del buf2724
        buf2740 = buf2720
        del buf2720
        buf2748 = buf2716
        del buf2716
        buf2752 = buf2714
        del buf2714
        buf2756 = buf2710
        del buf2710
        triton_poi_fused_minimum_neg_2[grid(256)](buf2722, buf2730, buf2726,
            buf2732, buf2736, buf2740, buf2748, buf2752, buf2756, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2733 = torch.ops.aten.max_pool3d_with_indices.default(buf2732, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2732
        buf2734 = buf2733[0]
        del buf2733
        buf2737 = torch.ops.aten.max_pool3d_with_indices.default(buf2736, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2736
        buf2738 = buf2737[0]
        del buf2737
        buf2741 = torch.ops.aten.max_pool3d_with_indices.default(buf2740, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2740
        buf2742 = buf2741[0]
        del buf2741
        buf2744 = buf2734
        del buf2734
        triton_poi_fused_minimum_neg_3[grid(256)](buf2744, buf2742, buf2738,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2745 = torch.ops.aten.max_pool3d_with_indices.default(buf2744, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2746 = buf2745[0]
        del buf2745
        buf2749 = torch.ops.aten.max_pool3d_with_indices.default(buf2748, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2750 = buf2749[0]
        del buf2749
        buf2753 = torch.ops.aten.max_pool3d_with_indices.default(buf2752, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2754 = buf2753[0]
        del buf2753
        buf2757 = torch.ops.aten.max_pool3d_with_indices.default(buf2756, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2758 = buf2757[0]
        del buf2757
        buf2760 = buf2756
        del buf2756
        buf2764 = buf2752
        del buf2752
        buf2768 = buf2748
        del buf2748
        buf2776 = buf2744
        del buf2744
        buf2780 = buf2742
        del buf2742
        buf2784 = buf2738
        del buf2738
        triton_poi_fused_minimum_neg_2[grid(256)](buf2750, buf2758, buf2754,
            buf2760, buf2764, buf2768, buf2776, buf2780, buf2784, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2761 = torch.ops.aten.max_pool3d_with_indices.default(buf2760, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2760
        buf2762 = buf2761[0]
        del buf2761
        buf2765 = torch.ops.aten.max_pool3d_with_indices.default(buf2764, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2764
        buf2766 = buf2765[0]
        del buf2765
        buf2769 = torch.ops.aten.max_pool3d_with_indices.default(buf2768, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2768
        buf2770 = buf2769[0]
        del buf2769
        buf2772 = buf2762
        del buf2762
        triton_poi_fused_minimum_neg_3[grid(256)](buf2772, buf2770, buf2766,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        buf2773 = torch.ops.aten.max_pool3d_with_indices.default(buf2772, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        buf2774 = buf2773[0]
        del buf2773
        buf2777 = torch.ops.aten.max_pool3d_with_indices.default(buf2776, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2778 = buf2777[0]
        del buf2777
        buf2781 = torch.ops.aten.max_pool3d_with_indices.default(buf2780, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2782 = buf2781[0]
        del buf2781
        buf2785 = torch.ops.aten.max_pool3d_with_indices.default(buf2784, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2786 = buf2785[0]
        del buf2785
        buf2788 = buf2784
        del buf2784
        buf2792 = buf2780
        del buf2780
        buf2796 = buf2776
        del buf2776
        buf2804 = buf2772
        del buf2772
        buf2808 = buf2770
        del buf2770
        buf2812 = buf2766
        del buf2766
        triton_poi_fused_minimum_neg_2[grid(256)](buf2778, buf2786, buf2782,
            buf2788, buf2792, buf2796, buf2804, buf2808, buf2812, 256,
            XBLOCK=128, num_warps=4, num_stages=1)
        buf2789 = torch.ops.aten.max_pool3d_with_indices.default(buf2788, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2788
        buf2790 = buf2789[0]
        del buf2789
        buf2793 = torch.ops.aten.max_pool3d_with_indices.default(buf2792, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2792
        buf2794 = buf2793[0]
        del buf2793
        buf2797 = torch.ops.aten.max_pool3d_with_indices.default(buf2796, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2796
        buf2798 = buf2797[0]
        del buf2797
        buf2800 = buf2790
        del buf2790
        triton_poi_fused_minimum_neg_3[grid(256)](buf2800, buf2798, buf2794,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        del buf2794
        del buf2798
        buf2801 = torch.ops.aten.max_pool3d_with_indices.default(buf2800, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        del buf2800
        buf2802 = buf2801[0]
        del buf2801
        buf2805 = torch.ops.aten.max_pool3d_with_indices.default(buf2804, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        buf2806 = buf2805[0]
        del buf2805
        buf2809 = torch.ops.aten.max_pool3d_with_indices.default(buf2808, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        buf2810 = buf2809[0]
        del buf2809
        buf2813 = torch.ops.aten.max_pool3d_with_indices.default(buf2812, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        buf2814 = buf2813[0]
        del buf2813
        buf2816 = buf2812
        del buf2812
        buf2820 = buf2808
        del buf2808
        buf2824 = buf2804
        del buf2804
        triton_poi_fused_minimum_neg_4[grid(256)](buf2806, buf2814, buf2810,
            buf2816, buf2820, buf2824, 256, XBLOCK=256, num_warps=4,
            num_stages=1)
        buf2817 = torch.ops.aten.max_pool3d_with_indices.default(buf2816, [
            3, 1, 1], [1, 1, 1], [1, 0, 0])
        del buf2816
        buf2818 = buf2817[0]
        del buf2817
        buf2821 = torch.ops.aten.max_pool3d_with_indices.default(buf2820, [
            1, 3, 1], [1, 1, 1], [0, 1, 0])
        del buf2820
        buf2822 = buf2821[0]
        del buf2821
        buf2825 = torch.ops.aten.max_pool3d_with_indices.default(buf2824, [
            1, 1, 3], [1, 1, 1], [0, 0, 1])
        del buf2824
        buf2826 = buf2825[0]
        del buf2825
        buf2828 = buf2818
        del buf2818
        triton_poi_fused_minimum_neg_3[grid(256)](buf2828, buf2826, buf2822,
            256, XBLOCK=256, num_warps=4, num_stages=1)
        del buf2822
        del buf2826
        buf2829 = torch.ops.aten.max_pool3d_with_indices.default(buf2828, [
            3, 3, 3], [1, 1, 1], [1, 1, 1])
        del buf2828
        buf2830 = buf2829[0]
        del buf2829
        buf2832 = buf1430
        del buf1430
        buf2833 = buf1462
        del buf1462
        buf2834 = buf1490
        del buf1490
        buf2835 = buf1518
        del buf1518
        buf2836 = buf1546
        del buf1546
        buf2837 = buf1574
        del buf1574
        buf2838 = buf1602
        del buf1602
        buf2839 = buf1630
        del buf1630
        buf2840 = buf1658
        del buf1658
        buf2841 = buf1686
        del buf1686
        buf2842 = buf1714
        del buf1714
        buf2843 = buf1742
        del buf1742
        buf2844 = buf1770
        del buf1770
        buf2845 = buf1798
        del buf1798
        buf2846 = buf1826
        del buf1826
        buf2847 = buf1854
        del buf1854
        buf2848 = buf1882
        del buf1882
        buf2849 = buf1910
        del buf1910
        buf2850 = buf1938
        del buf1938
        buf2851 = buf1966
        del buf1966
        buf2852 = buf1994
        del buf1994
        buf2853 = buf2022
        del buf2022
        buf2854 = buf2050
        del buf2050
        buf2855 = buf2078
        del buf2078
        buf2856 = buf2106
        del buf2106
        buf2857 = buf2134
        del buf2134
        buf2858 = buf2162
        del buf2162
        buf2859 = buf2190
        del buf2190
        buf2860 = buf2218
        del buf2218
        buf2861 = buf2246
        del buf2246
        buf2862 = buf2274
        del buf2274
        buf2863 = buf2302
        del buf2302
        buf2864 = buf2330
        del buf2330
        buf2865 = buf2358
        del buf2358
        buf2866 = buf2386
        del buf2386
        buf2867 = buf2414
        del buf2414
        buf2868 = buf2442
        del buf2442
        buf2869 = buf2470
        del buf2470
        buf2870 = buf2498
        del buf2498
        buf2871 = buf2526
        del buf2526
        buf2872 = buf2554
        del buf2554
        buf2873 = buf2582
        del buf2582
        buf2874 = buf2610
        del buf2610
        buf2875 = buf2638
        del buf2638
        buf2876 = buf2666
        del buf2666
        buf2877 = buf2694
        del buf2694
        buf2878 = buf2722
        del buf2722
        buf2879 = buf2750
        del buf2750
        buf2880 = buf2778
        del buf2778
        buf2881 = buf2806
        del buf2806
        triton_poi_fused_add_minimum_mul_neg_relu_sub_5[grid(256)](buf2832,
            buf2833, buf2834, buf2835, buf2836, buf2837, buf2838, buf2839,
            buf2840, buf2841, buf2842, buf2843, buf2844, buf2845, buf2846,
            buf2847, buf2848, buf2849, buf2850, buf2851, buf2852, buf2853,
            buf2854, buf2855, buf2856, buf2857, buf2858, buf2859, buf2860,
            buf2861, buf2862, buf2863, buf2864, buf2865, buf2866, buf2867,
            buf2868, buf2869, buf2870, buf2871, buf2872, buf2873, buf2874,
            buf2875, buf2876, buf2877, buf2878, buf2879, buf2880, buf2881,
            arg1_1, buf1434, buf1442, buf1438, buf1458, buf1470, buf1466,
            buf1486, buf1498, buf1494, buf1514, buf1526, buf1522, buf1542,
            buf1554, buf1550, buf1570, buf1582, buf1578, buf1598, buf1610,
            buf1606, buf1626, buf1638, buf1634, buf1654, buf1666, buf1662,
            buf1682, buf1694, buf1690, buf1710, buf1722, buf1718, buf1738,
            buf1750, buf1746, buf1766, buf1778, buf1774, buf1794, buf1806,
            buf1802, buf1822, buf1834, buf1830, buf1850, buf1862, buf1858,
            buf1878, buf1890, buf1886, buf1906, buf1918, buf1914, buf1934,
            buf1946, buf1942, buf1962, buf1974, buf1970, buf1990, buf2002,
            buf1998, buf2018, buf2030, buf2026, buf2046, buf2058, buf2054,
            buf2074, buf2086, buf2082, buf2102, buf2114, buf2110, buf2130,
            buf2142, buf2138, buf2158, buf2170, buf2166, buf2186, buf2198,
            buf2194, buf2214, buf2226, buf2222, buf2242, buf2254, buf2250,
            buf2270, buf2282, buf2278, buf2298, buf2310, buf2306, buf2326,
            buf2338, buf2334, buf2354, buf2366, buf2362, buf2382, buf2394,
            buf2390, buf2410, buf2422, buf2418, buf2438, buf2450, buf2446,
            buf2466, buf2478, buf2474, buf2494, buf2506, buf2502, buf2522,
            buf2534, buf2530, buf2550, buf2562, buf2558, buf2578, buf2590,
            buf2586, buf2606, buf2618, buf2614, buf2634, buf2646, buf2642,
            buf2662, buf2674, buf2670, buf2690, buf2702, buf2698, buf2718,
            buf2730, buf2726, buf2746, buf2758, buf2754, buf2774, buf2786,
            buf2782, buf2802, buf2814, buf2810, buf2830, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        del arg1_1
        del buf1434
        del buf1438
        del buf1442
        del buf1458
        del buf1466
        del buf1470
        del buf1486
        del buf1494
        del buf1498
        del buf1514
        del buf1522
        del buf1526
        del buf1542
        del buf1550
        del buf1554
        del buf1570
        del buf1578
        del buf1582
        del buf1598
        del buf1606
        del buf1610
        del buf1626
        del buf1634
        del buf1638
        del buf1654
        del buf1662
        del buf1666
        del buf1682
        del buf1690
        del buf1694
        del buf1710
        del buf1718
        del buf1722
        del buf1738
        del buf1746
        del buf1750
        del buf1766
        del buf1774
        del buf1778
        del buf1794
        del buf1802
        del buf1806
        del buf1822
        del buf1830
        del buf1834
        del buf1850
        del buf1858
        del buf1862
        del buf1878
        del buf1886
        del buf1890
        del buf1906
        del buf1914
        del buf1918
        del buf1934
        del buf1942
        del buf1946
        del buf1962
        del buf1970
        del buf1974
        del buf1990
        del buf1998
        del buf2002
        del buf2018
        del buf2026
        del buf2030
        del buf2046
        del buf2054
        del buf2058
        del buf2074
        del buf2082
        del buf2086
        del buf2102
        del buf2110
        del buf2114
        del buf2130
        del buf2138
        del buf2142
        del buf2158
        del buf2166
        del buf2170
        del buf2186
        del buf2194
        del buf2198
        del buf2214
        del buf2222
        del buf2226
        del buf2242
        del buf2250
        del buf2254
        del buf2270
        del buf2278
        del buf2282
        del buf2298
        del buf2306
        del buf2310
        del buf2326
        del buf2334
        del buf2338
        del buf2354
        del buf2362
        del buf2366
        del buf2382
        del buf2390
        del buf2394
        del buf2410
        del buf2418
        del buf2422
        del buf2438
        del buf2446
        del buf2450
        del buf2466
        del buf2474
        del buf2478
        del buf2494
        del buf2502
        del buf2506
        del buf2522
        del buf2530
        del buf2534
        del buf2550
        del buf2558
        del buf2562
        del buf2578
        del buf2586
        del buf2590
        del buf2606
        del buf2614
        del buf2618
        del buf2634
        del buf2642
        del buf2646
        del buf2662
        del buf2670
        del buf2674
        del buf2690
        del buf2698
        del buf2702
        del buf2718
        del buf2726
        del buf2730
        del buf2746
        del buf2754
        del buf2758
        del buf2774
        del buf2782
        del buf2786
        del buf2802
        del buf2810
        del buf2814
        del buf2830
        del buf2832
        del buf2833
        del buf2834
        del buf2835
        del buf2836
        del buf2837
        del buf2838
        del buf2839
        del buf2840
        del buf2841
        del buf2842
        del buf2843
        del buf2844
        del buf2845
        del buf2846
        del buf2847
        del buf2848
        del buf2849
        del buf2850
        del buf2851
        del buf2852
        del buf2853
        del buf2854
        del buf2855
        del buf2856
        del buf2857
        del buf2858
        del buf2859
        del buf2860
        del buf2861
        del buf2862
        del buf2863
        del buf2864
        del buf2865
        del buf2866
        del buf2867
        del buf2868
        del buf2869
        del buf2870
        del buf2871
        del buf2872
        del buf2873
        del buf2874
        del buf2875
        del buf2876
        del buf2877
        del buf2878
        del buf2879
        del buf2880
        buf2882 = buf14
        del buf14
        buf2883 = buf2882
        del buf2882
        buf2884 = buf2883
        del buf2883
        buf2885 = buf102
        del buf102
        buf2886 = buf130
        del buf130
        buf2887 = buf158
        del buf158
        buf2888 = buf186
        del buf186
        buf2889 = buf214
        del buf214
        buf2890 = buf242
        del buf242
        buf2891 = buf270
        del buf270
        buf2892 = buf2891
        del buf2891
        buf2893 = buf2892
        del buf2892
        buf2894 = buf2893
        del buf2893
        buf2895 = buf2894
        del buf2894
        buf2896 = buf2895
        del buf2895
        buf2897 = buf2896
        del buf2896
        buf2898 = buf2897
        del buf2897
        buf2899 = buf2898
        del buf2898
        buf2900 = buf2899
        del buf2899
        buf2901 = buf2900
        del buf2900
        buf2902 = buf2901
        del buf2901
        buf2903 = buf2902
        del buf2902
        buf2904 = buf2903
        del buf2903
        buf2905 = buf2904
        del buf2904
        buf2906 = buf2905
        del buf2905
        buf2907 = buf2906
        del buf2906
        buf2908 = buf2907
        del buf2907
        buf2909 = buf2908
        del buf2908
        buf2910 = buf2909
        del buf2909
        buf2911 = buf2910
        del buf2910
        buf2912 = buf2911
        del buf2911
        buf2913 = buf2912
        del buf2912
        buf2914 = buf2913
        del buf2913
        buf2915 = buf2914
        del buf2914
        buf2916 = buf2915
        del buf2915
        buf2917 = buf1002
        del buf1002
        buf2918 = buf1026
        del buf1026
        buf2919 = buf1054
        del buf1054
        buf2920 = buf1082
        del buf1082
        buf2921 = buf1110
        del buf1110
        buf2922 = buf1138
        del buf1138
        buf2923 = buf1166
        del buf1166
        buf2924 = buf1194
        del buf1194
        buf2925 = buf1222
        del buf1222
        buf2926 = buf1250
        del buf1250
        buf2927 = buf1278
        del buf1278
        buf2928 = buf1306
        del buf1306
        buf2929 = buf1334
        del buf1334
        buf2930 = buf1362
        del buf1362
        buf2931 = buf1390
        del buf1390
        triton_poi_fused_add_minimum_mul_neg_relu_sub_6[grid(256)](buf2884,
            buf2885, buf2886, buf2887, buf2888, buf2889, buf2890, buf2916,
            buf2917, buf2918, buf2919, buf2920, buf2921, buf2922, buf2923,
            buf2924, buf2925, buf2926, buf2927, buf2928, buf2929, buf2930,
            buf2931, arg0_1, buf18, buf26, buf22, buf42, buf46, buf54,
            buf50, buf70, buf74, buf82, buf78, buf98, buf110, buf106,
            buf126, buf138, buf134, buf154, buf166, buf162, buf182, buf194,
            buf190, buf210, buf222, buf218, buf238, buf250, buf246, buf266,
            buf278, buf274, buf294, buf298, buf306, buf302, buf322, buf326,
            buf334, buf330, buf350, buf354, buf362, buf358, buf378, buf382,
            buf390, buf386, buf406, buf410, buf418, buf414, buf434, buf438,
            buf446, buf442, buf462, buf466, buf474, buf470, buf490, buf494,
            buf502, buf498, buf518, buf522, buf530, buf526, buf546, buf550,
            buf558, buf554, buf574, buf578, buf586, buf582, buf602, buf606,
            buf614, buf610, buf630, buf634, buf642, buf638, buf658, buf662,
            buf670, buf666, buf686, buf690, buf698, buf694, buf714, buf718,
            buf726, buf722, buf742, buf746, buf754, buf750, buf770, buf774,
            buf782, buf778, buf798, buf802, buf810, buf806, buf826, buf830,
            buf838, buf834, buf854, buf858, buf866, buf862, buf882, buf886,
            buf894, buf890, buf910, buf914, buf922, buf918, buf938, buf942,
            buf950, buf946, buf966, buf970, buf978, buf974, buf994, buf998,
            buf1006, buf1022, buf1034, buf1030, buf1050, buf1062, buf1058,
            buf1078, buf1090, buf1086, buf1106, buf1118, buf1114, buf1134,
            buf1146, buf1142, buf1162, buf1174, buf1170, buf1190, buf1202,
            buf1198, buf1218, buf1230, buf1226, buf1246, buf1258, buf1254,
            buf1274, buf1286, buf1282, buf1302, buf1314, buf1310, buf1330,
            buf1342, buf1338, buf1358, buf1370, buf1366, buf1386, buf1398,
            buf1394, buf1414, 256, XBLOCK=128, num_warps=4, num_stages=1)
        del arg0_1
        del buf1006
        del buf1022
        del buf1030
        del buf1034
        del buf1050
        del buf1058
        del buf106
        del buf1062
        del buf1078
        del buf1086
        del buf1090
        del buf110
        del buf1106
        del buf1114
        del buf1118
        del buf1134
        del buf1142
        del buf1146
        del buf1162
        del buf1170
        del buf1174
        del buf1190
        del buf1198
        del buf1202
        del buf1218
        del buf1226
        del buf1230
        del buf1246
        del buf1254
        del buf1258
        del buf126
        del buf1274
        del buf1282
        del buf1286
        del buf1302
        del buf1310
        del buf1314
        del buf1330
        del buf1338
        del buf134
        del buf1342
        del buf1358
        del buf1366
        del buf1370
        del buf138
        del buf1386
        del buf1394
        del buf1398
        del buf1414
        del buf154
        del buf162
        del buf166
        del buf18
        del buf182
        del buf190
        del buf194
        del buf210
        del buf218
        del buf22
        del buf222
        del buf238
        del buf246
        del buf250
        del buf26
        del buf266
        del buf274
        del buf278
        del buf2884
        del buf2885
        del buf2886
        del buf2887
        del buf2888
        del buf2889
        del buf2890
        del buf2916
        del buf2917
        del buf2918
        del buf2919
        del buf2920
        del buf2921
        del buf2922
        del buf2923
        del buf2924
        del buf2925
        del buf2926
        del buf2927
        del buf2928
        del buf2929
        del buf2930
        del buf294
        del buf298
        del buf302
        del buf306
        del buf322
        del buf326
        del buf330
        del buf334
        del buf350
        del buf354
        del buf358
        del buf362
        del buf378
        del buf382
        del buf386
        del buf390
        del buf406
        del buf410
        del buf414
        del buf418
        del buf42
        del buf434
        del buf438
        del buf442
        del buf446
        del buf46
        del buf462
        del buf466
        del buf470
        del buf474
        del buf490
        del buf494
        del buf498
        del buf50
        del buf502
        del buf518
        del buf522
        del buf526
        del buf530
        del buf54
        del buf546
        del buf550
        del buf554
        del buf558
        del buf574
        del buf578
        del buf582
        del buf586
        del buf602
        del buf606
        del buf610
        del buf614
        del buf630
        del buf634
        del buf638
        del buf642
        del buf658
        del buf662
        del buf666
        del buf670
        del buf686
        del buf690
        del buf694
        del buf698
        del buf70
        del buf714
        del buf718
        del buf722
        del buf726
        del buf74
        del buf742
        del buf746
        del buf750
        del buf754
        del buf770
        del buf774
        del buf778
        del buf78
        del buf782
        del buf798
        del buf802
        del buf806
        del buf810
        del buf82
        del buf826
        del buf830
        del buf834
        del buf838
        del buf854
        del buf858
        del buf862
        del buf866
        del buf882
        del buf886
        del buf890
        del buf894
        del buf910
        del buf914
        del buf918
        del buf922
        del buf938
        del buf942
        del buf946
        del buf950
        del buf966
        del buf970
        del buf974
        del buf978
        del buf98
        del buf994
        del buf998
    return buf2881, buf2931


def sum_tensor(inp, axes, keepdim=False):
    axes = np.unique(axes).astype(int)
    if keepdim:
        for ax in axes:
            inp = inp.sum(int(ax), keepdim=True)
    else:
        for ax in sorted(axes, reverse=True):
            inp = inp.sum(int(ax))
    return inp


def get_tp_fp_fn_tn(net_output, gt, axes=None, mask=None, square=False):
    """
    net_output must be (b, c, x, y(, z)))
    gt must be a label map (shape (b, 1, x, y(, z)) OR shape (b, x, y(, z))) or one hot encoding (b, c, x, y(, z))
    if mask is provided it must have shape (b, 1, x, y(, z)))
    :param net_output:
    :param gt:
    :param axes: can be (, ) = no summation
    :param mask: mask must be 1 for valid pixels and 0 for invalid pixels
    :param square: if True then fp, tp and fn will be squared before summation
    :return:
    """
    if axes is None:
        axes = tuple(range(2, len(net_output.size())))
    shp_x = net_output.shape
    shp_y = gt.shape
    with torch.no_grad():
        if len(shp_x) != len(shp_y):
            gt = gt.view((shp_y[0], 1, *shp_y[1:]))
        if all([(i == j) for i, j in zip(net_output.shape, gt.shape)]):
            y_onehot = gt
        else:
            gt = gt.long()
            y_onehot = torch.zeros(shp_x)
            if net_output.device.type == 'cuda':
                y_onehot = y_onehot
            y_onehot.scatter_(1, gt, 1)
    tp = net_output * y_onehot
    fp = net_output * (1 - y_onehot)
    fn = (1 - net_output) * y_onehot
    tn = (1 - net_output) * (1 - y_onehot)
    if mask is not None:
        tp = torch.stack(tuple(x_i * mask[:, 0] for x_i in torch.unbind(tp,
            dim=1)), dim=1)
        fp = torch.stack(tuple(x_i * mask[:, 0] for x_i in torch.unbind(fp,
            dim=1)), dim=1)
        fn = torch.stack(tuple(x_i * mask[:, 0] for x_i in torch.unbind(fn,
            dim=1)), dim=1)
        tn = torch.stack(tuple(x_i * mask[:, 0] for x_i in torch.unbind(tn,
            dim=1)), dim=1)
    if square:
        tp = tp ** 2
        fp = fp ** 2
        fn = fn ** 2
        tn = tn ** 2
    if len(axes) > 0:
        tp = sum_tensor(tp, axes, keepdim=False)
        fp = sum_tensor(fp, axes, keepdim=False)
        fn = sum_tensor(fn, axes, keepdim=False)
        tn = sum_tensor(tn, axes, keepdim=False)
    return tp, fp, fn, tn


def soft_erode(I):
    p1 = -F.max_pool3d(-I, (3, 1, 1), (1, 1, 1), (1, 0, 0))
    p2 = -F.max_pool3d(-I, (1, 3, 1), (1, 1, 1), (0, 1, 0))
    p3 = -F.max_pool3d(-I, (1, 1, 3), (1, 1, 1), (0, 0, 1))
    return torch.min(torch.min(p1, p3), p2)


def soft_dilate(I):
    return F.max_pool3d(I, (3, 3, 3), (1, 1, 1), (1, 1, 1))


def soft_open(I):
    return soft_dilate(soft_erode(I))


def soft_skel(img, k=50):
    img1 = soft_open(img)
    skel = F.relu(img - img1)
    for iter in range(k):
        img = soft_erode(img)
        img1 = soft_open(img)
        delta = F.relu(img - img1)
        skel = skel + F.relu(delta - skel * delta)
    if torch.cuda.is_available():
        del img1
        del delta
    return skel


class SoftClDiceLossNew(nn.Module):

    def __init__(self, apply_nonlin=None, batch_dice=False, do_bg=True,
        smooth=1.0, k=2):
        """
        """
        super(SoftClDiceLossNew, self).__init__()
        self.do_bg = do_bg
        self.batch_dice = batch_dice
        self.apply_nonlin = apply_nonlin
        self.smooth = smooth
        self.k = k

    def softCenterline(self, I):
        max = nn.MaxPool3d(3, stride=1, padding=1)
        relu = nn.ReLU()
        Ip = max(-max(-I))
        cl = relu(I - Ip)
        for iter in range(self.k):
            I = -max(-I)
            Ip = max(-max(-I))
            cl = cl + cl * relu(I - Ip)
        return cl

    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.02017