# AOT ID: ['0_inference']
from ctypes import c_void_p, c_long, c_int
import torch
import math
import random
import os
import tempfile
from math import inf, nan
from torch._inductor.hooks import run_intermediate_hooks
from torch._inductor.utils import maybe_profile
from torch._inductor.codegen.memory_planning import _align as align
from torch import device, empty_strided
from torch._inductor.async_compile import AsyncCompile
from torch._inductor.select_algorithm import extern_kernels
from torch._inductor.codegen.multi_kernel import MultiKernelCall
import triton
import triton.language as tl
from torch._inductor.runtime.triton_heuristics import grid, split_scan_grid, grid_combo_kernels, start_graph, end_graph
from torch._C import _cuda_getCurrentRawStream as get_raw_stream

aten = torch.ops.aten
inductor_ops = torch.ops.inductor
_quantized = torch.ops._quantized
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cpu = torch._C._dynamo.guards._empty_strided_cpu
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda
empty_strided_xpu = torch._C._dynamo.guards._empty_strided_xpu
reinterpret_tensor = torch._C._dynamo.guards._reinterpret_tensor
alloc_from_pool = torch.ops.inductor._alloc_from_pool
async_compile = AsyncCompile()


# kernel path: runs/run_shard_0/inductor_cache/wh/cwh6ekspxfmultwzah26ckbd4e4xrlumdjaf4bmnjciawnbgob4k.py
# Topologically Sorted Source Nodes: [dy, dx, setitem, pow_1, mean, setitem_1, pow_2, mean_1], Original ATen: [aten.sub, aten.lift_fresh, aten.fill, aten.pow, aten.mean]
# Source node to ATen node mapping:
#   dx => sub
#   dy => sub_1
#   mean => mean
#   mean_1 => mean_1
#   pow_1 => pow_1
#   pow_2 => pow_2
#   setitem => copy, full_default
#   setitem_1 => copy_1, full_default_1
# Graph fragment:
#   %sub_1 : [num_users=3] = call_function[target=torch.ops.aten.sub.Tensor](args = (%slice_3, %arg0_1), kwargs = {})
#   %sub : [num_users=2] = call_function[target=torch.ops.aten.sub.Tensor](args = (%slice_2, %arg0_1), kwargs = {})
#   %full_default : [num_users=1] = call_function[target=torch.ops.aten.full.default](args = ([], 0.0), kwargs = {dtype: torch.float32, layout: torch.strided, device: cuda:0, pin_memory: False})
#   %copy : [num_users=1] = call_function[target=torch.ops.aten.copy.default](args = (%slice_8, %full_default), kwargs = {})
#   %slice_scatter_default : [num_users=1] = call_function[target=torch.ops.aten.slice_scatter.default](args = (%sub, %copy, 3, -1, 9223372036854775807), kwargs = {})
#   %pow_1 : [num_users=1] = call_function[target=torch.ops.aten.pow.Tensor_Scalar](args = (%slice_scatter_default, 2), kwargs = {})
#   %mean : [num_users=1] = call_function[target=torch.ops.aten.mean.dim](args = (%pow_1, [-3, -2, -1]), kwargs = {})
#   %full_default_1 : [num_users=1] = call_function[target=torch.ops.aten.full.default](args = ([], 0.0), kwargs = {dtype: torch.float32, layout: torch.strided, device: cuda:0, pin_memory: False})
#   %copy_1 : [num_users=1] = call_function[target=torch.ops.aten.copy.default](args = (%slice_18, %full_default_1), kwargs = {})
#   %slice_scatter_default_1 : [num_users=1] = call_function[target=torch.ops.aten.slice_scatter.default](args = (%sub_1, %copy_1, 2, -1, 9223372036854775807), kwargs = {})
#   %pow_2 : [num_users=1] = call_function[target=torch.ops.aten.pow.Tensor_Scalar](args = (%slice_scatter_default_1, 2), kwargs = {})
#   %mean_1 : [num_users=1] = call_function[target=torch.ops.aten.mean.dim](args = (%pow_2, [-3, -2, -1]), kwargs = {})
triton_per_fused_fill_lift_fresh_mean_pow_sub_0 = async_compile.triton('triton_per_fused_fill_lift_fresh_mean_pow_sub_0', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[4, 64],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2, 4), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_fill_lift_fresh_mean_pow_sub_0', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 3, 'num_reduction': 2, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_fill_lift_fresh_mean_pow_sub_0(in_ptr0, out_ptr0, out_ptr1, xnumel, rnumel, XBLOCK : tl.constexpr):
    xnumel = 4
    rnumel = 64
    RBLOCK: tl.constexpr = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rindex = tl.arange(0, RBLOCK)[None, :]
    roffset = 0
    rmask = tl.full([XBLOCK, RBLOCK], True, tl.int1)
    r1 = rindex % 4
    r5 = rindex
    x0 = xindex
    r3 = (rindex // 4) % 4
    tmp10 = tl.load(in_ptr0 + (r5 + (64*x0)), xmask, other=0.0)
    tmp0 = r1
    tmp1 = tl.full([1, 1], 3, tl.int64)
    tmp2 = tmp0 >= tmp1
    tmp3 = 0.0
    tmp4 = tl.full(tmp3.shape, 0.0, tmp3.dtype)
    tmp5 = tl.where(tmp2, tmp3, tmp4)
    tmp6 = 1 + r1
    tmp7 = tl.full([1, 1], 4, tl.int64)
    tmp8 = tmp6 < tmp7
    tmp9 = tl.load(in_ptr0 + (1 + r5 + (64*x0)), tmp8 & xmask, other=0.0)
    tmp11 = tmp9 - tmp10
    tmp12 = tl.where(tmp2, tmp5, tmp11)
    tmp13 = tmp12 * tmp12
    tmp14 = tl.broadcast_to(tmp13, [XBLOCK, RBLOCK])
    tmp16 = tl.where(xmask, tmp14, 0)
    tmp17 = tl.sum(tmp16, 1)[:, None]
    tmp18 = r3
    tmp19 = tmp18 >= tmp1
    tmp20 = tl.where(tmp19, tmp3, tmp4)
    tmp21 = 1 + r3
    tmp22 = tmp21 < tmp7
    tmp23 = tl.load(in_ptr0 + (4 + r5 + (64*x0)), tmp22 & xmask, other=0.0)
    tmp24 = tmp23 - tmp10
    tmp25 = tl.where(tmp19, tmp20, tmp24)
    tmp26 = tmp25 * tmp25
    tmp27 = tl.broadcast_to(tmp26, [XBLOCK, RBLOCK])
    tmp29 = tl.where(xmask, tmp27, 0)
    tmp30 = tl.sum(tmp29, 1)[:, None]
    tl.store(out_ptr0 + (x0), tmp17, xmask)
    tl.store(out_ptr1 + (x0), tmp30, xmask)
''', device_str='cuda')


# kernel path: runs/run_shard_0/inductor_cache/xx/cxxmaufbi2vxy3hgqyibhahljcxeuub3oywnnullhormjkmz4lno.py
# Topologically Sorted Source Nodes: [dy, dx, setitem, pow_1, mean, loss, setitem_1, pow_2, mean_1, loss_1, loss_2, mul], Original ATen: [aten.sub, aten.lift_fresh, aten.fill, aten.pow, aten.mean, aten.add, aten.sum, aten.mul]
# Source node to ATen node mapping:
#   dx => sub
#   dy => sub_1
#   loss => add
#   loss_1 => add_1
#   loss_2 => sum_1
#   mean => mean
#   mean_1 => mean_1
#   mul => mul
#   pow_1 => pow_1
#   pow_2 => pow_2
#   setitem => copy, full_default
#   setitem_1 => copy_1, full_default_1
# Graph fragment:
#   %sub_1 : [num_users=3] = call_function[target=torch.ops.aten.sub.Tensor](args = (%slice_3, %arg0_1), kwargs = {})
#   %sub : [num_users=2] = call_function[target=torch.ops.aten.sub.Tensor](args = (%slice_2, %arg0_1), kwargs = {})
#   %full_default : [num_users=1] = call_function[target=torch.ops.aten.full.default](args = ([], 0.0), kwargs = {dtype: torch.float32, layout: torch.strided, device: cuda:0, pin_memory: False})
#   %copy : [num_users=1] = call_function[target=torch.ops.aten.copy.default](args = (%slice_8, %full_default), kwargs = {})
#   %slice_scatter_default : [num_users=1] = call_function[target=torch.ops.aten.slice_scatter.default](args = (%sub, %copy, 3, -1, 9223372036854775807), kwargs = {})
#   %pow_1 : [num_users=1] = call_function[target=torch.ops.aten.pow.Tensor_Scalar](args = (%slice_scatter_default, 2), kwargs = {})
#   %mean : [num_users=1] = call_function[target=torch.ops.aten.mean.dim](args = (%pow_1, [-3, -2, -1]), kwargs = {})
#   %add : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%mean, 0), kwargs = {})
#   %full_default_1 : [num_users=1] = call_function[target=torch.ops.aten.full.default](args = ([], 0.0), kwargs = {dtype: torch.float32, layout: torch.strided, device: cuda:0, pin_memory: False})
#   %copy_1 : [num_users=1] = call_function[target=torch.ops.aten.copy.default](args = (%slice_18, %full_default_1), kwargs = {})
#   %slice_scatter_default_1 : [num_users=1] = call_function[target=torch.ops.aten.slice_scatter.default](args = (%sub_1, %copy_1, 2, -1, 9223372036854775807), kwargs = {})
#   %pow_2 : [num_users=1] = call_function[target=torch.ops.aten.pow.Tensor_Scalar](args = (%slice_scatter_default_1, 2), kwargs = {})
#   %mean_1 : [num_users=1] = call_function[target=torch.ops.aten.mean.dim](args = (%pow_2, [-3, -2, -1]), kwargs = {})
#   %add_1 : [num_users=1] = call_function[target=torch.ops.aten.add.Tensor](args = (%add, %mean_1), kwargs = {})
#   %sum_1 : [num_users=1] = call_function[target=torch.ops.aten.sum.default](args = (%add_1,), kwargs = {})
#   %mul : [num_users=1] = call_function[target=torch.ops.aten.mul.Tensor](args = (%sum_1, 0.25), kwargs = {})
triton_per_fused_add_fill_lift_fresh_mean_mul_pow_sub_sum_1 = async_compile.triton('triton_per_fused_add_fill_lift_fresh_mean_mul_pow_sub_sum_1', '''
import triton
import triton.language as tl
from triton.compiler.compiler import AttrsDescriptor

from torch._inductor.runtime import triton_helpers, triton_heuristics
from torch._inductor.runtime.triton_helpers import libdevice, math as tl_math
from torch._inductor.runtime.hints import AutotuneHint, ReductionHint, TileHint, instance_descriptor, DeviceProperties

@triton_heuristics.persistent_reduction(
    size_hints=[1, 4],
    reduction_hint=ReductionHint.INNER,
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: 'i32', 4: 'i32'}, 'device': DeviceProperties(type='cuda', index=0, cc=80, major=8, regs_per_multiprocessor=65536, max_threads_per_multi_processor=2048, multi_processor_count=108), 'constants': {3: 1}, 'configs': [AttrsDescriptor(divisible_by_16=(0, 1, 2), equal_to_1=(3,))]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_per_fused_add_fill_lift_fresh_mean_mul_pow_sub_sum_1', 'mutated_arg_names': ['in_out_ptr0'], 'no_x_dim': False, 'num_load': 2, 'num_reduction': 1, 'backend_hash': 'A9C866B4A14FD3277824029365D703C2427B2E685E54EC9B3EF4ADC8D1EEAC1D', 'are_deterministic_algorithms_enabled': False, 'assert_indirect_indexing': True, 'autotune_local_cache': True, 'autotune_pointwise': True, 'autotune_remote_cache': None, 'force_disable_caches': False, 'dynamic_scale_rblock': True, 'max_autotune': False, 'max_autotune_pointwise': False, 'min_split_scan_rblock': 256, 'spill_threshold': 16, 'store_cubin': False}
)
@triton.jit
def triton_per_fused_add_fill_lift_fresh_mean_mul_pow_sub_sum_1(in_out_ptr0, in_ptr0, in_ptr1, xnumel, rnumel, XBLOCK : tl.constexpr):
    xnumel = 1
    rnumel = 4
    RBLOCK: tl.constexpr = 4
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = tl.full([XBLOCK, RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[None, :]
    roffset = 0
    rmask = tl.full([XBLOCK, RBLOCK], True, tl.int1)
    r0 = rindex
    tmp0 = tl.load(in_ptr0 + (r0), None)
    tmp5 = tl.load(in_ptr1 + (r0), None)
    tmp1 = 64.0
    tmp2 = tmp0 / tmp1
    tmp3 = 0.0
    tmp4 = tmp2 + tmp3
    tmp6 = tmp5 / tmp1
    tmp7 = tmp4 + tmp6
    tmp8 = tl.broadcast_to(tmp7, [XBLOCK, RBLOCK])
    tmp10 = tl.sum(tmp8, 1)[:, None]
    tmp11 = 0.25
    tmp12 = tmp10 * tmp11
    tl.debug_barrier()
    tl.store(in_out_ptr0 + (tl.full([XBLOCK, 1], 0, tl.int32)), tmp12, None)
''', device_str='cuda')


async_compile.wait(globals())
del async_compile

def call(args):
    arg0_1, = args
    args.clear()
    assert_size_stride(arg0_1, (4, 4, 4, 4), (64, 16, 4, 1))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4, ), (1, ), torch.float32)
        buf1 = empty_strided_cuda((4, ), (1, ), torch.float32)
        # Topologically Sorted Source Nodes: [dy, dx, setitem, pow_1, mean, setitem_1, pow_2, mean_1], Original ATen: [aten.sub, aten.lift_fresh, aten.fill, aten.pow, aten.mean]
        stream0 = get_raw_stream(0)
        triton_per_fused_fill_lift_fresh_mean_pow_sub_0.run(arg0_1, buf0, buf1, 4, 64, grid=grid(4), stream=stream0)
        del arg0_1
        buf2 = empty_strided_cuda((), (), torch.float32)
        buf3 = buf2; del buf2  # reuse
        # Topologically Sorted Source Nodes: [dy, dx, setitem, pow_1, mean, loss, setitem_1, pow_2, mean_1, loss_1, loss_2, mul], Original ATen: [aten.sub, aten.lift_fresh, aten.fill, aten.pow, aten.mean, aten.add, aten.sum, aten.mul]
        triton_per_fused_add_fill_lift_fresh_mean_mul_pow_sub_sum_1.run(buf3, buf0, buf1, 1, 4, grid=grid(1), stream=stream0)
        del buf0
        del buf1
    return (buf3, )


def benchmark_compiled_module(times=10, repeat=10):
    from torch._dynamo.testing import rand_strided
    from torch._inductor.utils import print_performance
    arg0_1 = rand_strided((4, 4, 4, 4), (64, 16, 4, 1), device='cuda:0', dtype=torch.float32)
    fn = lambda: call([arg0_1])
    return print_performance(fn, times=times, repeat=repeat)


if __name__ == "__main__":
    from torch._inductor.wrapper_benchmark import compiled_module_main
    compiled_module_main('None', benchmark_compiled_module)

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.nn import functional as F
import torch.nn as nn
assert_size_stride = torch._C._dynamo.guards.assert_size_stride
empty_strided_cuda = torch._C._dynamo.guards._empty_strided_cuda


@triton.jit
def triton_per_fused_fill_lift_fresh_mean_pow_sub_0(in_ptr0, out_ptr0,
    out_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr):
    xnumel = 4
    RBLOCK: tl.constexpr = 64
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:, None]
    xmask = xindex < xnumel
    rindex = tl.arange(0, RBLOCK)[None, :]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    r1 = rindex % 4
    r5 = rindex
    x0 = xindex
    r3 = rindex // 4 % 4
    tmp10 = tl.load(in_ptr0 + (r5 + 64 * x0), xmask, other=0.0)
    tmp0 = r1
    tmp1 = tl.full([1, 1], 3, tl.int64)
    tmp2 = tmp0 >= tmp1
    tmp3 = 0.0
    tmp4 = tl.full(tmp3.shape, 0.0, tmp3.dtype)
    tmp5 = tl.where(tmp2, tmp3, tmp4)
    tmp6 = 1 + r1
    tmp7 = tl.full([1, 1], 4, tl.int64)
    tmp8 = tmp6 < tmp7
    tmp9 = tl.load(in_ptr0 + (1 + r5 + 64 * x0), tmp8 & xmask, other=0.0)
    tmp11 = tmp9 - tmp10
    tmp12 = tl.where(tmp2, tmp5, tmp11)
    tmp13 = tmp12 * tmp12
    tmp14 = tl.broadcast_to(tmp13, [XBLOCK, RBLOCK])
    tmp16 = tl.where(xmask, tmp14, 0)
    tmp17 = tl.sum(tmp16, 1)[:, None]
    tmp18 = r3
    tmp19 = tmp18 >= tmp1
    tmp20 = tl.where(tmp19, tmp3, tmp4)
    tmp21 = 1 + r3
    tmp22 = tmp21 < tmp7
    tmp23 = tl.load(in_ptr0 + (4 + r5 + 64 * x0), tmp22 & xmask, other=0.0)
    tmp24 = tmp23 - tmp10
    tmp25 = tl.where(tmp19, tmp20, tmp24)
    tmp26 = tmp25 * tmp25
    tmp27 = tl.broadcast_to(tmp26, [XBLOCK, RBLOCK])
    tmp29 = tl.where(xmask, tmp27, 0)
    tmp30 = tl.sum(tmp29, 1)[:, None]
    tl.store(out_ptr0 + x0, tmp17, xmask)
    tl.store(out_ptr1 + x0, tmp30, xmask)


@triton.jit
def triton_per_fused_add_fill_lift_fresh_mean_mul_pow_sub_sum_1(in_out_ptr0,
    in_ptr0, in_ptr1, xnumel, rnumel, XBLOCK: tl.constexpr):
    RBLOCK: tl.constexpr = 4
    xoffset = tl.program_id(0) * XBLOCK
    xoffset + tl.arange(0, XBLOCK)[:, None]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    rindex = tl.arange(0, RBLOCK)[None, :]
    tl.full([XBLOCK, RBLOCK], True, tl.int1)
    r0 = rindex
    tmp0 = tl.load(in_ptr0 + r0, None)
    tmp5 = tl.load(in_ptr1 + r0, None)
    tmp1 = 64.0
    tmp2 = tmp0 / tmp1
    tmp3 = 0.0
    tmp4 = tmp2 + tmp3
    tmp6 = tmp5 / tmp1
    tmp7 = tmp4 + tmp6
    tmp8 = tl.broadcast_to(tmp7, [XBLOCK, RBLOCK])
    tmp10 = tl.sum(tmp8, 1)[:, None]
    tmp11 = 0.25
    tmp12 = tmp10 * tmp11
    tl.debug_barrier()
    tl.store(in_out_ptr0 + tl.full([XBLOCK, 1], 0, tl.int32), tmp12, None)


def call(args):
    arg0_1, = args
    args.clear()
    assert_size_stride(arg0_1, (4, 4, 4, 4), (64, 16, 4, 1))
    with torch.cuda._DeviceGuard(0):
        torch.cuda.set_device(0)
        buf0 = empty_strided_cuda((4,), (1,), torch.float32)
        buf1 = empty_strided_cuda((4,), (1,), torch.float32)
        get_raw_stream(0)
        triton_per_fused_fill_lift_fresh_mean_pow_sub_0[grid(4)](arg0_1,
            buf0, buf1, 4, 64, XBLOCK=1, num_warps=2, num_stages=1)
        del arg0_1
        buf2 = empty_strided_cuda((), (), torch.float32)
        buf3 = buf2
        del buf2
        triton_per_fused_add_fill_lift_fresh_mean_mul_pow_sub_sum_1[grid(1)](
            buf3, buf0, buf1, 1, 4, XBLOCK=1, num_warps=2, num_stages=1)
        del buf0
        del buf1
    return buf3,


def get_image_gradients(image: 'torch.Tensor', step: 'int'=1):
    """Returns image gradients (dy, dx) for each color channel, using
    the finite-difference approximation.
    Places the gradient [ie. I(x+1,y) - I(x,y)] on the base pixel (x, y).
    Both output tensors have the same shape as the input: [b, c, h, w].

    Arguments:
        image: Tensor with shape [b, c, h, w].
        step: the size of the step for the finite difference
    Returns:
        Pair of tensors (dy, dx) holding the vertical and horizontal
        image gradients (ie. 1-step finite difference). To match the
        original size image, for example with step=1, dy will always
        have zeros in the last row, and dx will always have zeros in
        the last column.
    """
    right = F.pad(image, (0, step, 0, 0))[..., :, step:]
    bottom = F.pad(image, (0, 0, 0, step))[..., step:, :]
    dx, dy = right - image, bottom - image
    dx[:, :, :, -step:] = 0
    dy[:, :, -step:, :] = 0
    return dx, dy


def get_outnorm(x: 'torch.Tensor', out_norm: 'str'='') ->torch.Tensor:
    """ Common function to get a loss normalization value. Can
        normalize by either the batch size ('b'), the number of
        channels ('c'), the image size ('i') or combinations
        ('bi', 'bci', etc)
    """
    img_shape = x.shape
    if not out_norm:
        return 1
    norm = 1
    if 'b' in out_norm:
        norm /= img_shape[0]
    if 'c' in out_norm:
        norm /= img_shape[-3]
    if 'i' in out_norm:
        norm /= img_shape[-1] * img_shape[-2]
    return norm


def get_4dim_image_gradients(image: 'torch.Tensor'):
    """Returns image gradients (dy, dx) for each color channel, using
    the finite-difference approximation.
    Similar to get_image_gradients(), but additionally calculates the
    gradients in the two diagonal directions: 'dp' (the positive
    diagonal: bottom left to top right) and 'dn' (the negative
    diagonal: top left to bottom right).
    Only 1-step finite difference has been tested and is available.

    Arguments:
        image: Tensor with shape [b, c, h, w].
    Returns:
        tensors (dy, dx, dp, dn) holding the vertical, horizontal and
        diagonal image gradients (1-step finite difference). dx will
        always have zeros in the last column, dy will always have zeros
        in the last row, dp will always have zeros in the last row.
    """
    right = F.pad(image, (0, 1, 0, 0))[..., :, 1:]
    bottom = F.pad(image, (0, 0, 0, 1))[..., 1:, :]
    botright = F.pad(image, (0, 1, 0, 1))[..., 1:, 1:]
    dx, dy = right - image, bottom - image
    dn, dp = botright - image, right - bottom
    dx[:, :, :, -1] = 0
    dy[:, :, -1, :] = 0
    dp[:, :, -1, :] = 0
    return dx, dy, dp, dn


class TVLossNew(nn.Module):
    """Calculate the L1 or L2 total variation regularization.
    Also can calculate experimental 4D directional total variation.
    Args:
        tv_type: regular 'tv' or 4D 'dtv'
        p: use the absolute values '1' or Euclidean distance '2' to
            calculate the tv. (alt names: 'l1' and 'l2')
        reduction: aggregate results per image either by their 'mean' or
            by the total 'sum'. Note: typically, 'sum' should be
            normalized with out_norm: 'bci', while 'mean' needs only 'b'.
        out_norm: normalizes the TV loss by either the batch size ('b'), the
            number of channels ('c'), the image size ('i') or combinations
            ('bi', 'bci', etc).
        beta: β factor to control the balance between sharp edges (1<β<2)
            and washed out results (penalizing edges) with β >= 2.
    Ref:
        Mahendran et al. https://arxiv.org/pdf/1412.0035.pdf
    """

    def __init__(self, tv_type: 'str'='tv', p=2, reduction: 'str'='mean',
        out_norm: 'str'='b', beta: 'int'=2) ->None:
        super(TVLossNew, self).__init__()
        if isinstance(p, str):
            p = 1 if '1' in p else 2
        if p not in [1, 2]:
            raise ValueError(f'Expected p value to be 1 or 2, but got {p}')
        self.p = p
        self.tv_type = tv_type.lower()
        self.reduction = torch.sum if reduction == 'sum' else torch.mean
        self.out_norm = out_norm
        self.beta = beta

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