#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(float *, int, int, int, int, float, float, float,
                           float, float, float, float, float, float);
double exp(float);
int /*<<< orphan*/ fgamma_set(int, float, float *);
double sqrt(float);
float eri(float xa, float ya, float za, float norma, int la, int ma, int na,
          float alphaa, float xb, float yb, float zb, float normb, int lb,
          int mb, int nb, float alphab, float xc, float yc, float zc,
          float normc, int lc, int mc, int nc, float alphac, float xd, float yd,
          float zd, float normd, int ld, int md, int nd, float alphad) {
  float Bx[4 * 8], By[4 * 8], Bz[4 * 8], F[4 * 8];
  float rab2, rcd2, rpq2, xp, yp, zp, xq, yq, zq, sum;
  float eta1, eta2, zeta;
  int kX, kY, kZ;
  float 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;
  rab2 =
      ((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb) + (za - zb) * (za - zb));
  rcd2 =
      ((xc - xd) * (xc - xd) + (yc - yd) * (yc - yd) + (zc - zd) * (zc - zd));
  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 34.986836655249725 * eta1 * eta2 /
         sqrt(alphaa + alphab + alphac + alphad) *
         exp(-alphaa * alphab * rab2 * eta1 - alphac * alphad * rcd2 * eta2) *
         sum * norma * normb * normc * normd;
}


x86 assembly (clang, -O0):
<eri>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2a0,%rsp
movss  0x98(%rbp),%xmm8
mov    0x90(%rbp),%eax
mov    0x88(%rbp),%eax
mov    0x80(%rbp),%eax
movss  0x78(%rbp),%xmm8
movss  0x70(%rbp),%xmm8
movss  0x68(%rbp),%xmm8
movss  0x60(%rbp),%xmm8
movss  0x58(%rbp),%xmm8
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%eax
mov    0x40(%rbp),%eax
movss  0x38(%rbp),%xmm8
movss  0x30(%rbp),%xmm8
movss  0x28(%rbp),%xmm8
movss  0x20(%rbp),%xmm8
movss  0x18(%rbp),%xmm8
movss  0x10(%rbp),%xmm8
movss  %xmm0,-0x4(%rbp)
movss  %xmm1,-0x8(%rbp)
movss  %xmm2,-0xc(%rbp)
movss  %xmm3,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %esi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
movss  %xmm4,-0x20(%rbp)
movss  %xmm5,-0x24(%rbp)
movss  %xmm6,-0x28(%rbp)
movss  %xmm7,-0x2c(%rbp)
mov    %ecx,-0x30(%rbp)
mov    %r8d,-0x34(%rbp)
mov    %r9d,-0x38(%rbp)
movss  -0x20(%rbp),%xmm0
addss  0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xe0d(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x26c(%rbp)
ff
movss  0x58(%rbp),%xmm0
addss  0x98(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xde4(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x270(%rbp)
ff
movss  -0x20(%rbp),%xmm0
addss  0x18(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xdb6(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  0x58(%rbp),%xmm1
addss  0x98(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x20(%rbp),%xmm1
addss  0x18(%rbp),%xmm1
addss  0x58(%rbp),%xmm1
addss  0x98(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x274(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movss  -0x4(%rbp),%xmm2
movss  0x18(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x26c(%rbp),%xmm0
ff
movss  %xmm0,-0x250(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movss  -0x8(%rbp),%xmm2
movss  0x18(%rbp),%xmm1
mulss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x26c(%rbp),%xmm0
ff
movss  %xmm0,-0x254(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  0x18(%rbp),%xmm1
mulss  -0x2c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x26c(%rbp),%xmm0
ff
movss  %xmm0,-0x258(%rbp)
ff
movss  0x58(%rbp),%xmm0
movss  0x20(%rbp),%xmm2
movss  0x98(%rbp),%xmm1
mulss  0x60(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x270(%rbp),%xmm0
ff
movss  %xmm0,-0x25c(%rbp)
ff
movss  0x58(%rbp),%xmm0
movss  0x28(%rbp),%xmm2
movss  0x98(%rbp),%xmm1
mulss  0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x270(%rbp),%xmm0
ff
movss  %xmm0,-0x260(%rbp)
ff
movss  0x58(%rbp),%xmm0
movss  0x30(%rbp),%xmm2
movss  0x98(%rbp),%xmm1
mulss  0x70(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x270(%rbp),%xmm0
ff
movss  %xmm0,-0x264(%rbp)
ff
movss  -0x4(%rbp),%xmm1
subss  -0x24(%rbp),%xmm1
movss  -0x4(%rbp),%xmm2
subss  -0x24(%rbp),%xmm2
movss  -0x8(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  -0x8(%rbp),%xmm3
subss  -0x28(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0xc(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
subss  -0x2c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x244(%rbp)
ff
movss  0x20(%rbp),%xmm1
subss  0x60(%rbp),%xmm1
movss  0x20(%rbp),%xmm2
subss  0x60(%rbp),%xmm2
movss  0x28(%rbp),%xmm0
subss  0x68(%rbp),%xmm0
movss  0x28(%rbp),%xmm3
subss  0x68(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x30(%rbp),%xmm0
subss  0x70(%rbp),%xmm0
movss  0x30(%rbp),%xmm2
subss  0x70(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x248(%rbp)
ff
movss  -0x250(%rbp),%xmm1
ff
subss  -0x25c(%rbp),%xmm1
ff
movss  -0x250(%rbp),%xmm2
ff
subss  -0x25c(%rbp),%xmm2
ff
movss  -0x254(%rbp),%xmm0
ff
subss  -0x260(%rbp),%xmm0
ff
movss  -0x254(%rbp),%xmm3
ff
subss  -0x260(%rbp),%xmm3
ff
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x258(%rbp),%xmm0
ff
subss  -0x264(%rbp),%xmm0
ff
movss  -0x258(%rbp),%xmm2
ff
subss  -0x264(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24c(%rbp)
ff
movss  -0x24c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0xb19(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x274(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x284(%rbp)
ff
mov    -0x14(%rbp),%edi
add    -0x30(%rbp),%edi
add    0x40(%rbp),%edi
add    0x80(%rbp),%edi
add    -0x18(%rbp),%edi
add    -0x34(%rbp),%edi
add    0x48(%rbp),%edi
add    0x88(%rbp),%edi
add    -0x1c(%rbp),%edi
add    -0x38(%rbp),%edi
add    0x50(%rbp),%edi
add    0x90(%rbp),%edi
movss  -0x284(%rbp),%xmm0
ff
lea    -0x240(%rbp),%rsi
call   1030 <fgamma_set@plt>
lea    -0xc0(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x30(%rbp),%edx
mov    0x40(%rbp),%ecx
mov    0x80(%rbp),%r8d
movss  -0x250(%rbp),%xmm0
ff
movss  -0x4(%rbp),%xmm1
movss  -0x24(%rbp),%xmm2
movss  -0x25c(%rbp),%xmm3
ff
movss  0x20(%rbp),%xmm4
movss  0x60(%rbp),%xmm5
movss  -0x26c(%rbp),%xmm6
ff
movss  -0x270(%rbp),%xmm7
ff
movss  -0x274(%rbp),%xmm8
ff ff
movss  %xmm8,(%rsp)
call   1060 <eriB_1d@plt>
lea    -0x140(%rbp),%rdi
mov    -0x18(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    0x48(%rbp),%ecx
mov    0x88(%rbp),%r8d
movss  -0x254(%rbp),%xmm0
ff
movss  -0x8(%rbp),%xmm1
movss  -0x28(%rbp),%xmm2
movss  -0x260(%rbp),%xmm3
ff
movss  0x28(%rbp),%xmm4
movss  0x68(%rbp),%xmm5
movss  -0x26c(%rbp),%xmm6
ff
movss  -0x270(%rbp),%xmm7
ff
movss  -0x274(%rbp),%xmm8
ff ff
movss  %xmm8,(%rsp)
call   1060 <eriB_1d@plt>
lea    -0x1c0(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x38(%rbp),%edx
mov    0x50(%rbp),%ecx
mov    0x90(%rbp),%r8d
movss  -0x258(%rbp),%xmm0
ff
movss  -0xc(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movss  -0x264(%rbp),%xmm3
ff
movss  0x30(%rbp),%xmm4
movss  0x70(%rbp),%xmm5
movss  -0x26c(%rbp),%xmm6
ff
movss  -0x270(%rbp),%xmm7
ff
movss  -0x274(%rbp),%xmm8
ff ff
movss  %xmm8,(%rsp)
call   1060 <eriB_1d@plt>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x268(%rbp)
ff
movl   $0x0,-0x278(%rbp)
mov    -0x278(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x30(%rbp),%ecx
add    0x40(%rbp),%ecx
add    0x80(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1799 <eri+0x659>
movl   $0x0,-0x27c(%rbp)
mov    -0x27c(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    -0x34(%rbp),%ecx
add    0x48(%rbp),%ecx
add    0x88(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1780 <eri+0x640>
movl   $0x0,-0x280(%rbp)
mov    -0x280(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    -0x38(%rbp),%ecx
add    0x50(%rbp),%ecx
add    0x90(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1767 <eri+0x627>
movslq -0x278(%rbp),%rax
movss  -0xc0(%rbp,%rax,4),%xmm0
ff ff
movslq -0x27c(%rbp),%rax
mulss  -0x140(%rbp,%rax,4),%xmm0
ff ff
movslq -0x280(%rbp),%rax
mulss  -0x1c0(%rbp,%rax,4),%xmm0
ff ff
mov    -0x278(%rbp),%eax
add    -0x27c(%rbp),%eax
add    -0x280(%rbp),%eax
cltq
movss  -0x240(%rbp,%rax,4),%xmm2
ff ff
movss  -0x268(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x268(%rbp)
ff
mov    -0x280(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x280(%rbp)
jmp    16ce <eri+0x58e>
jmp    176c <eri+0x62c>
mov    -0x27c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x27c(%rbp)
jmp    16a4 <eri+0x564>
jmp    1785 <eri+0x645>
mov    -0x278(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x278(%rbp)
jmp    167a <eri+0x53a>
movss  -0x26c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x86b(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x270(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x298(%rbp)
ff
movss  -0x20(%rbp),%xmm0
addss  0x18(%rbp),%xmm0
addss  0x58(%rbp),%xmm0
addss  0x98(%rbp),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x298(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x290(%rbp)
ff
movss  -0x20(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  0x18(%rbp),%xmm0
mulss  -0x244(%rbp),%xmm0
ff
movss  -0x26c(%rbp),%xmm2
ff
movss  0x58(%rbp),%xmm1
mulss  0x98(%rbp),%xmm1
mulss  -0x248(%rbp),%xmm1
ff
mulss  -0x270(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x290(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movss  -0x268(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  0x38(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  0x78(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
add    $0x2a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eri>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x358,%rsp
mov    %r9,0x78(%rsp)
mov    %r8,0x10(%rsp)
mov    %rcx,0x38(%rsp)
movaps %xmm7,0x80(%rsp)
movaps %xmm6,0xb0(%rsp)
movaps %xmm5,0x90(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rsi,0x40(%rsp)
mov    %edi,%r14d
movss  %xmm3,0x1c(%rsp)
movaps %xmm2,0x60(%rsp)
movaps %xmm1,0xa0(%rsp)
movaps %xmm0,0xc0(%rsp)
movss  0x418(%rsp),%xmm8
movss  0x3d8(%rsp),%xmm9
movss  0x3a8(%rsp),%xmm10
movss  0x3a0(%rsp),%xmm11
movss  0x398(%rsp),%xmm12
movaps %xmm4,0x140(%rsp)
unpcklps %xmm9,%xmm4
unpcklps %xmm8,%xmm12
movaps %xmm0,%xmm13
unpcklps %xmm11,%xmm13
mulps  %xmm4,%xmm13
movaps %xmm1,%xmm11
unpcklps %xmm10,%xmm11
mulps  %xmm4,%xmm11
movss  0x3b0(%rsp),%xmm1
movaps %xmm2,%xmm3
unpcklps %xmm1,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm12,%xmm4
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
cvtss2sd %xmm1,%xmm1
xorps  %xmm2,%xmm2
cvtss2sd %xmm4,%xmm2
mulsd  0xdf6(%rip),%xmm2
mulsd  %xmm1,%xmm2
movaps 0xdcb(%rip),%xmm0
divps  %xmm4,%xmm0
addss  %xmm9,%xmm4
addss  %xmm8,%xmm4
movaps %xmm4,0x130(%rsp)
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
divsd  %xmm1,%xmm2
movss  0x3e0(%rsp),%xmm4
movaps %xmm5,%xmm1
unpcklps %xmm4,%xmm1
mulps  %xmm12,%xmm1
addps  %xmm1,%xmm13
movss  0x3e8(%rsp),%xmm4
movaps %xmm6,%xmm1
unpcklps %xmm4,%xmm1
mulps  %xmm12,%xmm1
addps  %xmm1,%xmm11
movss  0x3f0(%rsp),%xmm4
movaps %xmm7,%xmm1
unpcklps %xmm4,%xmm1
mulps  %xmm12,%xmm1
addps  %xmm1,%xmm3
mulps  %xmm0,%xmm13
movaps %xmm13,0xd0(%rsp)
mulps  %xmm0,%xmm11
movaps %xmm11,0xf0(%rsp)
movaps %xmm0,%xmm5
movaps %xmm0,0x20(%rsp)
movaps %xmm13,%xmm1
shufps $0x55,%xmm13,%xmm1
movaps %xmm1,0xe0(%rsp)
movaps %xmm13,%xmm0
subss  %xmm1,%xmm0
movaps %xmm11,%xmm4
shufps $0x55,%xmm11,%xmm4
movaps %xmm4,0x100(%rsp)
movaps %xmm11,%xmm1
subss  %xmm4,%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm4,%xmm4
cvtsd2ss %xmm2,%xmm4
movss  %xmm4,0x8(%rsp)
movaps %xmm3,%xmm1
mulps  %xmm5,%xmm1
movaps %xmm1,0x120(%rsp)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movaps %xmm2,0x110(%rsp)
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0xcea(%rip),%xmm0
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
mulsd  %xmm0,%xmm1
mov    0x410(%rsp),%r13d
mov    0x408(%rsp),%r15d
mov    0x400(%rsp),%ebp
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
lea    (%rcx,%r14,1),%ebx
add    0x3c0(%rsp),%ebx
add    %ebp,%ebx
lea    (%r8,%rsi,1),%r12d
lea    (%r12,%rdx,1),%edi
add    %r9d,%edi
add    0x3c8(%rsp),%edi
add    0x3d0(%rsp),%edi
add    %ebx,%edi
add    %r15d,%edi
add    %r13d,%edi
lea    0x1d0(%rsp),%rsi
call   1030 <fgamma_set@plt>
movaps 0x20(%rsp),%xmm6
movaps %xmm6,%xmm0
shufps $0x55,%xmm6,%xmm0
movaps %xmm0,%xmm7
movaps %xmm0,0x50(%rsp)
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%rsp)
lea    0x2d0(%rsp),%rdi
mov    %r14,0x70(%rsp)
mov    %r14d,%esi
mov    0x38(%rsp),%rdx
mov    0x3c0(%rsp),%ecx
mov    %ebp,%r8d
movaps 0xd0(%rsp),%xmm0
movaps 0xc0(%rsp),%xmm1
movaps 0x90(%rsp),%xmm2
movaps 0xe0(%rsp),%xmm3
movss  0x3a0(%rsp),%xmm4
movss  0x3e0(%rsp),%xmm5
call   1060 <eriB_1d@plt>
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%rsp)
lea    0x250(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    0x3c8(%rsp),%ecx
mov    %r15d,%r8d
movaps 0xf0(%rsp),%xmm0
movaps 0xa0(%rsp),%xmm1
movaps 0xb0(%rsp),%xmm2
movaps 0x100(%rsp),%xmm3
movss  0x3a8(%rsp),%xmm4
movss  0x3e8(%rsp),%xmm5
movaps 0x20(%rsp),%xmm6
movaps 0x50(%rsp),%xmm7
call   1060 <eriB_1d@plt>
movss  0x8(%rsp),%xmm0
movss  %xmm0,(%rsp)
lea    0x150(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x78(%rsp),%rdx
mov    %rdx,%r14
mov    0x3d0(%rsp),%ecx
mov    %r13d,%r8d
movaps 0x120(%rsp),%xmm0
movaps 0x60(%rsp),%xmm1
movaps 0x80(%rsp),%xmm2
movaps 0x110(%rsp),%xmm3
movss  0x3b0(%rsp),%xmm4
movss  0x3f0(%rsp),%xmm5
movaps 0x20(%rsp),%xmm6
movaps 0x50(%rsp),%xmm7
call   1060 <eriB_1d@plt>
test   %ebx,%ebx
js     161e <eri+0x4de>
mov    0x3c8(%rsp),%edx
add    %edx,%r12d
add    %r15d,%r12d
mov    %r14,%rax
mov    0x30(%rsp),%rcx
add    %ecx,%r14d
mov    0x3d0(%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    0x10(%rsp),%r15d
mov    0x40(%rsp),%rcx
lea    (%rcx,%r15,1),%esi
add    $0x1,%esi
add    0x3c0(%rsp),%ebp
add    0x38(%rsp),%ebp
mov    0x70(%rsp),%rax
lea    (%rax,%rbp,1),%r8d
add    $0x1,%r8d
mov    %r11d,%edx
and    $0xfffffffe,%edx
lea    0x1d4(%rsp),%r9
xorps  %xmm2,%xmm2
xor    %edi,%edi
jmp    1581 <eri+0x441>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdi
add    $0x4,%r9
cmp    %r8,%rdi
je     1621 <eri+0x4e1>
test   %r12d,%r12d
js     1570 <eri+0x430>
mov    %r9,%rbx
xor    %ecx,%ecx
jmp    159d <eri+0x45d>
nopl   (%rax)
add    $0x1,%rcx
add    $0x4,%rbx
cmp    %rsi,%rcx
je     1570 <eri+0x430>
test   %r14d,%r14d
js     1590 <eri+0x450>
movss  0x2d0(%rsp,%rdi,4),%xmm0
mulss  0x250(%rsp,%rcx,4),%xmm0
xor    %ebp,%ebp
test   %r10d,%r10d
je     15f6 <eri+0x4b6>
nopl   0x0(%rax,%rax,1)
movss  0x150(%rsp,%rbp,4),%xmm1
mulss  %xmm0,%xmm1
mulss  -0x4(%rbx,%rbp,4),%xmm1
addss  %xmm2,%xmm1
movss  0x154(%rsp,%rbp,4),%xmm2
mulss  %xmm0,%xmm2
mulss  (%rbx,%rbp,4),%xmm2
addss  %xmm1,%xmm2
add    $0x2,%rbp
cmp    %rbp,%rdx
jne    15c0 <eri+0x480>
test   $0x1,%r11b
je     1590 <eri+0x450>
lea    (%rcx,%rdi,1),%rax
mulss  0x150(%rsp,%rbp,4),%xmm0
add    %rbp,%rax
mulss  0x1d0(%rsp,%rax,4),%xmm0
addss  %xmm0,%xmm2
jmp    1590 <eri+0x450>
xorps  %xmm2,%xmm2
movss  %xmm2,0x10(%rsp)
movss  0x3b0(%rsp),%xmm3
movss  0x3f0(%rsp),%xmm0
subss  %xmm0,%xmm3
movss  0x3a0(%rsp),%xmm0
movss  0x3e0(%rsp),%xmm1
subss  %xmm1,%xmm0
movss  0x3a8(%rsp),%xmm1
movss  0x3e8(%rsp),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm3,%xmm3
addss  %xmm0,%xmm3
movaps %xmm3,0x40(%rsp)
movaps 0x60(%rsp),%xmm2
subss  0x80(%rsp),%xmm2
movaps 0xc0(%rsp),%xmm0
subss  0x90(%rsp),%xmm0
movaps 0xa0(%rsp),%xmm1
subss  0xb0(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
mulss  %xmm2,%xmm2
addss  %xmm0,%xmm2
movaps %xmm2,0x60(%rsp)
movaps 0x20(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  0x954(%rip),%xmm0
movaps 0x50(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movapd 0x130(%rsp),%xmm0
call   1050 <sqrt@plt>
movaps 0x140(%rsp),%xmm1
xorps  0x904(%rip),%xmm1
movsd  0x8(%rsp),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x8(%rsp)
movss  0x398(%rsp),%xmm0
mulss  %xmm0,%xmm1
mulss  0x60(%rsp),%xmm1
movss  0x418(%rsp),%xmm0
movss  0x3d8(%rsp),%xmm2
mulss  %xmm0,%xmm2
mulss  0x40(%rsp),%xmm2
mulss  0x50(%rsp),%xmm2
mulss  0x20(%rsp),%xmm1
subss  %xmm2,%xmm1
movaps %xmm1,%xmm0
call   1040 <exp@plt>
mulsd  0x8(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movss  0x1c(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
movss  0x390(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
movss  0x3b8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
movss  0x3f8(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
add    $0x358,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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