#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 gaux(double, int);
double pow(double, double);
void gint2_nai_SP_P(double *a, double a_a, double *b, double b_a, double *c,
                    double *out) {
  double ab_a, d_0, d_1, d_2, p_0, p_1, p_2, tmp1, tmp6, tmp7, tmp8, tmp9, u_0,
      u_1, u_2, usq, v_0, v_1, v_2;
  ab_a = a_a + b_a;
  p_0 = (a[0] * a_a + b[0] * b_a) / ab_a;
  p_1 = (a[1] * a_a + b[1] * b_a) / ab_a;
  p_2 = (a[2] * a_a + b[2] * b_a) / ab_a;
  d_0 = a[0] - b[0];
  d_1 = a[1] - b[1];
  d_2 = a[2] - b[2];
  u_0 = p_0 - c[0];
  u_1 = p_1 - c[1];
  u_2 = p_2 - c[2];
  usq = ab_a * (u_0 * u_0 + u_1 * u_1 + u_2 * u_2);
  v_0 = p_0 - a[0];
  v_1 = p_1 - a[1];
  v_2 = p_2 - a[2];
  p_0 = p_0 - b[0];
  p_1 = p_1 - b[1];
  p_2 = p_2 - b[2];
  d_0 = exp(-a_a * b_a * (d_0 * d_0 + d_1 * d_1 + d_2 * d_2) / ab_a) / ab_a;
  d_1 = 6.28318530717959 * d_0 * gaux(usq, 0);
  d_2 = 6.28318530717959 * d_0 * gaux(usq, 1);
  tmp9 = d_2 * u_0;
  tmp1 = pow(b_a, 1.25);
  tmp6 = tmp1 * pow(a_a, 0.75);
  out[0] = 1.01589817494786 * tmp6 * (-tmp9 + d_1 * p_0);
  tmp8 = d_2 * u_1;
  out[1] = 1.01589817494786 * tmp6 * (-tmp8 + d_1 * p_1);
  tmp7 = d_2 * u_2;
  out[2] = 1.01589817494786 * tmp6 * (-tmp7 + d_1 * p_2);
  tmp9 = -tmp9 + d_1 * v_0;
  tmp6 = 6.28318530717959 * d_0 * gaux(usq, 2);
  usq = d_2 * v_0 - tmp6 * u_0;
  v_0 = (0.5 * d_1 - 0.5 * d_2) / ab_a;
  ab_a = tmp1 * pow(a_a, 1.25);
  out[3] = 2.03179634989571 * ab_a * (v_0 + p_0 * tmp9 - u_0 * usq);
  out[4] = 2.03179634989571 * ab_a * (p_1 * tmp9 - u_1 * usq);
  out[5] = 2.03179634989571 * ab_a * (p_2 * tmp9 - u_2 * usq);
  d_0 = -tmp8 + d_1 * v_1;
  tmp9 = d_2 * v_1 - tmp6 * u_1;
  out[6] = 2.03179634989571 * ab_a * (d_0 * p_0 - tmp9 * u_0);
  out[7] = 2.03179634989571 * ab_a * (v_0 + d_0 * p_1 - tmp9 * u_1);
  out[8] = 2.03179634989571 * ab_a * (d_0 * p_2 - tmp9 * u_2);
  tmp1 = -tmp7 + d_1 * v_2;
  tmp6 = d_2 * v_2 - tmp6 * u_2;
  out[9] = 2.03179634989571 * ab_a * (p_0 * tmp1 - tmp6 * u_0);
  out[10] = 2.03179634989571 * ab_a * (p_1 * tmp1 - tmp6 * u_1);
  out[11] = 2.03179634989571 * ab_a * (v_0 + p_2 * tmp1 - tmp6 * u_2);
}


x86 assembly (clang, -O0):
<gint2_nai_SP_P>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
movsd  -0x10(%rbp),%xmm0
addsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x10(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  -0x10(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x10(%rbp),%xmm2
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  -0x20(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm3
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x10(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x20(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm3
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
call   1040 <exp@plt>
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xc6f(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
xor    %edi,%edi
call   1030 <gaux@plt>
movaps %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xc37(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    $0x1,%edi
call   1030 <gaux@plt>
movaps %xmm0,%xmm1
movsd  -0xe8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  0xbd2(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0xbce(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xe0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0xba5(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x48(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xb46(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x48(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x50(%rbp),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  0xae9(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
movsd  -0x48(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xa5d(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    $0x2,%edi
call   1030 <gaux@plt>
movaps %xmm0,%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  0x9d4(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0x9b0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x10(%rbp),%xmm0
movsd  0x979(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  0x950(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  0x8ea(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
movsd  -0xa0(%rbp),%xmm2
ff
mulsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  0x894(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm3
ff
movsd  -0xa8(%rbp),%xmm2
ff
mulsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x28(%rax)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x7c4(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm3
movsd  -0x90(%rbp),%xmm2
ff
mulsd  -0x98(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x30(%rax)
movsd  0x771(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x38(%rax)
movsd  0x70e(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
movsd  -0x90(%rbp),%xmm2
ff
mulsd  -0xa8(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x40(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  -0x48(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x647(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
mulsd  -0x98(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x48(%rax)
movsd  0x5f7(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm3
movsd  -0x78(%rbp),%xmm2
mulsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x50(%rax)
movsd  0x5a7(%rip),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x78(%rbp),%xmm1
movsd  -0xa8(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,0x58(%rax)
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gint2_nai_SP_P>:
push   %rbx
sub    $0x110,%rsp
mov    %rcx,%rbx
movapd %xmm1,%xmm3
movapd %xmm0,%xmm1
addsd  %xmm3,%xmm1
movapd %xmm1,%xmm10
movupd (%rdi),%xmm1
movupd (%rsi),%xmm8
movapd %xmm3,%xmm2
movapd %xmm3,%xmm7
unpcklpd %xmm3,%xmm2
mulpd  %xmm8,%xmm2
movapd %xmm0,%xmm3
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm3
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm10,%xmm2
unpcklpd %xmm10,%xmm2
divpd  %xmm2,%xmm3
movapd %xmm3,%xmm6
movsd  0x10(%rdi),%xmm3
movsd  0x10(%rsi),%xmm2
movapd %xmm2,%xmm4
mulsd  %xmm7,%xmm4
movapd %xmm7,%xmm12
movapd %xmm7,0x30(%rsp)
movapd %xmm3,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm5,%xmm11
movapd %xmm5,0xb0(%rsp)
addsd  %xmm4,%xmm0
divsd  %xmm10,%xmm0
movapd %xmm0,%xmm9
movupd (%rdx),%xmm4
movapd %xmm6,%xmm7
subpd  %xmm4,%xmm7
movapd %xmm7,0x70(%rsp)
subsd  0x10(%rdx),%xmm0
movapd %xmm0,0xd0(%rsp)
movapd %xmm7,%xmm4
unpckhpd %xmm7,%xmm4
movapd %xmm4,0xf0(%rsp)
mulsd  %xmm4,%xmm4
movapd %xmm7,%xmm5
mulsd  %xmm7,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm0,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm0,%xmm5
movapd %xmm6,%xmm0
subpd  %xmm1,%xmm0
movapd %xmm0,%xmm4
movapd %xmm0,0x40(%rsp)
subpd  %xmm8,%xmm1
subpd  %xmm8,%xmm6
movapd %xmm6,0x60(%rsp)
movapd %xmm9,%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x88(%rsp)
movapd %xmm3,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm10,0xa0(%rsp)
mulsd  %xmm10,%xmm5
movapd %xmm5,(%rsp)
subsd  %xmm2,%xmm9
movapd %xmm9,0xc0(%rsp)
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm2
unpckhpd %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm11,%xmm1
xorpd  0xd5e(%rip),%xmm1
mulsd  %xmm12,%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm4,%xmm1
unpckhpd %xmm4,%xmm1
movapd %xmm1,0x100(%rsp)
divsd  %xmm10,%xmm0
call   1040 <exp@plt>
divsd  0xa0(%rsp),%xmm0
mulsd  0xd39(%rip),%xmm0
movapd %xmm0,0x50(%rsp)
movaps (%rsp),%xmm0
xor    %edi,%edi
call   1030 <gaux@plt>
movaps %xmm0,0x10(%rsp)
movapd (%rsp),%xmm0
mov    $0x1,%edi
call   1030 <gaux@plt>
movapd 0x50(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
unpcklpd 0x10(%rsp),%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0xcfa(%rip),%xmm1
movaps 0x30(%rsp),%xmm0
call   1050 <pow@plt>
movsd  %xmm0,0x28(%rsp)
movsd  0xcea(%rip),%xmm1
movapd 0xb0(%rsp),%xmm0
call   1050 <pow@plt>
mulsd  0x28(%rsp),%xmm0
mulsd  0xcd6(%rip),%xmm0
movdqa 0x10(%rsp),%xmm2
movdqa %xmm2,%xmm1
pxor   0xc9c(%rip),%xmm1
pshufd $0x44,%xmm1,%xmm4
movdqa %xmm1,%xmm5
mulpd  0x70(%rsp),%xmm4
movapd %xmm4,0x30(%rsp)
punpckhqdq %xmm2,%xmm2
movdqa %xmm2,%xmm1
movdqa %xmm2,0x90(%rsp)
mulpd  0x60(%rsp),%xmm1
addpd  %xmm4,%xmm1
mulsd  0xd0(%rsp),%xmm5
movapd %xmm5,0xe0(%rsp)
mulsd  0xc0(%rsp),%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm0,%xmm2
unpcklpd %xmm0,%xmm0
mulpd  %xmm1,%xmm0
movupd %xmm0,(%rbx)
movsd  %xmm2,0x10(%rbx)
movapd (%rsp),%xmm0
mov    $0x2,%edi
call   1030 <gaux@plt>
movapd 0x50(%rsp),%xmm1
xorpd  0xc1b(%rip),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
movapd 0x70(%rsp),%xmm0
mulsd  %xmm1,%xmm0
movapd 0x40(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
unpcklpd 0x30(%rsp),%xmm0
movapd 0x10(%rsp),%xmm2
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movapd %xmm1,0x40(%rsp)
movsd  0xc0b(%rip),%xmm0
mulsd  %xmm2,%xmm0
movsd  0xc07(%rip),%xmm1
mulsd  0x90(%rsp),%xmm1
addsd  %xmm0,%xmm1
divsd  0xa0(%rsp),%xmm1
movsd  %xmm1,(%rsp)
movapd 0xb0(%rsp),%xmm0
movsd  0xbbb(%rip),%xmm1
call   1050 <pow@plt>
mulsd  0x28(%rsp),%xmm0
movapd 0x40(%rsp),%xmm4
movapd %xmm4,%xmm2
unpckhpd %xmm4,%xmm2
movapd 0x60(%rsp),%xmm5
mulsd  %xmm5,%xmm2
movsd  (%rsp),%xmm8
addsd  %xmm8,%xmm2
movapd 0xf0(%rsp),%xmm12
movapd %xmm12,%xmm1
movapd 0xb5d(%rip),%xmm13
xorpd  %xmm13,%xmm1
mulsd  %xmm4,%xmm1
unpcklpd %xmm1,%xmm2
movapd 0x70(%rsp),%xmm9
movapd %xmm9,%xmm1
xorpd  %xmm13,%xmm1
shufpd $0x2,%xmm5,%xmm1
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movapd 0x90(%rsp),%xmm15
movapd %xmm15,%xmm11
movsd  0x88(%rsp),%xmm5
mulsd  %xmm5,%xmm15
addsd  0xe0(%rsp),%xmm15
movapd 0x100(%rsp),%xmm2
mulsd  %xmm2,%xmm11
movapd 0x10(%rsp),%xmm4
mulsd  %xmm4,%xmm2
mulsd  %xmm5,%xmm4
movapd 0x50(%rsp),%xmm5
mulsd  %xmm5,%xmm12
movapd 0xd0(%rsp),%xmm7
mulsd  %xmm7,%xmm5
addsd  %xmm5,%xmm4
movapd %xmm9,%xmm3
movapd 0xc0(%rsp),%xmm10
shufpd $0x1,%xmm10,%xmm3
movapd %xmm10,%xmm14
mulsd  %xmm15,%xmm10
addsd  %xmm8,%xmm10
movapd %xmm4,%xmm5
mulsd  %xmm7,%xmm4
subsd  %xmm4,%xmm10
mulsd  0xada(%rip),%xmm0
mulsd  %xmm0,%xmm10
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm1
movupd %xmm1,0x18(%rbx)
movapd 0x30(%rsp),%xmm1
unpckhpd %xmm1,%xmm1
addsd  %xmm1,%xmm11
addsd  %xmm12,%xmm2
movapd %xmm7,%xmm1
unpcklpd %xmm2,%xmm1
xorpd  %xmm1,%xmm13
movapd 0x40(%rsp),%xmm4
movapd %xmm4,%xmm6
unpcklpd %xmm9,%xmm6
mulpd  %xmm1,%xmm6
unpcklpd %xmm11,%xmm14
movapd 0x60(%rsp),%xmm2
movapd %xmm4,%xmm1
shufpd $0x1,%xmm2,%xmm1
mulpd  %xmm14,%xmm1
subpd  %xmm6,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x28(%rbx)
movapd %xmm2,%xmm1
unpckhpd %xmm2,%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm8,%xmm1
movapd %xmm13,%xmm6
pshufd $0xee,%xmm13,%xmm4
mulsd  %xmm7,%xmm4
unpcklpd %xmm4,%xmm1
shufpd $0x1,%xmm11,%xmm6
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm3
movupd %xmm3,0x38(%rbx)
unpcklpd %xmm5,%xmm5
mulpd  %xmm9,%xmm5
movapd %xmm15,%xmm1
unpcklpd %xmm15,%xmm1
mulpd  %xmm2,%xmm1
subpd  %xmm5,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x48(%rbx)
movsd  %xmm10,0x58(%rbx)
add    $0x110,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @gint2_nai_SP_P(double* %0, double %1, double* %2, double %3, double* %4, double* %5) {
%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
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca double
%31 = alloca double
store double* %0, double** %7
store double %1, double* %8
store double* %2, double** %9
store double %3, double* %10
store double* %4, double** %11
store double* %5, double** %12
%32 = load double, double* %8
%33 = load double, double* %10
%34 = fadd double %32, %33
store double %34, double* %13
%35 = load double*, double** %7
%36 = getelementptr inbounds double, double* %35, i64 0
%37 = load double, double* %36
%38 = load double, double* %8
%39 = load double*, double** %9
%40 = getelementptr inbounds double, double* %39, i64 0
%41 = load double, double* %40
%42 = load double, double* %10
%43 = fmul double %41, %42
%44 = call double @llvm.fmuladd.f64(double %37, double %38, double %43)
%45 = load double, double* %13
%46 = fdiv double %44, %45
store double %46, double* %17
%47 = load double*, double** %7
%48 = getelementptr inbounds double, double* %47, i64 1
%49 = load double, double* %48
%50 = load double, double* %8
%51 = load double*, double** %9
%52 = getelementptr inbounds double, double* %51, i64 1
%53 = load double, double* %52
%54 = load double, double* %10
%55 = fmul double %53, %54
%56 = call double @llvm.fmuladd.f64(double %49, double %50, double %55)
%57 = load double, double* %13
%58 = fdiv double %56, %57
store double %58, double* %18
%59 = load double*, double** %7
%60 = getelementptr inbounds double, double* %59, i64 2
%61 = load double, double* %60
%62 = load double, double* %8
%63 = load double*, double** %9
%64 = getelementptr inbounds double, double* %63, i64 2
%65 = load double, double* %64
%66 = load double, double* %10
%67 = fmul double %65, %66
%68 = call double @llvm.fmuladd.f64(double %61, double %62, double %67)
%69 = load double, double* %13
%70 = fdiv double %68, %69
store double %70, double* %19
%71 = load double*, double** %7
%72 = getelementptr inbounds double, double* %71, i64 0
%73 = load double, double* %72
%74 = load double*, double** %9
%75 = getelementptr inbounds double, double* %74, i64 0
%76 = load double, double* %75
%77 = fsub double %73, %76
store double %77, double* %14
%78 = load double*, double** %7
%79 = getelementptr inbounds double, double* %78, i64 1
%80 = load double, double* %79
%81 = load double*, double** %9
%82 = getelementptr inbounds double, double* %81, i64 1
%83 = load double, double* %82
%84 = fsub double %80, %83
store double %84, double* %15
%85 = load double*, double** %7
%86 = getelementptr inbounds double, double* %85, i64 2
%87 = load double, double* %86
%88 = load double*, double** %9
%89 = getelementptr inbounds double, double* %88, i64 2
%90 = load double, double* %89
%91 = fsub double %87, %90
store double %91, double* %16
%92 = load double, double* %17
%93 = load double*, double** %11
%94 = getelementptr inbounds double, double* %93, i64 0
%95 = load double, double* %94
%96 = fsub double %92, %95
store double %96, double* %25
%97 = load double, double* %18
%98 = load double*, double** %11
%99 = getelementptr inbounds double, double* %98, i64 1
%100 = load double, double* %99
%101 = fsub double %97, %100
store double %101, double* %26
%102 = load double, double* %19
%103 = load double*, double** %11
%104 = getelementptr inbounds double, double* %103, i64 2
%105 = load double, double* %104
%106 = fsub double %102, %105
store double %106, double* %27
%107 = load double, double* %13
%108 = load double, double* %25
%109 = load double, double* %25
%110 = load double, double* %26
%111 = load double, double* %26
%112 = fmul double %110, %111
%113 = call double @llvm.fmuladd.f64(double %108, double %109, double %112)
%114 = load double, double* %27
%115 = load double, double* %27
%116 = call double @llvm.fmuladd.f64(double %114, double %115, double %113)
%117 = fmul double %107, %116
store double %117, double* %28
%118 = load double, double* %17
%119 = load double*, double** %7
%120 = getelementptr inbounds double, double* %119, i64 0
%121 = load double, double* %120
%122 = fsub double %118, %121
store double %122, double* %29
%123 = load double, double* %18
%124 = load double*, double** %7
%125 = getelementptr inbounds double, double* %124, i64 1
%126 = load double, double* %125
%127 = fsub double %123, %126
store double %127, double* %30
%128 = load double, double* %19
%129 = load double*, double** %7
%130 = getelementptr inbounds double, double* %129, i64 2
%131 = load double, double* %130
%132 = fsub double %128, %131
store double %132, double* %31
%133 = load double, double* %17
%134 = load double*, double** %9
%135 = getelementptr inbounds double, double* %134, i64 0
%136 = load double, double* %135
%137 = fsub double %133, %136
store double %137, double* %17
%138 = load double, double* %18
%139 = load double*, double** %9
%140 = getelementptr inbounds double, double* %139, i64 1
%141 = load double, double* %140
%142 = fsub double %138, %141
store double %142, double* %18
%143 = load double, double* %19
%144 = load double*, double** %9
%145 = getelementptr inbounds double, double* %144, i64 2
%146 = load double, double* %145
%147 = fsub double %143, %146
store double %147, double* %19
%148 = load double, double* %8
%149 = fneg double %148
%150 = load double, double* %10
%151 = fmul double %149, %150
%152 = load double, double* %14
%153 = load double, double* %14
%154 = load double, double* %15
%155 = load double, double* %15
%156 = fmul double %154, %155
%157 = call double @llvm.fmuladd.f64(double %152, double %153, double %156)
%158 = load double, double* %16
%159 = load double, double* %16
%160 = call double @llvm.fmuladd.f64(double %158, double %159, double %157)
%161 = fmul double %151, %160
%162 = load double, double* %13
%163 = fdiv double %161, %162
%164 = call double @exp(double %163)
%165 = load double, double* %13
%166 = fdiv double %164, %165
store double %166, double* %14
%167 = load double, double* %14
%168 = fmul double 0x401921FB54442D1C, %167
%169 = load double, double* %28
%170 = call double @gaux(double %169, i32 0)
%171 = fmul double %168, %170
store double %171, double* %15
%172 = load double, double* %14
%173 = fmul double 0x401921FB54442D1C, %172
%174 = load double, double* %28
%175 = call double @gaux(double %174, i32 1)
%176 = fmul double %173, %175
store double %176, double* %16
%177 = load double, double* %16
%178 = load double, double* %25
%179 = fmul double %177, %178
store double %179, double* %24
%180 = load double, double* %10
%181 = call double @pow(double %180, double 1.250000e+00)
store double %181, double* %20
%182 = load double, double* %20
%183 = load double, double* %8
%184 = call double @pow(double %183, double 7.500000e-01)
%185 = fmul double %182, %184
store double %185, double* %21
%186 = load double, double* %21
%187 = fmul double 0x3FF0411E71D7796D, %186
%188 = load double, double* %24
%189 = fneg double %188
%190 = load double, double* %15
%191 = load double, double* %17
%192 = call double @llvm.fmuladd.f64(double %190, double %191, double %189)
%193 = fmul double %187, %192
%194 = load double*, double** %12
%195 = getelementptr inbounds double, double* %194, i64 0
store double %193, double* %195
%196 = load double, double* %16
%197 = load double, double* %26
%198 = fmul double %196, %197
store double %198, double* %23
%199 = load double, double* %21
%200 = fmul double 0x3FF0411E71D7796D, %199
%201 = load double, double* %23
%202 = fneg double %201
%203 = load double, double* %15
%204 = load double, double* %18
%205 = call double @llvm.fmuladd.f64(double %203, double %204, double %202)
%206 = fmul double %200, %205
%207 = load double*, double** %12
%208 = getelementptr inbounds double, double* %207, i64 1
store double %206, double* %208
%209 = load double, double* %16
%210 = load double, double* %27
%211 = fmul double %209, %210
store double %211, double* %22
%212 = load double, double* %21
%213 = fmul double 0x3FF0411E71D7796D, %212
%214 = load double, double* %22
%215 = fneg double %214
%216 = load double, double* %15
%217 = load double, double* %19
%218 = call double @llvm.fmuladd.f64(double %216, double %217, double %215)
%219 = fmul double %213, %218
%220 = load double*, double** %12
%221 = getelementptr inbounds double, double* %220, i64 2
store double %219, double* %221
%222 = load double, double* %24
%223 = fneg double %222
%224 = load double, double* %15
%225 = load double, double* %29
%226 = call double @llvm.fmuladd.f64(double %224, double %225, double %223)
store double %226, double* %24
%227 = load double, double* %14
%228 = fmul double 0x401921FB54442D1C, %227
%229 = load double, double* %28
%230 = call double @gaux(double %229, i32 2)
%231 = fmul double %228, %230
store double %231, double* %21
%232 = load double, double* %16
%233 = load double, double* %29
%234 = load double, double* %21
%235 = load double, double* %25
%236 = fmul double %234, %235
%237 = fneg double %236
%238 = call double @llvm.fmuladd.f64(double %232, double %233, double %237)
store double %238, double* %28
%239 = load double, double* %15
%240 = load double, double* %16
%241 = fmul double 5.000000e-01, %240
%242 = fneg double %241
%243 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %239, double %242)
%244 = load double, double* %13
%245 = fdiv double %243, %244
store double %245, double* %29
%246 = load double, double* %20
%247 = load double, double* %8
%248 = call double @pow(double %247, double 1.250000e+00)
%249 = fmul double %246, %248
store double %249, double* %13
%250 = load double, double* %13
%251 = fmul double 0x4000411E71D77957, %250
%252 = load double, double* %29
%253 = load double, double* %17
%254 = load double, double* %24
%255 = call double @llvm.fmuladd.f64(double %253, double %254, double %252)
%256 = load double, double* %25
%257 = load double, double* %28
%258 = fneg double %256
%259 = call double @llvm.fmuladd.f64(double %258, double %257, double %255)
%260 = fmul double %251, %259
%261 = load double*, double** %12
%262 = getelementptr inbounds double, double* %261, i64 3
store double %260, double* %262
%263 = load double, double* %13
%264 = fmul double 0x4000411E71D77957, %263
%265 = load double, double* %18
%266 = load double, double* %24
%267 = load double, double* %26
%268 = load double, double* %28
%269 = fmul double %267, %268
%270 = fneg double %269
%271 = call double @llvm.fmuladd.f64(double %265, double %266, double %270)
%272 = fmul double %264, %271
%273 = load double*, double** %12
%274 = getelementptr inbounds double, double* %273, i64 4
store double %272, double* %274
%275 = load double, double* %13
%276 = fmul double 0x4000411E71D77957, %275
%277 = load double, double* %19
%278 = load double, double* %24
%279 = load double, double* %27
%280 = load double, double* %28
%281 = fmul double %279, %280
%282 = fneg double %281
%283 = call double @llvm.fmuladd.f64(double %277, double %278, double %282)
%284 = fmul double %276, %283
%285 = load double*, double** %12
%286 = getelementptr inbounds double, double* %285, i64 5
store double %284, double* %286
%287 = load double, double* %23
%288 = fneg double %287
%289 = load double, double* %15
%290 = load double, double* %30
%291 = call double @llvm.fmuladd.f64(double %289, double %290, double %288)
store double %291, double* %14
%292 = load double, double* %16
%293 = load double, double* %30
%294 = load double, double* %21
%295 = load double, double* %26
%296 = fmul double %294, %295
%297 = fneg double %296
%298 = call double @llvm.fmuladd.f64(double %292, double %293, double %297)
store double %298, double* %24
%299 = load double, double* %13
%300 = fmul double 0x4000411E71D77957, %299
%301 = load double, double* %14
%302 = load double, double* %17
%303 = load double, double* %24
%304 = load double, double* %25
%305 = fmul double %303, %304
%306 = fneg double %305
%307 = call double @llvm.fmuladd.f64(double %301, double %302, double %306)
%308 = fmul double %300, %307
%309 = load double*, double** %12
%310 = getelementptr inbounds double, double* %309, i64 6
store double %308, double* %310
%311 = load double, double* %13
%312 = fmul double 0x4000411E71D77957, %311
%313 = load double, double* %29
%314 = load double, double* %14
%315 = load double, double* %18
%316 = call double @llvm.fmuladd.f64(double %314, double %315, double %313)
%317 = load double, double* %24
%318 = load double, double* %26
%319 = fneg double %317
%320 = call double @llvm.fmuladd.f64(double %319, double %318, double %316)
%321 = fmul double %312, %320
%322 = load double*, double** %12
%323 = getelementptr inbounds double, double* %322, i64 7
store double %321, double* %323
%324 = load double, double* %13
%325 = fmul double 0x4000411E71D77957, %324
%326 = load double, double* %14
%327 = load double, double* %19
%328 = load double, double* %24
%329 = load double, double* %27
%330 = fmul double %328, %329
%331 = fneg double %330
%332 = call double @llvm.fmuladd.f64(double %326, double %327, double %331)
%333 = fmul double %325, %332
%334 = load double*, double** %12
%335 = getelementptr inbounds double, double* %334, i64 8
store double %333, double* %335
%336 = load double, double* %22
%337 = fneg double %336
%338 = load double, double* %15
%339 = load double, double* %31
%340 = call double @llvm.fmuladd.f64(double %338, double %339, double %337)
store double %340, double* %20
%341 = load double, double* %16
%342 = load double, double* %31
%343 = load double, double* %21
%344 = load double, double* %27
%345 = fmul double %343, %344
%346 = fneg double %345
%347 = call double @llvm.fmuladd.f64(double %341, double %342, double %346)
store double %347, double* %21
%348 = load double, double* %13
%349 = fmul double 0x4000411E71D77957, %348
%350 = load double, double* %17
%351 = load double, double* %20
%352 = load double, double* %21
%353 = load double, double* %25
%354 = fmul double %352, %353
%355 = fneg double %354
%356 = call double @llvm.fmuladd.f64(double %350, double %351, double %355)
%357 = fmul double %349, %356
%358 = load double*, double** %12
%359 = getelementptr inbounds double, double* %358, i64 9
store double %357, double* %359
%360 = load double, double* %13
%361 = fmul double 0x4000411E71D77957, %360
%362 = load double, double* %18
%363 = load double, double* %20
%364 = load double, double* %21
%365 = load double, double* %26
%366 = fmul double %364, %365
%367 = fneg double %366
%368 = call double @llvm.fmuladd.f64(double %362, double %363, double %367)
%369 = fmul double %361, %368
%370 = load double*, double** %12
%371 = getelementptr inbounds double, double* %370, i64 10
store double %369, double* %371
%372 = load double, double* %13
%373 = fmul double 0x4000411E71D77957, %372
%374 = load double, double* %29
%375 = load double, double* %19
%376 = load double, double* %20
%377 = call double @llvm.fmuladd.f64(double %375, double %376, double %374)
%378 = load double, double* %21
%379 = load double, double* %27
%380 = fneg double %378
%381 = call double @llvm.fmuladd.f64(double %380, double %379, double %377)
%382 = fmul double %373, %381
%383 = load double*, double** %12
%384 = getelementptr inbounds double, double* %383, i64 11
store double %382, double* %384
ret void
}

LLVM IR (-O2):
define void @gint2_nai_SP_P(double* nocapture %0, double %1, double* nocapture %2, double %3, double* nocapture %4, double* nocapture writeonly %5) {
%7 = fadd double %1, %3
%8 = bitcast double* %0 to <2 x double>*
%9 = load <2 x double>, <2 x double>* %8
%10 = bitcast double* %2 to <2 x double>*
%11 = load <2 x double>, <2 x double>* %10
%12 = insertelement <2 x double> poison, double %3, i64 0
%13 = shufflevector <2 x double> %12, <2 x double> poison, <2 x i32> zeroinitializer
%14 = fmul <2 x double> %11, %13
%15 = insertelement <2 x double> poison, double %1, i64 0
%16 = shufflevector <2 x double> %15, <2 x double> poison, <2 x i32> zeroinitializer
%17 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %9, <2 x double> %16, <2 x double> %14)
%18 = insertelement <2 x double> poison, double %7, i64 0
%19 = shufflevector <2 x double> %18, <2 x double> poison, <2 x i32> zeroinitializer
%20 = fdiv <2 x double> %17, %19
%21 = getelementptr inbounds double, double* %0, i64 2
%22 = load double, double* %21
%23 = getelementptr inbounds double, double* %2, i64 2
%24 = load double, double* %23
%25 = fmul double %24, %3
%26 = tail call double @llvm.fmuladd.f64(double %22, double %1, double %25)
%27 = fdiv double %26, %7
%28 = fsub <2 x double> %9, %11
%29 = extractelement <2 x double> %28, i64 0
%30 = fsub <2 x double> %9, %11
%31 = fsub double %22, %24
%32 = bitcast double* %4 to <2 x double>*
%33 = load <2 x double>, <2 x double>* %32
%34 = fsub <2 x double> %20, %33
%35 = getelementptr inbounds double, double* %4, i64 2
%36 = load double, double* %35
%37 = fsub double %27, %36
%38 = extractelement <2 x double> %34, i64 1
%39 = fmul double %38, %38
%40 = extractelement <2 x double> %34, i64 0
%41 = tail call double @llvm.fmuladd.f64(double %40, double %40, double %39)
%42 = tail call double @llvm.fmuladd.f64(double %37, double %37, double %41)
%43 = fmul double %7, %42
%44 = fsub <2 x double> %20, %9
%45 = fsub <2 x double> %20, %9
%46 = extractelement <2 x double> %45, i64 1
%47 = fsub double %27, %22
%48 = fsub <2 x double> %20, %11
%49 = fsub double %27, %24
%50 = fneg double %1
%51 = fmul double %50, %3
%52 = fmul <2 x double> %30, %30
%53 = extractelement <2 x double> %52, i64 1
%54 = tail call double @llvm.fmuladd.f64(double %29, double %29, double %53)
%55 = tail call double @llvm.fmuladd.f64(double %31, double %31, double %54)
%56 = fmul double %51, %55
%57 = fdiv double %56, %7
%58 = tail call double @exp(double %57)
%59 = fdiv double %58, %7
%60 = fmul double %59, 0x401921FB54442D1C
%61 = tail call double @gaux(double %43, i32 0)
%62 = tail call double @gaux(double %43, i32 1)
%63 = insertelement <2 x double> poison, double %60, i64 0
%64 = shufflevector <2 x double> %63, <2 x double> poison, <2 x i32> zeroinitializer
%65 = insertelement <2 x double> poison, double %62, i64 0
%66 = insertelement <2 x double> %65, double %61, i64 1
%67 = fmul <2 x double> %64, %66
%68 = tail call double @pow(double %3, double 1.250000e+00)
%69 = tail call double @pow(double %1, double 7.500000e-01)
%70 = fmul double %68, %69
%71 = fmul double %70, 0x3FF0411E71D7796D
%72 = extractelement <2 x double> %67, i64 0
%73 = fneg double %72
%74 = insertelement <2 x double> poison, double %73, i64 0
%75 = shufflevector <2 x double> %74, <2 x double> poison, <2 x i32> zeroinitializer
%76 = fmul <2 x double> %34, %75
%77 = extractelement <2 x double> %67, i64 1
%78 = shufflevector <2 x double> %67, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%79 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %78, <2 x double> %48, <2 x double> %76)
%80 = insertelement <2 x double> poison, double %71, i64 0
%81 = shufflevector <2 x double> %80, <2 x double> poison, <2 x i32> zeroinitializer
%82 = fmul <2 x double> %79, %81
%83 = bitcast double* %5 to <2 x double>*
store <2 x double> %82, <2 x double>* %83
%84 = fmul double %37, %73
%85 = tail call double @llvm.fmuladd.f64(double %77, double %49, double %84)
%86 = fmul double %85, %71
%87 = getelementptr inbounds double, double* %5, i64 2
store double %86, double* %87
%88 = tail call double @gaux(double %43, i32 2)
%89 = fneg double %60
%90 = fmul double %88, %89
%91 = fmul double %40, %90
%92 = shufflevector <2 x double> %44, <2 x double> undef, <2 x i32> zeroinitializer
%93 = insertelement <2 x double> poison, double %91, i64 0
%94 = shufflevector <2 x double> %93, <2 x double> %76, <2 x i32> <i32 0, i32 2>
%95 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %67, <2 x double> %92, <2 x double> %94)
%96 = fmul double %72, -5.000000e-01
%97 = tail call double @llvm.fmuladd.f64(double %77, double 5.000000e-01, double %96)
%98 = fdiv double %97, %7
%99 = tail call double @pow(double %1, double 1.250000e+00)
%100 = fmul double %68, %99
%101 = fmul double %100, 0x4000411E71D77957
%102 = extractelement <2 x double> %48, i64 0
%103 = extractelement <2 x double> %95, i64 1
%104 = tail call double @llvm.fmuladd.f64(double %102, double %103, double %98)
%105 = fneg double %40
%106 = getelementptr inbounds double, double* %5, i64 3
%107 = fneg double %38
%108 = extractelement <2 x double> %95, i64 0
%109 = fmul double %108, %107
%110 = extractelement <2 x double> %48, i64 1
%111 = insertelement <2 x double> %48, double %105, i64 0
%112 = insertelement <2 x double> poison, double %104, i64 0
%113 = insertelement <2 x double> %112, double %109, i64 1
%114 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %111, <2 x double> %95, <2 x double> %113)
%115 = insertelement <2 x double> poison, double %101, i64 0
%116 = shufflevector <2 x double> %115, <2 x double> poison, <2 x i32> zeroinitializer
%117 = fmul <2 x double> %116, %114
%118 = bitcast double* %106 to <2 x double>*
store <2 x double> %117, <2 x double>* %118
%119 = getelementptr inbounds double, double* %5, i64 5
%120 = extractelement <2 x double> %76, i64 1
%121 = tail call double @llvm.fmuladd.f64(double %77, double %46, double %120)
%122 = fmul double %38, %90
%123 = tail call double @llvm.fmuladd.f64(double %72, double %46, double %122)
%124 = insertelement <2 x double> poison, double %37, i64 0
%125 = insertelement <2 x double> %124, double %123, i64 1
%126 = fneg <2 x double> %125
%127 = shufflevector <2 x double> %95, <2 x double> %34, <2 x i32> <i32 0, i32 2>
%128 = fmul <2 x double> %127, %126
%129 = insertelement <2 x double> poison, double %49, i64 0
%130 = insertelement <2 x double> %129, double %121, i64 1
%131 = shufflevector <2 x double> %95, <2 x double> %48, <2 x i32> <i32 1, i32 2>
%132 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %130, <2 x double> %131, <2 x double> %128)
%133 = fmul <2 x double> %116, %132
%134 = bitcast double* %119 to <2 x double>*
store <2 x double> %133, <2 x double>* %134
%135 = tail call double @llvm.fmuladd.f64(double %121, double %110, double %98)
%136 = extractelement <2 x double> %126, i64 1
%137 = getelementptr inbounds double, double* %5, i64 7
%138 = fmul double %37, %136
%139 = insertelement <2 x double> poison, double %136, i64 0
%140 = insertelement <2 x double> %139, double %121, i64 1
%141 = insertelement <2 x double> poison, double %38, i64 0
%142 = insertelement <2 x double> %141, double %49, i64 1
%143 = insertelement <2 x double> poison, double %135, i64 0
%144 = insertelement <2 x double> %143, double %138, i64 1
%145 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %140, <2 x double> %142, <2 x double> %144)
%146 = fmul <2 x double> %116, %145
%147 = bitcast double* %137 to <2 x double>*
store <2 x double> %146, <2 x double>* %147
%148 = tail call double @llvm.fmuladd.f64(double %77, double %47, double %84)
%149 = fmul double %37, %90
%150 = tail call double @llvm.fmuladd.f64(double %72, double %47, double %149)
%151 = fneg double %150
%152 = getelementptr inbounds double, double* %5, i64 9
%153 = insertelement <2 x double> poison, double %151, i64 0
%154 = shufflevector <2 x double> %153, <2 x double> poison, <2 x i32> zeroinitializer
%155 = fmul <2 x double> %34, %154
%156 = insertelement <2 x double> poison, double %148, i64 0
%157 = shufflevector <2 x double> %156, <2 x double> poison, <2 x i32> zeroinitializer
%158 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %48, <2 x double> %157, <2 x double> %155)
%159 = fmul <2 x double> %116, %158
%160 = bitcast double* %152 to <2 x double>*
store <2 x double> %159, <2 x double>* %160
%161 = tail call double @llvm.fmuladd.f64(double %49, double %148, double %98)
%162 = tail call double @llvm.fmuladd.f64(double %151, double %37, double %161)
%163 = fmul double %101, %162
%164 = getelementptr inbounds double, double* %5, i64 11
store double %163, double* %164
ret void
}