# AOT ID: ['0_forward']
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_8/inductor_cache/it/citf76sfvzevdyefubb2wimef7vawjm6wo43m4fvgaqjdgvqrzwh.py
# Topologically Sorted Source Nodes: [log, neg, truediv, sub, sub_1, truediv_1, pow_1, truediv_2, sub_2, exp], Original ATen: [aten.log, aten.neg, aten.div, aten.sub, aten.pow, aten.exp]
# Source node to ATen node mapping:
#   exp => exp
#   log => log
#   neg => neg
#   pow_1 => pow_1
#   sub => sub
#   sub_1 => sub_1
#   sub_2 => sub_2
#   truediv => div
#   truediv_1 => div_1
#   truediv_2 => div_2
# Graph fragment:
#   %log : [num_users=1] = call_function[target=torch.ops.aten.log.default](args = (%unsqueeze,), kwargs = {})
#   %neg : [num_users=1] = call_function[target=torch.ops.aten.neg.default](args = (%log,), kwargs = {})
#   %div : [num_users=1] = call_function[target=torch.ops.aten.div.Tensor](args = (%primals_2, 2), kwargs = {})
#   %sub : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%neg, %div), kwargs = {})
#   %sub_1 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%primals_4, %unsqueeze_1), kwargs = {})
#   %div_1 : [num_users=1] = call_function[target=torch.ops.aten.div.Tensor](args = (%sub_1, %unsqueeze), kwargs = {})
#   %pow_1 : [num_users=1] = call_function[target=torch.ops.aten.pow.Tensor_Scalar](args = (%div_1, 2), kwargs = {})
#   %div_2 : [num_users=1] = call_function[target=torch.ops.aten.div.Tensor](args = (%pow_1, 2), kwargs = {})
#   %sub_2 : [num_users=1] = call_function[target=torch.ops.aten.sub.Tensor](args = (%sub, %div_2), kwargs = {})
#   %exp : [num_users=1] = call_function[target=torch.ops.aten.exp.default](args = (%sub_2,), kwargs = {})
triton_poi_fused_div_exp_log_neg_pow_sub_0 = async_compile.triton('triton_poi_fused_div_exp_log_neg_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.pointwise(
    size_hints=[256], 
    filename=__file__,
    triton_meta={'signature': {0: '*fp32', 1: '*fp32', 2: '*fp32', 3: '*fp32', 4: '*fp32', 5: '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, 3, 4, 5), equal_to_1=())]},
    inductor_meta={'autotune_hints': set(), 'kernel_name': 'triton_poi_fused_div_exp_log_neg_pow_sub_0', 'mutated_arg_names': [], 'no_x_dim': False, 'num_load': 4, 'num_reduction': 0, '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},
    min_elem_per_thread=0
)
@triton.jit
def triton_poi_fused_div_exp_log_neg_pow_sub_0(in_ptr0, in_ptr1, in_ptr2, in_ptr3, out_ptr0, xnumel, XBLOCK : tl.constexpr):
    xnumel = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + (0))
    tmp1 = tl.broadcast_to(tmp0, [XBLOCK])
    tmp4 = tl.load(in_ptr1 + (0))
    tmp5 = tl.broadcast_to(tmp4, [XBLOCK])
    tmp9 = tl.load(in_ptr2 + (x0), xmask)
    tmp10 = tl.load(in_ptr3 + (0))
    tmp11 = tl.broadcast_to(tmp10, [XBLOCK])
    tmp2 = tl_math.log(tmp1)
    tmp3 = -tmp2
    tmp6 = 0.5
    tmp7 = tmp5 * tmp6
    tmp8 = tmp3 - tmp7
    tmp12 = tmp9 - tmp11
    tmp13 = tmp12 / tmp1
    tmp14 = tmp13 * tmp13
    tmp15 = tmp14 * tmp6
    tmp16 = tmp8 - tmp15
    tmp17 = tl_math.exp(tmp16)
    tl.store(out_ptr0 + (x0), tmp17, xmask)
''', device_str='cuda')


async_compile.wait(globals())
del async_compile

def call(args):
    primals_1, primals_2, primals_3, primals_4 = args
    args.clear()
    assert_size_stride(primals_1, (1, ), (1, ))
    assert_size_stride(primals_2, (1, ), (1, ))
    assert_size_stride(primals_3, (1, ), (1, ))
    assert_size_stride(primals_4, (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)
        # Topologically Sorted Source Nodes: [log, neg, truediv, sub, sub_1, truediv_1, pow_1, truediv_2, sub_2, exp], Original ATen: [aten.log, aten.neg, aten.div, aten.sub, aten.pow, aten.exp]
        stream0 = get_raw_stream(0)
        triton_poi_fused_div_exp_log_neg_pow_sub_0.run(primals_1, primals_2, primals_4, primals_3, buf0, 256, grid=grid(256), stream=stream0)
        del primals_2
    return (buf0, primals_1, primals_3, primals_4, buf0, )


def benchmark_compiled_module(times=10, repeat=10):
    from torch._dynamo.testing import rand_strided
    from torch._inductor.utils import print_performance
    primals_1 = rand_strided((1, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_2 = rand_strided((1, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_3 = rand_strided((1, ), (1, ), device='cuda:0', dtype=torch.float32)
    primals_4 = rand_strided((4, 4, 4, 4), (64, 16, 4, 1), device='cuda:0', dtype=torch.float32)
    fn = lambda: call([primals_1, primals_2, primals_3, primals_4])
    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 torch.nn as nn


class Normal_Model(nn.Module):
    """
    Example of a module for modeling a probability distribution. This is set up with all pieces
    required for use with the rest of this package. (initial parameters; as well as implimented
    constrain, forward, and log_prob methods)
    """

    def __init__(self, init_mean: 'torch.Tensor'=torch.Tensor([0]),
        init_std: 'torch.Tensor'=torch.Tensor([1])):
        super(Normal_Model, self).__init__()
        self.mean = nn.Parameter(init_mean, requires_grad=True)
        self.std = nn.Parameter(init_std, requires_grad=True)
        self.ln2p = nn.Parameter(torch.log(2 * torch.Tensor([torch.pi])),
            requires_grad=False)

    def constrain(self):
        """
        Method to run on "constrain" step of training. Easiest method for optimization under
        constraint is Projection Optimization by simply clamping parameters to bounds after each
        update. This is certainly not the most efficent way, but it gets the job done.
        """
        eps = 1e-06
        self.std.data = model.std.data.clamp(min=eps)

    def log_prob(self, x):
        """
        Returns the log probability of the items in tensor 'x' according to the probability
        distribution of the module.
        """
        return -torch.log(self.std.unsqueeze(-1)) - self.ln2p / 2 - ((x -
            self.mean.unsqueeze(-1)) / self.std.unsqueeze(-1)).pow(2) / 2

    def forward(self, x):
        """Returns the probability of the items in tensor 'x' according to the probability distribution of the module."""
        return self.log_prob(x).exp()


def get_inputs():
    return [torch.rand([4, 4, 4, 4])]


def get_init_inputs():
    return [[], {}]

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.triton_helpers import math as tl_math
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_poi_fused_div_exp_log_neg_pow_sub_0(in_ptr0, in_ptr1, in_ptr2,
    in_ptr3, out_ptr0, xnumel, XBLOCK: tl.constexpr):
    xnumel = 256
    xoffset = tl.program_id(0) * XBLOCK
    xindex = xoffset + tl.arange(0, XBLOCK)[:]
    xmask = xindex < xnumel
    x0 = xindex
    tmp0 = tl.load(in_ptr0 + 0)
    tmp1 = tl.broadcast_to(tmp0, [XBLOCK])
    tmp4 = tl.load(in_ptr1 + 0)
    tmp5 = tl.broadcast_to(tmp4, [XBLOCK])
    tmp9 = tl.load(in_ptr2 + x0, xmask)
    tmp10 = tl.load(in_ptr3 + 0)
    tmp11 = tl.broadcast_to(tmp10, [XBLOCK])
    tmp2 = tl_math.log(tmp1)
    tmp3 = -tmp2
    tmp6 = 0.5
    tmp7 = tmp5 * tmp6
    tmp8 = tmp3 - tmp7
    tmp12 = tmp9 - tmp11
    tmp13 = tmp12 / tmp1
    tmp14 = tmp13 * tmp13
    tmp15 = tmp14 * tmp6
    tmp16 = tmp8 - tmp15
    tmp17 = tl_math.exp(tmp16)
    tl.store(out_ptr0 + x0, tmp17, xmask)


def call(args):
    primals_1, primals_2, primals_3, primals_4 = args
    args.clear()
    assert_size_stride(primals_1, (1,), (1,))
    assert_size_stride(primals_2, (1,), (1,))
    assert_size_stride(primals_3, (1,), (1,))
    assert_size_stride(primals_4, (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)
        get_raw_stream(0)
        triton_poi_fused_div_exp_log_neg_pow_sub_0[grid(256)](primals_1,
            primals_2, primals_4, primals_3, buf0, 256, XBLOCK=128,
            num_warps=4, num_stages=1)
        del primals_2
    return buf0, primals_1, primals_3, primals_4, buf0


class Normal_ModelNew(nn.Module):
    """
    Example of a module for modeling a probability distribution. This is set up with all pieces
    required for use with the rest of this package. (initial parameters; as well as implimented
    constrain, forward, and log_prob methods)
    """

    def __init__(self, init_mean: 'torch.Tensor'=torch.Tensor([0]),
        init_std: 'torch.Tensor'=torch.Tensor([1])):
        super(Normal_ModelNew, self).__init__()
        self.mean = nn.Parameter(init_mean, requires_grad=True)
        self.std = nn.Parameter(init_std, requires_grad=True)
        self.ln2p = nn.Parameter(torch.log(2 * torch.Tensor([torch.pi])),
            requires_grad=False)

    def constrain(self):
        """
        Method to run on "constrain" step of training. Easiest method for optimization under
        constraint is Projection Optimization by simply clamping parameters to bounds after each
        update. This is certainly not the most efficent way, but it gets the job done.
        """
        eps = 1e-06
        self.std.data = model.std.data.clamp(min=eps)

    def log_prob(self, x):
        """
        Returns the log probability of the items in tensor 'x' according to the probability
        distribution of the module.
        """
        return -torch.log(self.std.unsqueeze(-1)) - self.ln2p / 2 - ((x -
            self.mean.unsqueeze(-1)) / self.std.unsqueeze(-1)).pow(2) / 2

    def forward(self, input_0):
        primals_1 = self.mean
        primals_2 = self.std
        primals_3 = self.ln2p
        primals_4 = input_0
        output = call([primals_1, primals_2, primals_3, primals_4])
        return output[0]
