#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double exp(double);
double pow(double, double);
void gint1_fn_pD(double *a, double a_a, double *p, double *out) {
  double tmp10, tmp2, tmp3, tmp4, v_0, v_1, v_2;
  v_0 = p[0] - a[0];
  v_1 = p[1] - a[1];
  v_2 = p[2] - a[2];
  tmp2 = v_1 * v_1;
  tmp3 = v_0 * v_0;
  tmp4 = v_2 * v_2;
  tmp10 = pow(a_a, 1.75) * exp(-a_a * (tmp2 + tmp3 + tmp4));
  tmp3 = tmp10 * tmp3;
  tmp2 = tmp10 * tmp2;
  out[0] = -0.822961390324745 * tmp2 - 0.822961390324745 * tmp3 +
           1.64592278064949 * tmp10 * tmp4;
  tmp4 = tmp10 * v_2;
  out[1] = 2.85082188141996 * tmp4 * v_0;
  out[2] = 2.85082188141996 * tmp4 * v_1;
  out[3] = 1.42541094070998 * tmp3 - 1.42541094070998 * tmp2;
  out[4] = 2.85082188141996 * tmp10 * v_0 * v_1;
}


x86 assembly (clang, -O0):
<gint1_fn_pD>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x58(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  0xe72(%rip),%xmm1
call   1040 <pow@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x30(%rbp),%xmm1
addsd  -0x38(%rbp),%xmm1
addsd  -0x40(%rbp),%xmm1
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x28(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm1
movsd  0xdf0(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xdc4(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0xdac(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x28(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xd6b(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  0xd50(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x38(%rbp),%xmm0
movsd  0xd38(%rip),%xmm1
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xd14(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  0xcf3(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x20(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gint1_fn_pD>:
push   %rbx
sub    $0x70,%rsp
mov    %rdx,%rbx
movaps %xmm0,%xmm3
movaps %xmm0,0x10(%rsp)
movupd (%rsi),%xmm1
movupd (%rdi),%xmm0
subpd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
movsd  0x10(%rsi),%xmm2
subsd  0x10(%rdi),%xmm2
movapd %xmm2,0x40(%rsp)
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movapd %xmm0,0x60(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
mulsd  %xmm1,%xmm1
movapd %xmm1,0x20(%rsp)
mulsd  %xmm2,%xmm2
movsd  %xmm2,0x8(%rsp)
movsd  0xe7a(%rip),%xmm1
movaps %xmm3,%xmm0
call   1040 <pow@plt>
movapd 0x10(%rsp),%xmm1
xorpd  0xe94(%rip),%xmm1
movsd  %xmm0,0x10(%rsp)
movapd 0x20(%rsp),%xmm0
addsd  0x30(%rsp),%xmm0
addsd  0x8(%rsp),%xmm0
mulsd  %xmm1,%xmm0
call   1030 <exp@plt>
mulsd  0x10(%rsp),%xmm0
movapd 0x20(%rsp),%xmm4
mulsd  %xmm0,%xmm4
movapd 0x30(%rsp),%xmm3
mulsd  %xmm0,%xmm3
movsd  0xe29(%rip),%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0xe19(%rip),%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x8(%rsp),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%rbx)
movapd 0x40(%rsp),%xmm5
mulsd  %xmm0,%xmm5
movsd  0xdfd(%rip),%xmm1
mulsd  %xmm1,%xmm5
unpcklpd %xmm5,%xmm5
movapd 0x50(%rsp),%xmm2
mulpd  %xmm2,%xmm5
movupd %xmm5,0x8(%rbx)
mulsd  0xde6(%rip),%xmm3
mulsd  0xde6(%rip),%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,0x18(%rbx)
mulsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
mulsd  0x60(%rsp),%xmm0
movsd  %xmm0,0x20(%rbx)
add    $0x70,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @gint1_fn_pD(double* %0, double %1, double* %2, double* %3) {
%5 = alloca double*
%6 = alloca double
%7 = alloca double*
%8 = alloca double*
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca double
%13 = alloca double
%14 = alloca double
%15 = alloca double
store double* %0, double** %5
store double %1, double* %6
store double* %2, double** %7
store double* %3, double** %8
%16 = load double*, double** %7
%17 = getelementptr inbounds double, double* %16, i64 0
%18 = load double, double* %17
%19 = load double*, double** %5
%20 = getelementptr inbounds double, double* %19, i64 0
%21 = load double, double* %20
%22 = fsub double %18, %21
store double %22, double* %13
%23 = load double*, double** %7
%24 = getelementptr inbounds double, double* %23, i64 1
%25 = load double, double* %24
%26 = load double*, double** %5
%27 = getelementptr inbounds double, double* %26, i64 1
%28 = load double, double* %27
%29 = fsub double %25, %28
store double %29, double* %14
%30 = load double*, double** %7
%31 = getelementptr inbounds double, double* %30, i64 2
%32 = load double, double* %31
%33 = load double*, double** %5
%34 = getelementptr inbounds double, double* %33, i64 2
%35 = load double, double* %34
%36 = fsub double %32, %35
store double %36, double* %15
%37 = load double, double* %14
%38 = load double, double* %14
%39 = fmul double %37, %38
store double %39, double* %10
%40 = load double, double* %13
%41 = load double, double* %13
%42 = fmul double %40, %41
store double %42, double* %11
%43 = load double, double* %15
%44 = load double, double* %15
%45 = fmul double %43, %44
store double %45, double* %12
%46 = load double, double* %6
%47 = call double @pow(double %46, double 1.750000e+00)
%48 = load double, double* %6
%49 = fneg double %48
%50 = load double, double* %10
%51 = load double, double* %11
%52 = fadd double %50, %51
%53 = load double, double* %12
%54 = fadd double %52, %53
%55 = fmul double %49, %54
%56 = call double @exp(double %55)
%57 = fmul double %47, %56
store double %57, double* %9
%58 = load double, double* %9
%59 = load double, double* %11
%60 = fmul double %58, %59
store double %60, double* %11
%61 = load double, double* %9
%62 = load double, double* %10
%63 = fmul double %61, %62
store double %63, double* %10
%64 = load double, double* %10
%65 = load double, double* %11
%66 = fmul double 0x3FEA55B3202A1856, %65
%67 = fneg double %66
%68 = call double @llvm.fmuladd.f64(double 0xBFEA55B3202A1856, double %64, double %67)
%69 = load double, double* %9
%70 = fmul double 0x3FFA55B3202A1856, %69
%71 = load double, double* %12
%72 = call double @llvm.fmuladd.f64(double %70, double %71, double %68)
%73 = load double*, double** %8
%74 = getelementptr inbounds double, double* %73, i64 0
store double %72, double* %74
%75 = load double, double* %9
%76 = load double, double* %15
%77 = fmul double %75, %76
store double %77, double* %12
%78 = load double, double* %12
%79 = fmul double 0x4006CE7BB3DB5BFE, %78
%80 = load double, double* %13
%81 = fmul double %79, %80
%82 = load double*, double** %8
%83 = getelementptr inbounds double, double* %82, i64 1
store double %81, double* %83
%84 = load double, double* %12
%85 = fmul double 0x4006CE7BB3DB5BFE, %84
%86 = load double, double* %14
%87 = fmul double %85, %86
%88 = load double*, double** %8
%89 = getelementptr inbounds double, double* %88, i64 2
store double %87, double* %89
%90 = load double, double* %11
%91 = load double, double* %10
%92 = fmul double 0x3FF6CE7BB3DB5BFE, %91
%93 = fneg double %92
%94 = call double @llvm.fmuladd.f64(double 0x3FF6CE7BB3DB5BFE, double %90, double %93)
%95 = load double*, double** %8
%96 = getelementptr inbounds double, double* %95, i64 3
store double %94, double* %96
%97 = load double, double* %9
%98 = fmul double 0x4006CE7BB3DB5BFE, %97
%99 = load double, double* %13
%100 = fmul double %98, %99
%101 = load double, double* %14
%102 = fmul double %100, %101
%103 = load double*, double** %8
%104 = getelementptr inbounds double, double* %103, i64 4
store double %102, double* %104
ret void
}

LLVM IR (-O2):
define void @gint1_fn_pD(double* nocapture %0, double %1, double* nocapture %2, double* nocapture writeonly %3) {
%5 = bitcast double* %2 to <2 x double>*
%6 = load <2 x double>, <2 x double>* %5
%7 = bitcast double* %0 to <2 x double>*
%8 = load <2 x double>, <2 x double>* %7
%9 = fsub <2 x double> %6, %8
%10 = getelementptr inbounds double, double* %2, i64 2
%11 = load double, double* %10
%12 = getelementptr inbounds double, double* %0, i64 2
%13 = load double, double* %12
%14 = fsub double %11, %13
%15 = extractelement <2 x double> %9, i64 1
%16 = fmul double %15, %15
%17 = extractelement <2 x double> %9, i64 0
%18 = fmul <2 x double> %9, %9
%19 = extractelement <2 x double> %18, i64 0
%20 = fmul double %14, %14
%21 = tail call double @pow(double %1, double 1.750000e+00)
%22 = fneg double %1
%23 = fadd double %19, %16
%24 = fadd double %23, %20
%25 = fmul double %24, %22
%26 = tail call double @exp(double %25)
%27 = fmul double %21, %26
%28 = fmul double %19, %27
%29 = fmul double %16, %27
%30 = fmul double %28, 0xBFEA55B3202A1856
%31 = tail call double @llvm.fmuladd.f64(double %29, double 0xBFEA55B3202A1856, double %30)
%32 = fmul double %27, 0x3FFA55B3202A1856
%33 = tail call double @llvm.fmuladd.f64(double %32, double %20, double %31)
store double %33, double* %3
%34 = fmul double %14, %27
%35 = fmul double %34, 0x4006CE7BB3DB5BFE
%36 = getelementptr inbounds double, double* %3, i64 1
%37 = insertelement <2 x double> poison, double %35, i64 0
%38 = shufflevector <2 x double> %37, <2 x double> poison, <2 x i32> zeroinitializer
%39 = fmul <2 x double> %9, %38
%40 = bitcast double* %36 to <2 x double>*
store <2 x double> %39, <2 x double>* %40
%41 = fmul double %29, 0xBFF6CE7BB3DB5BFE
%42 = tail call double @llvm.fmuladd.f64(double %28, double 0x3FF6CE7BB3DB5BFE, double %41)
%43 = getelementptr inbounds double, double* %3, i64 3
store double %42, double* %43
%44 = fmul double %27, 0x4006CE7BB3DB5BFE
%45 = fmul double %17, %44
%46 = fmul double %15, %45
%47 = getelementptr inbounds double, double* %3, i64 4
store double %46, double* %47
ret void
}