#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_P_P(double *a, double a_a, double *b, double b_a, double *c,
                   double *out) {
  double ab_a, d_0, d_1, d_2, nai_100_000_0, p_0, p_1, p_2, 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);
  nai_100_000_0 = d_1 * v_0 - d_2 * u_0;
  usq = 6.28318530717959 * d_0 * gaux(usq, 2);
  v_0 = d_2 * v_0 - u_0 * usq;
  ab_a = (0.5 * d_1 - 0.5 * d_2) / ab_a;
  d_0 = pow(a_a, 1.25) * pow(b_a, 1.25);
  out[0] = 2.03179634989571 * d_0 * (ab_a + nai_100_000_0 * p_0 - u_0 * v_0);
  out[1] = 2.03179634989571 * d_0 * (nai_100_000_0 * p_1 - u_1 * v_0);
  out[2] = 2.03179634989571 * d_0 * (nai_100_000_0 * p_2 - u_2 * v_0);
  nai_100_000_0 = d_1 * v_1 - d_2 * u_1;
  v_0 = d_2 * v_1 - u_1 * usq;
  out[3] = 2.03179634989571 * d_0 * (nai_100_000_0 * p_0 - u_0 * v_0);
  out[4] = 2.03179634989571 * d_0 * (ab_a + nai_100_000_0 * p_1 - u_1 * v_0);
  out[5] = 2.03179634989571 * d_0 * (nai_100_000_0 * p_2 - u_2 * v_0);
  v_1 = d_1 * v_2 - d_2 * u_2;
  v_2 = d_2 * v_2 - u_2 * usq;
  out[6] = 2.03179634989571 * d_0 * (p_0 * v_1 - u_0 * v_2);
  out[7] = 2.03179634989571 * d_0 * (p_1 * v_1 - u_1 * v_2);
  out[8] = 2.03179634989571 * d_0 * (ab_a + p_2 * v_1 - u_2 * v_2);
}


x86 assembly (clang, -O0):
<gint2_nai_P_P>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%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,-0x60(%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,-0x68(%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,-0x70(%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  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm3
movsd  -0x80(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x70(%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  0xc81(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
xor    %edi,%edi
call   1030 <gaux@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  0xc49(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    $0x1,%edi
call   1030 <gaux@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0xbd3(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    $0x2,%edi
call   1030 <gaux@plt>
movaps %xmm0,%xmm1
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  0xb47(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
movsd  0xb23(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x10(%rbp),%xmm0
movsd  0xafc(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  0xae2(%rip),%xmm1
call   1050 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  0xab9(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%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,(%rax)
movsd  0xa5d(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm3
movsd  -0x80(%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,0x8(%rax)
movsd  0xa0d(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm3
movsd  -0x88(%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,0x10(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x93e(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%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,0x18(%rax)
movsd  0x8ee(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm2
movsd  -0x68(%rbp),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x80(%rbp),%xmm1
movsd  -0x98(%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,0x20(%rax)
movsd  0x891(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm3
movsd  -0x88(%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,0x28(%rax)
movsd  -0x48(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  -0x90(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x7b9(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm3
ff
movsd  -0x78(%rbp),%xmm2
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,0x30(%rax)
movsd  0x766(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm1
movsd  -0xa0(%rbp),%xmm3
ff
movsd  -0x80(%rbp),%xmm2
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,0x38(%rax)
movsd  0x713(%rip),%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x88(%rbp),%xmm1
ff
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,0x40(%rax)
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gint2_nai_P_P>:
push   %rbx
sub    $0xf0,%rsp
mov    %rcx,%rbx
movapd %xmm0,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,%xmm13
movupd (%rdi),%xmm4
movupd (%rsi),%xmm11
movapd %xmm1,%xmm2
movapd %xmm1,%xmm10
movapd %xmm1,0x60(%rsp)
unpcklpd %xmm1,%xmm2
mulpd  %xmm11,%xmm2
movapd %xmm0,%xmm3
movapd %xmm0,%xmm14
unpcklpd %xmm0,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm13,%xmm2
unpcklpd %xmm13,%xmm2
divpd  %xmm2,%xmm3
movapd %xmm3,%xmm9
movsd  0x10(%rdi),%xmm8
movsd  0x10(%rsi),%xmm3
movapd %xmm9,%xmm0
subpd  %xmm4,%xmm0
movapd %xmm0,0x90(%rsp)
subpd  %xmm11,%xmm4
movapd %xmm8,%xmm0
subsd  %xmm3,%xmm0
movapd %xmm9,%xmm5
subpd  %xmm11,%xmm5
movapd %xmm5,%xmm1
movapd %xmm5,0xa0(%rsp)
unpcklpd %xmm3,%xmm11
mulsd  %xmm10,%xmm3
movapd %xmm8,%xmm2
movapd %xmm14,0x50(%rsp)
mulsd  %xmm14,%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm13,%xmm2
movupd (%rdx),%xmm3
movapd %xmm9,%xmm5
movapd %xmm2,%xmm7
subsd  0x10(%rdx),%xmm7
movapd %xmm7,0xb0(%rsp)
subpd  %xmm3,%xmm5
movapd %xmm5,0x70(%rsp)
movapd %xmm5,%xmm3
mulpd  %xmm5,%xmm3
unpckhpd %xmm3,%xmm3
mulsd  %xmm5,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm7,%xmm7
addsd  %xmm5,%xmm7
movapd %xmm13,0x20(%rsp)
mulsd  %xmm13,%xmm7
movapd %xmm7,0x10(%rsp)
movapd %xmm9,%xmm6
unpcklpd %xmm2,%xmm6
subsd  %xmm8,%xmm2
movapd %xmm2,0xc0(%rsp)
movapd %xmm1,%xmm2
unpckhpd %xmm1,%xmm2
movapd %xmm2,0xe0(%rsp)
subpd  %xmm11,%xmm6
movapd %xmm6,0x80(%rsp)
movapd %xmm4,%xmm1
mulpd  %xmm4,%xmm1
unpckhpd %xmm1,%xmm1
mulsd  %xmm4,%xmm4
addsd  %xmm1,%xmm4
mulsd  %xmm0,%xmm0
addsd  %xmm4,%xmm0
movapd %xmm14,%xmm1
xorpd  0xd57(%rip),%xmm1
mulsd  %xmm10,%xmm1
mulsd  %xmm1,%xmm0
movapd %xmm6,%xmm1
shufpd $0x1,%xmm6,%xmm1
movapd %xmm1,0xd0(%rsp)
divsd  %xmm13,%xmm0
call   1040 <exp@plt>
divsd  0x20(%rsp),%xmm0
mulsd  0xd34(%rip),%xmm0
movsd  %xmm0,0x8(%rsp)
movapd 0x10(%rsp),%xmm0
xor    %edi,%edi
call   1030 <gaux@plt>
mulsd  0x8(%rsp),%xmm0
movapd %xmm0,0x40(%rsp)
movapd 0x10(%rsp),%xmm0
mov    $0x1,%edi
call   1030 <gaux@plt>
mulsd  0x8(%rsp),%xmm0
movapd %xmm0,0x30(%rsp)
movapd 0x10(%rsp),%xmm0
mov    $0x2,%edi
call   1030 <gaux@plt>
mulsd  0x8(%rsp),%xmm0
movapd %xmm0,0x10(%rsp)
movsd  0xcdd(%rip),%xmm0
mulsd  0x30(%rsp),%xmm0
movsd  0xcd7(%rip),%xmm1
mulsd  0x40(%rsp),%xmm1
addsd  %xmm0,%xmm1
divsd  0x20(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0xcc1(%rip),%xmm1
movaps 0x50(%rsp),%xmm0
call   1050 <pow@plt>
movsd  %xmm0,0x20(%rsp)
movapd 0x60(%rsp),%xmm0
movsd  0xca3(%rip),%xmm1
call   1050 <pow@plt>
mulsd  0x20(%rsp),%xmm0
movapd 0x30(%rsp),%xmm13
movapd %xmm13,%xmm1
unpcklpd %xmm13,%xmm1
movapd 0x70(%rsp),%xmm4
movapd %xmm4,%xmm3
mulpd  %xmm1,%xmm3
movapd 0x40(%rsp),%xmm12
movapd %xmm12,%xmm2
unpcklpd %xmm12,%xmm2
movapd 0x90(%rsp),%xmm5
mulpd  %xmm5,%xmm2
subpd  %xmm3,%xmm2
mulpd  %xmm5,%xmm1
movapd 0x10(%rsp),%xmm15
movapd %xmm15,%xmm3
unpcklpd %xmm15,%xmm3
mulpd  %xmm4,%xmm3
subpd  %xmm3,%xmm1
movapd %xmm2,%xmm5
movapd 0x80(%rsp),%xmm10
mulsd  %xmm10,%xmm5
movsd  0x8(%rsp),%xmm3
addsd  %xmm3,%xmm5
movapd %xmm4,%xmm14
movapd %xmm4,%xmm8
movapd 0xbe2(%rip),%xmm11
xorpd  %xmm11,%xmm14
pshufd $0xee,%xmm14,%xmm4
mulsd  %xmm1,%xmm4
unpcklpd %xmm4,%xmm5
movapd %xmm14,%xmm6
unpcklpd %xmm2,%xmm6
movapd 0xa0(%rsp),%xmm9
movapd %xmm9,%xmm4
movsd  %xmm1,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm5,%xmm4
movapd 0xb0(%rsp),%xmm6
movapd %xmm6,%xmm5
mulsd  %xmm13,%xmm5
movapd 0xc0(%rsp),%xmm7
mulsd  %xmm7,%xmm12
subsd  %xmm5,%xmm12
mulsd  0xbae(%rip),%xmm0
mulsd  %xmm7,%xmm13
xorpd  %xmm6,%xmm11
movapd %xmm15,%xmm5
mulsd  %xmm6,%xmm5
subsd  %xmm5,%xmm13
movapd %xmm10,%xmm5
unpckhpd %xmm10,%xmm5
mulsd  %xmm13,%xmm6
mulsd  %xmm12,%xmm5
addsd  %xmm3,%xmm5
subsd  %xmm6,%xmm5
mulsd  %xmm0,%xmm5
unpcklpd %xmm0,%xmm0
mulpd  %xmm0,%xmm4
movupd %xmm4,(%rbx)
movapd %xmm11,%xmm6
movapd %xmm11,%xmm4
unpcklpd %xmm14,%xmm4
mulpd  %xmm1,%xmm4
movapd 0xd0(%rsp),%xmm7
mulpd  %xmm2,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm0,%xmm7
movupd %xmm7,0x10(%rbx)
unpckhpd %xmm2,%xmm14
unpckhpd %xmm2,%xmm2
mulsd  0xe0(%rsp),%xmm2
addsd  %xmm3,%xmm2
movapd %xmm1,%xmm4
unpckhpd %xmm1,%xmm4
mulsd  %xmm6,%xmm4
unpcklpd %xmm4,%xmm2
movapd %xmm10,%xmm4
unpckhpd %xmm10,%xmm1
mulpd  %xmm14,%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x20(%rbx)
movapd %xmm13,%xmm1
unpcklpd %xmm13,%xmm1
mulpd  %xmm8,%xmm1
movapd %xmm1,%xmm2
shufpd $0x2,%xmm9,%xmm4
movapd %xmm12,%xmm1
unpcklpd %xmm12,%xmm1
mulpd  %xmm4,%xmm1
subpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm1
movupd %xmm1,0x30(%rbx)
movsd  %xmm5,0x40(%rbx)
add    $0xf0,%rsp
pop    %rbx
ret

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

LLVM IR (-O2):
define void @gint2_nai_P_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 = fmul <2 x double> %34, %34
%39 = extractelement <2 x double> %38, i64 1
%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 double %27, %22
%46 = fsub <2 x double> %20, %11
%47 = extractelement <2 x double> %46, i64 1
%48 = insertelement <2 x double> %20, double %27, i64 1
%49 = insertelement <2 x double> %11, double %24, i64 1
%50 = fsub <2 x double> %48, %49
%51 = shufflevector <2 x double> %50, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%52 = fneg double %1
%53 = fmul double %52, %3
%54 = fmul <2 x double> %30, %30
%55 = extractelement <2 x double> %54, i64 1
%56 = tail call double @llvm.fmuladd.f64(double %29, double %29, double %55)
%57 = tail call double @llvm.fmuladd.f64(double %31, double %31, double %56)
%58 = fmul double %53, %57
%59 = fdiv double %58, %7
%60 = tail call double @exp(double %59)
%61 = fdiv double %60, %7
%62 = fmul double %61, 0x401921FB54442D1C
%63 = tail call double @gaux(double %43, i32 0)
%64 = fmul double %63, %62
%65 = tail call double @gaux(double %43, i32 1)
%66 = fmul double %62, %65
%67 = fneg double %66
%68 = tail call double @gaux(double %43, i32 2)
%69 = fmul double %62, %68
%70 = fmul double %66, -5.000000e-01
%71 = tail call double @llvm.fmuladd.f64(double %64, double 5.000000e-01, double %70)
%72 = fdiv double %71, %7
%73 = tail call double @pow(double %1, double 1.250000e+00)
%74 = tail call double @pow(double %3, double 1.250000e+00)
%75 = fmul double %73, %74
%76 = fmul double %75, 0x4000411E71D77957
%77 = insertelement <2 x double> poison, double %67, i64 0
%78 = shufflevector <2 x double> %77, <2 x double> poison, <2 x i32> zeroinitializer
%79 = fmul <2 x double> %34, %78
%80 = insertelement <2 x double> poison, double %64, i64 0
%81 = shufflevector <2 x double> %80, <2 x double> poison, <2 x i32> zeroinitializer
%82 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %81, <2 x double> %44, <2 x double> %79)
%83 = extractelement <2 x double> %82, i64 0
%84 = extractelement <2 x double> %50, i64 0
%85 = tail call double @llvm.fmuladd.f64(double %83, double %84, double %72)
%86 = fneg <2 x double> %34
%87 = insertelement <2 x double> poison, double %69, i64 0
%88 = shufflevector <2 x double> %87, <2 x double> poison, <2 x i32> zeroinitializer
%89 = fmul <2 x double> %88, %86
%90 = insertelement <2 x double> poison, double %66, i64 0
%91 = shufflevector <2 x double> %90, <2 x double> poison, <2 x i32> zeroinitializer
%92 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %91, <2 x double> %44, <2 x double> %89)
%93 = extractelement <2 x double> %92, i64 0
%94 = extractelement <2 x double> %86, i64 1
%95 = fmul double %93, %94
%96 = shufflevector <2 x double> %86, <2 x double> %82, <2 x i32> <i32 0, i32 2>
%97 = shufflevector <2 x double> %92, <2 x double> %46, <2 x i32> <i32 0, i32 3>
%98 = insertelement <2 x double> poison, double %85, i64 0
%99 = insertelement <2 x double> %98, double %95, i64 1
%100 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %96, <2 x double> %97, <2 x double> %99)
%101 = insertelement <2 x double> poison, double %76, i64 0
%102 = shufflevector <2 x double> %101, <2 x double> poison, <2 x i32> zeroinitializer
%103 = fmul <2 x double> %102, %100
%104 = bitcast double* %5 to <2 x double>*
store <2 x double> %103, <2 x double>* %104
%105 = fneg double %37
%106 = getelementptr inbounds double, double* %5, i64 2
%107 = insertelement <2 x double> poison, double %105, i64 0
%108 = shufflevector <2 x double> %107, <2 x double> %86, <2 x i32> <i32 0, i32 2>
%109 = fmul <2 x double> %92, %108
%110 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %82, <2 x double> %51, <2 x double> %109)
%111 = fmul <2 x double> %102, %110
%112 = bitcast double* %106 to <2 x double>*
store <2 x double> %111, <2 x double>* %112
%113 = extractelement <2 x double> %82, i64 1
%114 = tail call double @llvm.fmuladd.f64(double %113, double %47, double %72)
%115 = extractelement <2 x double> %92, i64 1
%116 = getelementptr inbounds double, double* %5, i64 4
%117 = fmul double %115, %105
%118 = extractelement <2 x double> %50, i64 1
%119 = shufflevector <2 x double> %86, <2 x double> %82, <2 x i32> <i32 1, i32 3>
%120 = shufflevector <2 x double> %92, <2 x double> %50, <2 x i32> <i32 1, i32 3>
%121 = insertelement <2 x double> poison, double %114, i64 0
%122 = insertelement <2 x double> %121, double %117, i64 1
%123 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %119, <2 x double> %120, <2 x double> %122)
%124 = fmul <2 x double> %102, %123
%125 = bitcast double* %116 to <2 x double>*
store <2 x double> %124, <2 x double>* %125
%126 = fmul double %37, %67
%127 = tail call double @llvm.fmuladd.f64(double %64, double %45, double %126)
%128 = fmul double %69, %105
%129 = tail call double @llvm.fmuladd.f64(double %66, double %45, double %128)
%130 = getelementptr inbounds double, double* %5, i64 6
%131 = insertelement <2 x double> poison, double %129, i64 0
%132 = shufflevector <2 x double> %131, <2 x double> poison, <2 x i32> zeroinitializer
%133 = fmul <2 x double> %132, %86
%134 = shufflevector <2 x double> %50, <2 x double> %46, <2 x i32> <i32 0, i32 3>
%135 = insertelement <2 x double> poison, double %127, i64 0
%136 = shufflevector <2 x double> %135, <2 x double> poison, <2 x i32> zeroinitializer
%137 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %134, <2 x double> %136, <2 x double> %133)
%138 = fmul <2 x double> %102, %137
%139 = bitcast double* %130 to <2 x double>*
store <2 x double> %138, <2 x double>* %139
%140 = tail call double @llvm.fmuladd.f64(double %118, double %127, double %72)
%141 = tail call double @llvm.fmuladd.f64(double %105, double %129, double %140)
%142 = fmul double %76, %141
%143 = getelementptr inbounds double, double* %5, i64 8
store double %142, double* %143
ret void
}