#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 */
int /*<<< orphan*/ eriB_1d(double *, int, int, int, int, double, double, double,
                           double, double, double, double, double, double);
int /*<<< orphan*/ fgamma_set(int, double, double *);
double sqrt(double);
double primeERI(double xa, double ya, double za, int la, int ma, int na,
                double alphaa, double xb, double yb, double zb, int lb, int mb,
                int nb, double alphab, double xc, double yc, double zc, int lc,
                int mc, int nc, double alphac, double xd, double yd, double zd,
                int ld, int md, int nd, double alphad) {
  double Bx[4 * 8], By[4 * 8], Bz[4 * 8], F[4 * 8];
  double rpq2, xp, yp, zp, xq, yq, zq, sum;
  double eta1, eta2, zeta;
  int kX, kY, kZ;
  double t;
  eta1 = 1.0 / (alphaa + alphab);
  eta2 = 1.0 / (alphac + alphad);
  zeta = 4.0 * (alphaa + alphab) * (alphac + alphad) /
         (alphaa + alphab + alphac + alphad);
  xp = (alphaa * xa + alphab * xb) * eta1;
  yp = (alphaa * ya + alphab * yb) * eta1;
  zp = (alphaa * za + alphab * zb) * eta1;
  xq = (alphac * xc + alphad * xd) * eta2;
  yq = (alphac * yc + alphad * yd) * eta2;
  zq = (alphac * zc + alphad * zd) * eta2;
  rpq2 =
      ((xp - xq) * (xp - xq) + (yp - yq) * (yp - yq) + (zp - zq) * (zp - zq));
  t = 0.25 * rpq2 * zeta;
  fgamma_set(la + lb + lc + ld + ma + mb + mc + md + na + nb + nc + nd, t, F);
  eriB_1d(Bx, la, lb, lc, ld, xp, xa, xb, xq, xc, xd, eta1, eta2, zeta);
  eriB_1d(By, ma, mb, mc, md, yp, ya, yb, yq, yc, yd, eta1, eta2, zeta);
  eriB_1d(Bz, na, nb, nc, nd, zp, za, zb, zq, zc, zd, eta1, eta2, zeta);
  sum = 0.0;
  for (kX = 0; kX < la + lb + lc + ld + 1; kX++)
    for (kY = 0; kY < ma + mb + mc + md + 1; kY++)
      for (kZ = 0; kZ < na + nb + nc + nd + 1; kZ++)
        sum += Bx[kX] * By[kY] * Bz[kZ] * F[kX + kY + kZ];
  return sum / sqrt(alphaa + alphab + alphac + alphad);
}


x86 assembly (clang, -O0):
<primeERI>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e0,%rsp
movsd  0x78(%rbp),%xmm8
mov    0x70(%rbp),%eax
mov    0x68(%rbp),%eax
mov    0x60(%rbp),%eax
movsd  0x58(%rbp),%xmm8
movsd  0x50(%rbp),%xmm8
movsd  0x48(%rbp),%xmm8
movsd  0x40(%rbp),%xmm8
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
movsd  0x20(%rbp),%xmm8
movsd  0x18(%rbp),%xmm8
movsd  0x10(%rbp),%xmm8
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
mov    %edi,-0x1c(%rbp)
mov    %esi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
movsd  %xmm3,-0x30(%rbp)
movsd  %xmm4,-0x38(%rbp)
movsd  %xmm5,-0x40(%rbp)
movsd  %xmm6,-0x48(%rbp)
mov    %ecx,-0x4c(%rbp)
mov    %r8d,-0x50(%rbp)
mov    %r9d,-0x54(%rbp)
movsd  %xmm7,-0x60(%rbp)
movsd  -0x30(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movsd  0xe45(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x4a8(%rbp)
ff
movsd  0x40(%rbp),%xmm1
addsd  0x78(%rbp),%xmm1
movsd  0xe27(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x4b0(%rbp)
ff
movsd  -0x30(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movsd  0xe01(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x40(%rbp),%xmm1
addsd  0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
addsd  0x40(%rbp),%xmm1
addsd  0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x4b8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x4a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x470(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x4a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x478(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x4a8(%rbp),%xmm0
ff
movsd  %xmm0,-0x480(%rbp)
ff
movsd  0x40(%rbp),%xmm0
movsd  0x10(%rbp),%xmm2
movsd  0x78(%rbp),%xmm1
mulsd  0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x4b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x488(%rbp)
ff
movsd  0x40(%rbp),%xmm0
movsd  0x18(%rbp),%xmm2
movsd  0x78(%rbp),%xmm1
mulsd  0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x4b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x490(%rbp)
ff
movsd  0x40(%rbp),%xmm0
movsd  0x20(%rbp),%xmm2
movsd  0x78(%rbp),%xmm1
mulsd  0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x4b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x498(%rbp)
ff
movsd  -0x470(%rbp),%xmm1
ff
subsd  -0x488(%rbp),%xmm1
ff
movsd  -0x470(%rbp),%xmm2
ff
subsd  -0x488(%rbp),%xmm2
ff
movsd  -0x478(%rbp),%xmm0
ff
subsd  -0x490(%rbp),%xmm0
ff
movsd  -0x478(%rbp),%xmm3
ff
subsd  -0x490(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x480(%rbp),%xmm0
ff
subsd  -0x498(%rbp),%xmm0
ff
movsd  -0x480(%rbp),%xmm2
ff
subsd  -0x498(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x468(%rbp)
ff
movsd  0xc3b(%rip),%xmm0
mulsd  -0x468(%rbp),%xmm0
ff
mulsd  -0x4b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x4d0(%rbp)
ff
mov    -0x1c(%rbp),%edi
add    -0x4c(%rbp),%edi
add    0x28(%rbp),%edi
add    0x60(%rbp),%edi
add    -0x20(%rbp),%edi
add    -0x50(%rbp),%edi
add    0x30(%rbp),%edi
add    0x68(%rbp),%edi
add    -0x24(%rbp),%edi
add    -0x54(%rbp),%edi
add    0x38(%rbp),%edi
add    0x70(%rbp),%edi
movsd  -0x4d0(%rbp),%xmm0
ff
lea    -0x460(%rbp),%rsi
call   1030 <fgamma_set@plt>
lea    -0x160(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    0x28(%rbp),%ecx
mov    0x60(%rbp),%r8d
movsd  -0x470(%rbp),%xmm0
ff
movsd  -0x8(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  -0x488(%rbp),%xmm3
ff
movsd  0x10(%rbp),%xmm4
movsd  0x48(%rbp),%xmm5
movsd  -0x4a8(%rbp),%xmm6
ff
movsd  -0x4b0(%rbp),%xmm7
ff
movsd  -0x4b8(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1050 <eriB_1d@plt>
lea    -0x260(%rbp),%rdi
mov    -0x20(%rbp),%esi
mov    -0x50(%rbp),%edx
mov    0x30(%rbp),%ecx
mov    0x68(%rbp),%r8d
movsd  -0x478(%rbp),%xmm0
ff
movsd  -0x10(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0x490(%rbp),%xmm3
ff
movsd  0x18(%rbp),%xmm4
movsd  0x50(%rbp),%xmm5
movsd  -0x4a8(%rbp),%xmm6
ff
movsd  -0x4b0(%rbp),%xmm7
ff
movsd  -0x4b8(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1050 <eriB_1d@plt>
lea    -0x360(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x54(%rbp),%edx
mov    0x38(%rbp),%ecx
mov    0x70(%rbp),%r8d
movsd  -0x480(%rbp),%xmm0
ff
movsd  -0x18(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0x498(%rbp),%xmm3
ff
movsd  0x20(%rbp),%xmm4
movsd  0x58(%rbp),%xmm5
movsd  -0x4a8(%rbp),%xmm6
ff
movsd  -0x4b0(%rbp),%xmm7
ff
movsd  -0x4b8(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1050 <eriB_1d@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x4a0(%rbp)
ff
movl   $0x0,-0x4bc(%rbp)
mov    -0x4bc(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    -0x4c(%rbp),%ecx
add    0x28(%rbp),%ecx
add    0x60(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1654 <primeERI+0x524>
movl   $0x0,-0x4c0(%rbp)
mov    -0x4c0(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    0x30(%rbp),%ecx
add    0x68(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    163b <primeERI+0x50b>
movl   $0x0,-0x4c4(%rbp)
mov    -0x4c4(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    -0x54(%rbp),%ecx
add    0x38(%rbp),%ecx
add    0x70(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1622 <primeERI+0x4f2>
movslq -0x4bc(%rbp),%rax
movsd  -0x160(%rbp,%rax,8),%xmm0
ff ff
movslq -0x4c0(%rbp),%rax
mulsd  -0x260(%rbp,%rax,8),%xmm0
ff ff
movslq -0x4c4(%rbp),%rax
mulsd  -0x360(%rbp,%rax,8),%xmm0
ff ff
mov    -0x4bc(%rbp),%eax
add    -0x4c0(%rbp),%eax
add    -0x4c4(%rbp),%eax
cltq
movsd  -0x460(%rbp,%rax,8),%xmm2
ff ff
movsd  -0x4a0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x4a0(%rbp)
ff
mov    -0x4c4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c4(%rbp)
jmp    158c <primeERI+0x45c>
jmp    1627 <primeERI+0x4f7>
mov    -0x4c0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c0(%rbp)
jmp    1565 <primeERI+0x435>
jmp    1640 <primeERI+0x510>
mov    -0x4bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4bc(%rbp)
jmp    153e <primeERI+0x40e>
movsd  -0x4a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x4d8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
addsd  0x40(%rbp),%xmm0
addsd  0x78(%rbp),%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x4d8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
add    $0x4e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<primeERI>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x548,%rsp
mov    %r9,0x58(%rsp)
mov    %r8,0x38(%rsp)
mov    %rcx,0x28(%rsp)
movapd %xmm6,0x100(%rsp)
movapd %xmm5,0xe0(%rsp)
movapd %xmm4,0x90(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rsi,0x30(%rsp)
mov    %edi,%r14d
movapd %xmm2,0x120(%rsp)
movapd %xmm1,0x110(%rsp)
movapd %xmm0,0xf0(%rsp)
movsd  0x590(%rsp),%xmm10
movsd  0x588(%rsp),%xmm11
movsd  0x580(%rsp),%xmm12
movsd  0x5e8(%rsp),%xmm8
movsd  0x5b0(%rsp),%xmm9
unpcklpd %xmm9,%xmm3
unpcklpd %xmm8,%xmm7
movapd %xmm0,%xmm13
unpcklpd %xmm12,%xmm13
mulpd  %xmm3,%xmm13
unpcklpd %xmm11,%xmm1
mulpd  %xmm3,%xmm1
movapd %xmm1,%xmm11
movapd %xmm2,%xmm1
unpcklpd %xmm10,%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm7,%xmm3
movsd  0xe0b(%rip),%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm0,%xmm12
movapd 0xddd(%rip),%xmm10
divpd  %xmm3,%xmm10
addsd  %xmm9,%xmm3
addsd  %xmm8,%xmm3
movsd  0x5b8(%rsp),%xmm2
movapd %xmm4,%xmm0
unpcklpd %xmm2,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm0,%xmm13
movsd  0x5c0(%rsp),%xmm2
movapd %xmm5,%xmm0
unpcklpd %xmm2,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm0,%xmm11
movsd  0x5c8(%rsp),%xmm2
movapd %xmm6,%xmm0
unpcklpd %xmm2,%xmm0
mulpd  %xmm7,%xmm0
movapd %xmm1,%xmm2
addpd  %xmm0,%xmm2
movapd %xmm13,%xmm1
mulpd  %xmm10,%xmm1
movapd %xmm1,0x70(%rsp)
mulpd  %xmm10,%xmm11
movapd %xmm10,0x40(%rsp)
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
movapd %xmm0,0x80(%rsp)
subsd  %xmm0,%xmm1
movapd %xmm11,%xmm0
movapd %xmm11,0xa0(%rsp)
movapd %xmm11,%xmm4
unpckhpd %xmm11,%xmm4
movapd %xmm4,0xb0(%rsp)
subsd  %xmm4,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulpd  %xmm10,%xmm2
movapd %xmm2,0xd0(%rsp)
movapd %xmm2,%xmm4
unpckhpd %xmm2,%xmm4
movapd %xmm4,0xc0(%rsp)
movapd %xmm2,%xmm0
subsd  %xmm4,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x5e0(%rsp),%r13d
mov    0x5d8(%rsp),%r15d
mov    0x5d0(%rsp),%ebp
movapd %xmm3,0x130(%rsp)
divsd  %xmm3,%xmm12
movapd %xmm12,0x10(%rsp)
mulsd  0xccf(%rip),%xmm0
mulsd  %xmm12,%xmm0
lea    (%rcx,%r14,1),%ebx
add    0x598(%rsp),%ebx
add    %ebp,%ebx
lea    (%r8,%rsi,1),%r12d
lea    (%r12,%rdx,1),%edi
add    %r9d,%edi
add    0x5a0(%rsp),%edi
add    0x5a8(%rsp),%edi
add    %ebx,%edi
add    %r15d,%edi
add    %r13d,%edi
lea    0x240(%rsp),%rsi
call   1030 <fgamma_set@plt>
movaps 0x40(%rsp),%xmm6
movaps %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
movaps %xmm0,%xmm7
movaps %xmm0,0x60(%rsp)
movaps 0x10(%rsp),%xmm0
movsd  %xmm0,(%rsp)
lea    0x440(%rsp),%rdi
mov    %r14,0x50(%rsp)
mov    %r14d,%esi
mov    0x28(%rsp),%rdx
mov    0x598(%rsp),%ecx
mov    %ebp,%r8d
movaps 0x70(%rsp),%xmm0
movaps 0xf0(%rsp),%xmm1
movaps 0x90(%rsp),%xmm2
movaps 0x80(%rsp),%xmm3
movsd  0x580(%rsp),%xmm4
movsd  0x5b8(%rsp),%xmm5
call   1050 <eriB_1d@plt>
movaps 0x10(%rsp),%xmm0
movsd  %xmm0,(%rsp)
lea    0x340(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    0x5a0(%rsp),%ecx
mov    %r15d,%r8d
movaps 0xa0(%rsp),%xmm0
movaps 0x110(%rsp),%xmm1
movaps 0xe0(%rsp),%xmm2
movaps 0xb0(%rsp),%xmm3
movsd  0x588(%rsp),%xmm4
movsd  0x5c0(%rsp),%xmm5
movaps 0x40(%rsp),%xmm6
movaps 0x60(%rsp),%xmm7
call   1050 <eriB_1d@plt>
movaps 0x10(%rsp),%xmm0
movsd  %xmm0,(%rsp)
lea    0x140(%rsp),%rdi
mov    0x20(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    %rdx,%r14
mov    0x5a8(%rsp),%ecx
mov    %r13d,%r8d
movapd 0xd0(%rsp),%xmm0
movapd 0x120(%rsp),%xmm1
movapd 0x100(%rsp),%xmm2
movapd 0xc0(%rsp),%xmm3
movsd  0x590(%rsp),%xmm4
movsd  0x5c8(%rsp),%xmm5
movaps 0x40(%rsp),%xmm6
movaps 0x60(%rsp),%xmm7
call   1050 <eriB_1d@plt>
xorpd  %xmm0,%xmm0
xorpd  %xmm3,%xmm3
test   %ebx,%ebx
js     160e <primeERI+0x4de>
mov    0x5a0(%rsp),%edx
add    %edx,%r12d
add    %r15d,%r12d
mov    %r14,%rax
mov    0x20(%rsp),%rcx
add    %ecx,%r14d
mov    0x5a8(%rsp),%esi
add    %esi,%r14d
add    %r13d,%r14d
add    %esi,%r13d
add    %eax,%r13d
lea    (%rcx,%r13,1),%r10d
lea    (%rcx,%r13,1),%r11d
add    $0x1,%r11d
add    %edx,%r15d
add    0x38(%rsp),%r15d
mov    0x30(%rsp),%rcx
lea    (%rcx,%r15,1),%esi
add    $0x1,%esi
add    0x598(%rsp),%ebp
add    0x28(%rsp),%ebp
mov    0x50(%rsp),%rax
lea    (%rax,%rbp,1),%r8d
add    $0x1,%r8d
mov    %r11d,%edx
and    $0xfffffffe,%edx
lea    0x248(%rsp),%r9
xorpd  %xmm3,%xmm3
xor    %edi,%edi
jmp    1571 <primeERI+0x441>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x8,%r9
cmp    %r8,%rdi
je     160e <primeERI+0x4de>
test   %r12d,%r12d
js     1560 <primeERI+0x430>
mov    %r9,%rbx
xor    %ecx,%ecx
jmp    158d <primeERI+0x45d>
nopl   (%rax)
add    $0x1,%rcx
add    $0x8,%rbx
cmp    %rsi,%rcx
je     1560 <primeERI+0x430>
test   %r14d,%r14d
js     1580 <primeERI+0x450>
movsd  0x440(%rsp,%rdi,8),%xmm1
mulsd  0x340(%rsp,%rcx,8),%xmm1
xor    %ebp,%ebp
test   %r10d,%r10d
je     15e6 <primeERI+0x4b6>
nopl   0x0(%rax,%rax,1)
movsd  0x140(%rsp,%rbp,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  -0x8(%rbx,%rbp,8),%xmm2
addsd  %xmm3,%xmm2
movsd  0x148(%rsp,%rbp,8),%xmm3
mulsd  %xmm1,%xmm3
mulsd  (%rbx,%rbp,8),%xmm3
addsd  %xmm2,%xmm3
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    15b0 <primeERI+0x480>
test   $0x1,%r11b
je     1580 <primeERI+0x450>
lea    (%rcx,%rdi,1),%rax
mulsd  0x140(%rsp,%rbp,8),%xmm1
add    %rbp,%rax
mulsd  0x240(%rsp,%rax,8),%xmm1
addsd  %xmm1,%xmm3
jmp    1580 <primeERI+0x450>
movapd 0x130(%rsp),%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm1,%xmm0
jb     1627 <primeERI+0x4f7>
sqrtsd %xmm0,%xmm0
jmp    1638 <primeERI+0x508>
movsd  %xmm3,0x10(%rsp)
call   1040 <sqrt@plt>
movsd  0x10(%rsp),%xmm3
divsd  %xmm0,%xmm3
movapd %xmm3,%xmm0
add    $0x548,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define double @primeERI(double %0, double %1, double %2, i32 %3, i32 %4, i32 %5, double %6, double %7, double %8, double %9, i32 %10, i32 %11, i32 %12, double %13, double %14, double %15, double %16, i32 %17, i32 %18, i32 %19, double %20, double %21, double %22, double %23, i32 %24, i32 %25, i32 %26, double %27) {
%29 = alloca [32 x double]
%30 = alloca [32 x double]
%31 = alloca [32 x double]
%32 = alloca [32 x double]
%33 = bitcast [32 x double]* %29 to i8*
%34 = bitcast [32 x double]* %30 to i8*
%35 = bitcast [32 x double]* %31 to i8*
%36 = bitcast [32 x double]* %32 to i8*
%37 = insertelement <2 x double> poison, double %6, i64 0
%38 = insertelement <2 x double> %37, double %20, i64 1
%39 = insertelement <2 x double> poison, double %13, i64 0
%40 = insertelement <2 x double> %39, double %27, i64 1
%41 = fadd <2 x double> %38, %40
%42 = fdiv <2 x double> <double 1.000000e+00, double 1.000000e+00>, %41
%43 = extractelement <2 x double> %41, i64 0
%44 = fmul double %43, 4.000000e+00
%45 = extractelement <2 x double> %41, i64 1
%46 = fmul double %44, %45
%47 = fadd double %43, %20
%48 = fadd double %47, %27
%49 = fdiv double %46, %48
%50 = insertelement <2 x double> poison, double %7, i64 0
%51 = insertelement <2 x double> %50, double %21, i64 1
%52 = fmul <2 x double> %51, %40
%53 = insertelement <2 x double> poison, double %0, i64 0
%54 = insertelement <2 x double> %53, double %14, i64 1
%55 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %54, <2 x double> %52)
%56 = fmul <2 x double> %55, %42
%57 = insertelement <2 x double> poison, double %8, i64 0
%58 = insertelement <2 x double> %57, double %22, i64 1
%59 = fmul <2 x double> %58, %40
%60 = insertelement <2 x double> poison, double %1, i64 0
%61 = insertelement <2 x double> %60, double %15, i64 1
%62 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %61, <2 x double> %59)
%63 = fmul <2 x double> %62, %42
%64 = insertelement <2 x double> poison, double %9, i64 0
%65 = insertelement <2 x double> %64, double %23, i64 1
%66 = fmul <2 x double> %65, %40
%67 = insertelement <2 x double> poison, double %2, i64 0
%68 = insertelement <2 x double> %67, double %16, i64 1
%69 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %38, <2 x double> %68, <2 x double> %66)
%70 = fmul <2 x double> %69, %42
%71 = extractelement <2 x double> %56, i64 0
%72 = extractelement <2 x double> %56, i64 1
%73 = fsub double %71, %72
%74 = extractelement <2 x double> %63, i64 0
%75 = extractelement <2 x double> %63, i64 1
%76 = fsub double %74, %75
%77 = fmul double %76, %76
%78 = tail call double @llvm.fmuladd.f64(double %73, double %73, double %77)
%79 = extractelement <2 x double> %70, i64 0
%80 = extractelement <2 x double> %70, i64 1
%81 = fsub double %79, %80
%82 = tail call double @llvm.fmuladd.f64(double %81, double %81, double %78)
%83 = fmul double %82, 2.500000e-01
%84 = fmul double %49, %83
%85 = add nsw i32 %10, %3
%86 = add nsw i32 %85, %17
%87 = add nsw i32 %86, %24
%88 = add i32 %11, %4
%89 = add i32 %88, %5
%90 = add i32 %89, %12
%91 = add i32 %90, %18
%92 = add i32 %91, %19
%93 = add i32 %92, %87
%94 = add i32 %93, %25
%95 = add i32 %94, %26
%96 = getelementptr inbounds [32 x double], [32 x double]* %32, i64 0, i64 0
%97 = call i32 @fgamma_set(i32 %95, double %84, double* %96)
%98 = getelementptr inbounds [32 x double], [32 x double]* %29, i64 0, i64 0
%99 = extractelement <2 x double> %42, i64 0
%100 = extractelement <2 x double> %42, i64 1
%101 = call i32 @eriB_1d(double* %98, i32 %3, i32 %10, i32 %17, i32 %24, double %71, double %0, double %7, double %72, double %14, double %21, double %99, double %100, double %49)
%102 = getelementptr inbounds [32 x double], [32 x double]* %30, i64 0, i64 0
%103 = call i32 @eriB_1d(double* %102, i32 %4, i32 %11, i32 %18, i32 %25, double %74, double %1, double %8, double %75, double %15, double %22, double %99, double %100, double %49)
%104 = getelementptr inbounds [32 x double], [32 x double]* %31, i64 0, i64 0
%105 = call i32 @eriB_1d(double* %104, i32 %5, i32 %12, i32 %19, i32 %26, double %79, double %2, double %9, double %80, double %16, double %23, double %99, double %100, double %49)
%106 = icmp slt i32 %87, 0
br i1 %106, label %190, label %107
107: ; preds = %28
%108 = add nsw i32 %88, %18
%109 = add nsw i32 %108, %25
%110 = icmp slt i32 %109, 0
%111 = add nsw i32 %12, %5
%112 = add nsw i32 %111, %19
%113 = add nsw i32 %112, %26
%114 = icmp slt i32 %113, 0
%115 = add i32 %26, %19
%116 = add i32 %115, %12
%117 = add i32 %116, %5
%118 = add i32 %117, 1
%119 = add i32 %25, %18
%120 = add i32 %119, %11
%121 = add i32 %120, %4
%122 = add i32 %121, 1
%123 = add i32 %24, %17
%124 = add i32 %123, %10
%125 = add i32 %124, %3
%126 = add i32 %125, 1
%127 = zext i32 %126 to i64
%128 = zext i32 %122 to i64
%129 = zext i32 %118 to i64
%130 = and i64 %129, 1
%131 = icmp eq i32 %117, 0
%132 = and i64 %129, 4294967294
%133 = icmp eq i64 %130, 0
br label %134
134: ; preds = %107, %186
%135 = phi i64 [ 0, %107 ], [ %188, %186 ]
%136 = phi double [ 0.000000e+00, %107 ], [ %187, %186 ]
br i1 %110, label %186, label %137
137: ; preds = %134
%138 = getelementptr inbounds [32 x double], [32 x double]* %29, i64 0, i64 %135
br label %139
139: ; preds = %137, %182
%140 = phi i64 [ 0, %137 ], [ %184, %182 ]
%141 = phi double [ %136, %137 ], [ %183, %182 ]
br i1 %114, label %182, label %142
142: ; preds = %139
%143 = load double, double* %138
%144 = getelementptr inbounds [32 x double], [32 x double]* %30, i64 0, i64 %140
%145 = load double, double* %144
%146 = fmul double %143, %145
%147 = add nuw nsw i64 %140, %135
br i1 %131, label %170, label %148
148: ; preds = %142, %148
%149 = phi i64 [ %167, %148 ], [ 0, %142 ]
%150 = phi double [ %166, %148 ], [ %141, %142 ]
%151 = phi i64 [ %168, %148 ], [ 0, %142 ]
%152 = getelementptr inbounds [32 x double], [32 x double]* %31, i64 0, i64 %149
%153 = load double, double* %152
%154 = fmul double %146, %153
%155 = add nuw nsw i64 %147, %149
%156 = getelementptr inbounds [32 x double], [32 x double]* %32, i64 0, i64 %155
%157 = load double, double* %156
%158 = call double @llvm.fmuladd.f64(double %154, double %157, double %150)
%159 = or i64 %149, 1
%160 = getelementptr inbounds [32 x double], [32 x double]* %31, i64 0, i64 %159
%161 = load double, double* %160
%162 = fmul double %146, %161
%163 = add nuw nsw i64 %147, %159
%164 = getelementptr inbounds [32 x double], [32 x double]* %32, i64 0, i64 %163
%165 = load double, double* %164
%166 = call double @llvm.fmuladd.f64(double %162, double %165, double %158)
%167 = add nuw nsw i64 %149, 2
%168 = add i64 %151, 2
%169 = icmp eq i64 %168, %132
br i1 %169, label %170, label %148
170: ; preds = %148, %142
%171 = phi double [ undef, %142 ], [ %166, %148 ]
%172 = phi i64 [ 0, %142 ], [ %167, %148 ]
%173 = phi double [ %141, %142 ], [ %166, %148 ]
br i1 %133, label %182, label %174
174: ; preds = %170
%175 = getelementptr inbounds [32 x double], [32 x double]* %31, i64 0, i64 %172
%176 = load double, double* %175
%177 = fmul double %146, %176
%178 = add nuw nsw i64 %147, %172
%179 = getelementptr inbounds [32 x double], [32 x double]* %32, i64 0, i64 %178
%180 = load double, double* %179
%181 = call double @llvm.fmuladd.f64(double %177, double %180, double %173)
br label %182
182: ; preds = %174, %170, %139
%183 = phi double [ %141, %139 ], [ %171, %170 ], [ %181, %174 ]
%184 = add nuw nsw i64 %140, 1
%185 = icmp eq i64 %184, %128
br i1 %185, label %186, label %139
186: ; preds = %182, %134
%187 = phi double [ %136, %134 ], [ %183, %182 ]
%188 = add nuw nsw i64 %135, 1
%189 = icmp eq i64 %188, %127
br i1 %189, label %190, label %134
190: ; preds = %186, %28
%191 = phi double [ 0.000000e+00, %28 ], [ %187, %186 ]
%192 = call double @sqrt(double %48)
%193 = fdiv double %191, %192
ret double %193
}