#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 const, int const, int const, int const,
                           double, double, double, double, double, double,
                           double, double, double);
double exp(double);
int /*<<< orphan*/ fgamma_set(int, double, double *);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
double sqrt(double);
void eri_list(double xa, double ya, double za, const int *la, const int *ma,
              const int *na, double alphaa, double xb, double yb, double zb,
              const int *lb, const int *mb, const int *nb, double alphab,
              double xc, double yc, double zc, const int *lc, const int *mc,
              const int *nc, double alphac, double xd, double yd, double zd,
              const int *ld, const int *md, const int *nd, double alphad,
              int maxSumL, int nItem, double *results) {
  char BxArray[256];
  char ByArray[256];
  char BzArray[256];
  double Bx[16 * 256];
  double By[16 * 256];
  double Bz[16 * 256];
  double *tBx, *tBy, *tBz;
  double F[4 * 4];
  double rab2, rcd2, rpq2, xp, yp, zp, xq, yq, zq;
  double eta1, eta2, zeta;
  int kX, kY, kZ;
  double sum;
  int i, n;
  double t;
  int mX, mY, mZ;
  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(maxSumL, t, F);
  t = 34.986836655249725 * eta1 * eta2 /
      sqrt(alphaa + alphab + alphac + alphad) *
      exp(-alphaa * alphab * rab2 * eta1 - alphac * alphad * rcd2 * eta2);
  memset(BxArray, 0, 256);
  memset(ByArray, 0, 256);
  memset(BzArray, 0, 256);
  for (n = 0; n < nItem; n++) {
    i = la[n] * 64 + lb[n] * 16 + lc[n] * 4 + ld[n];
    tBx = Bx + 16 * i;
    if (!BxArray[i]) {
      eriB_1d(tBx, la[n], lb[n], lc[n], ld[n], xp, xa, xb, xq, xc, xd, eta1,
              eta2, zeta);
      BxArray[i] = 1;
    }
    i = ma[n] * 64 + mb[n] * 16 + mc[n] * 4 + md[n];
    tBy = By + 16 * i;
    if (!ByArray[i]) {
      eriB_1d(tBy, ma[n], mb[n], mc[n], md[n], yp, ya, yb, yq, yc, yd, eta1,
              eta2, zeta);
      ByArray[i] = 1;
    }
    i = na[n] * 64 + nb[n] * 16 + nc[n] * 4 + nd[n];
    tBz = Bz + 16 * i;
    if (!BzArray[i]) {
      eriB_1d(tBz, na[n], nb[n], nc[n], nd[n], zp, za, zb, zq, zc, zd, eta1,
              eta2, zeta);
      BzArray[i] = 1;
    }
    sum = 0.0;
    mX = la[n] + lb[n] + lc[n] + ld[n] + 1;
    mY = ma[n] + mb[n] + mc[n] + md[n] + 1;
    mZ = na[n] + nb[n] + nc[n] + nd[n] + 1;
    for (kX = 0; kX < mX; kX++)
      for (kY = 0; kY < mY; kY++)
        for (kZ = 0; kZ < mZ; kZ++)
          sum += tBx[kX] * tBy[kY] * tBz[kZ] * F[kX + kY + kZ];
    results[n] = sum * t;
  }
}


x86 assembly (clang, -O0):
<eri_list>:
push   %rbp
mov    %rsp,%rbp
sub    $0x184c0,%rsp
mov    0x90(%rbp),%rax
mov    0x88(%rbp),%eax
mov    0x80(%rbp),%eax
movsd  0x78(%rbp),%xmm8
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
movsd  0x58(%rbp),%xmm8
movsd  0x50(%rbp),%xmm8
movsd  0x48(%rbp),%xmm8
movsd  0x40(%rbp),%xmm8
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
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    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
movsd  %xmm3,-0x38(%rbp)
movsd  %xmm4,-0x40(%rbp)
movsd  %xmm5,-0x48(%rbp)
movsd  %xmm6,-0x50(%rbp)
mov    %rcx,-0x58(%rbp)
mov    %r8,-0x60(%rbp)
mov    %r9,-0x68(%rbp)
movsd  %xmm7,-0x70(%rbp)
movsd  -0x38(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xe10(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18460(%rbp)
ff
movsd  0x40(%rbp),%xmm1
addsd  0x78(%rbp),%xmm1
movsd  0xdf2(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18468(%rbp)
ff
movsd  -0x38(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
movsd  0xdcc(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x40(%rbp),%xmm1
addsd  0x78(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x38(%rbp),%xmm1
addsd  -0x70(%rbp),%xmm1
addsd  0x40(%rbp),%xmm1
addsd  0x78(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18470(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x18460(%rbp),%xmm0
ff
movsd  %xmm0,-0x18430(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x18460(%rbp),%xmm0
ff
movsd  %xmm0,-0x18438(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x18460(%rbp),%xmm0
ff
movsd  %xmm0,-0x18440(%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  -0x18468(%rbp),%xmm0
ff
movsd  %xmm0,-0x18448(%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  -0x18468(%rbp),%xmm0
ff
movsd  %xmm0,-0x18450(%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  -0x18468(%rbp),%xmm0
ff
movsd  %xmm0,-0x18458(%rbp)
ff
movsd  -0x8(%rbp),%xmm1
subsd  -0x40(%rbp),%xmm1
movsd  -0x8(%rbp),%xmm2
subsd  -0x40(%rbp),%xmm2
movsd  -0x10(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm3
subsd  -0x48(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
subsd  -0x50(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18418(%rbp)
ff
movsd  0x10(%rbp),%xmm1
subsd  0x48(%rbp),%xmm1
movsd  0x10(%rbp),%xmm2
subsd  0x48(%rbp),%xmm2
movsd  0x18(%rbp),%xmm0
subsd  0x50(%rbp),%xmm0
movsd  0x18(%rbp),%xmm3
subsd  0x50(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%rbp),%xmm0
subsd  0x58(%rbp),%xmm0
movsd  0x20(%rbp),%xmm2
subsd  0x58(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18420(%rbp)
ff
movsd  -0x18430(%rbp),%xmm1
ff
subsd  -0x18448(%rbp),%xmm1
ff
movsd  -0x18430(%rbp),%xmm2
ff
subsd  -0x18448(%rbp),%xmm2
ff
movsd  -0x18438(%rbp),%xmm0
ff
subsd  -0x18450(%rbp),%xmm0
ff
movsd  -0x18438(%rbp),%xmm3
ff
subsd  -0x18450(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x18440(%rbp),%xmm0
ff
subsd  -0x18458(%rbp),%xmm0
ff
movsd  -0x18440(%rbp),%xmm2
ff
subsd  -0x18458(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18428(%rbp)
ff
movsd  0xb56(%rip),%xmm0
mulsd  -0x18428(%rbp),%xmm0
ff
mulsd  -0x18470(%rbp),%xmm0
ff
movsd  %xmm0,-0x18498(%rbp)
ff
mov    0x80(%rbp),%edi
movsd  -0x18498(%rbp),%xmm0
ff
lea    -0x18410(%rbp),%rsi
call   1030 <fgamma_set@plt>
movsd  0xb14(%rip),%xmm0
mulsd  -0x18460(%rbp),%xmm0
ff
mulsd  -0x18468(%rbp),%xmm0
ff
movsd  %xmm0,-0x184b8(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
addsd  -0x70(%rbp),%xmm0
addsd  0x40(%rbp),%xmm0
addsd  0x78(%rbp),%xmm0
call   1060 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x184b8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x184b0(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x70(%rbp),%xmm0
mulsd  -0x18418(%rbp),%xmm0
ff
movsd  -0x18460(%rbp),%xmm2
ff
movsd  0x40(%rbp),%xmm1
mulsd  0x78(%rbp),%xmm1
mulsd  -0x18420(%rbp),%xmm1
ff
mulsd  -0x18468(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1050 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x184b0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x18498(%rbp)
ff
lea    -0x170(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
lea    -0x270(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
lea    -0x370(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
movl   $0x0,-0x18490(%rbp)
mov    -0x18490(%rbp),%eax
cmp    0x88(%rbp),%eax
jge    1b64 <eri_list+0xa14>
mov    -0x20(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x6,%eax
mov    -0x58(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    0x28(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    0x60(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1848c(%rbp)
lea    -0x8370(%rbp),%rax
mov    -0x1848c(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18378(%rbp)
movslq -0x1848c(%rbp),%rax
cmpb   $0x0,-0x170(%rbp,%rax,1)
jne    1727 <eri_list+0x5d7>
mov    -0x18378(%rbp),%rdi
mov    -0x20(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x58(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x28(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    0x60(%rbp),%rax
movslq -0x18490(%rbp),%r8
mov    (%rax,%r8,4),%r8d
movsd  -0x18430(%rbp),%xmm0
ff
movsd  -0x8(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0x18448(%rbp),%xmm3
ff
movsd  0x10(%rbp),%xmm4
movsd  0x48(%rbp),%xmm5
movsd  -0x18460(%rbp),%xmm6
ff
movsd  -0x18468(%rbp),%xmm7
ff
movsd  -0x18470(%rbp),%xmm8
fe ff
movsd  %xmm8,(%rsp)
call   1070 <eriB_1d@plt>
movslq -0x1848c(%rbp),%rax
movb   $0x1,-0x170(%rbp,%rax,1)
01
mov    -0x28(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x6,%eax
mov    -0x60(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    0x30(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    0x68(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1848c(%rbp)
lea    -0x10370(%rbp),%rax
mov    -0x1848c(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18380(%rbp)
movslq -0x1848c(%rbp),%rax
cmpb   $0x0,-0x270(%rbp,%rax,1)
jne    183f <eri_list+0x6ef>
mov    -0x18380(%rbp),%rdi
mov    -0x28(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x60(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x30(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    0x68(%rbp),%rax
movslq -0x18490(%rbp),%r8
mov    (%rax,%r8,4),%r8d
movsd  -0x18438(%rbp),%xmm0
ff
movsd  -0x10(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0x18450(%rbp),%xmm3
ff
movsd  0x18(%rbp),%xmm4
movsd  0x50(%rbp),%xmm5
movsd  -0x18460(%rbp),%xmm6
ff
movsd  -0x18468(%rbp),%xmm7
ff
movsd  -0x18470(%rbp),%xmm8
fe ff
movsd  %xmm8,(%rsp)
call   1070 <eriB_1d@plt>
movslq -0x1848c(%rbp),%rax
movb   $0x1,-0x270(%rbp,%rax,1)
01
mov    -0x30(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
shl    $0x6,%eax
mov    -0x68(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x4,%ecx
add    %ecx,%eax
mov    0x38(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    0x70(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1848c(%rbp)
lea    -0x18370(%rbp),%rax
mov    -0x1848c(%rbp),%ecx
shl    $0x4,%ecx
movslq %ecx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x18388(%rbp)
movslq -0x1848c(%rbp),%rax
cmpb   $0x0,-0x370(%rbp,%rax,1)
jne    1957 <eri_list+0x807>
mov    -0x18388(%rbp),%rdi
mov    -0x30(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x68(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x38(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    0x70(%rbp),%rax
movslq -0x18490(%rbp),%r8
mov    (%rax,%r8,4),%r8d
movsd  -0x18440(%rbp),%xmm0
ff
movsd  -0x18(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x18458(%rbp),%xmm3
ff
movsd  0x20(%rbp),%xmm4
movsd  0x58(%rbp),%xmm5
movsd  -0x18460(%rbp),%xmm6
ff
movsd  -0x18468(%rbp),%xmm7
ff
movsd  -0x18470(%rbp),%xmm8
fe ff
movsd  %xmm8,(%rsp)
call   1070 <eriB_1d@plt>
movslq -0x1848c(%rbp),%rax
movb   $0x1,-0x370(%rbp,%rax,1)
01
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x18488(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x58(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    0x28(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    0x60(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
add    $0x1,%eax
mov    %eax,-0x1849c(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x60(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    0x30(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    0x68(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
add    $0x1,%eax
mov    %eax,-0x184a0(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x18490(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x68(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    0x38(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    0x70(%rbp),%rcx
movslq -0x18490(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
add    $0x1,%eax
mov    %eax,-0x184a4(%rbp)
movl   $0x0,-0x18474(%rbp)
mov    -0x18474(%rbp),%eax
cmp    -0x1849c(%rbp),%eax
jge    1b2d <eri_list+0x9dd>
movl   $0x0,-0x18478(%rbp)
mov    -0x18478(%rbp),%eax
cmp    -0x184a0(%rbp),%eax
jge    1b14 <eri_list+0x9c4>
movl   $0x0,-0x1847c(%rbp)
mov    -0x1847c(%rbp),%eax
cmp    -0x184a4(%rbp),%eax
jge    1afb <eri_list+0x9ab>
mov    -0x18378(%rbp),%rax
movslq -0x18474(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18380(%rbp),%rax
movslq -0x18478(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18388(%rbp),%rax
movslq -0x1847c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18474(%rbp),%eax
add    -0x18478(%rbp),%eax
add    -0x1847c(%rbp),%eax
cltq
movsd  -0x18410(%rbp,%rax,8),%xmm2
fe ff
movsd  -0x18488(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x18488(%rbp)
ff
mov    -0x1847c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1847c(%rbp)
jmp    1a67 <eri_list+0x917>
jmp    1b00 <eri_list+0x9b0>
mov    -0x18478(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18478(%rbp)
jmp    1a4b <eri_list+0x8fb>
jmp    1b19 <eri_list+0x9c9>
mov    -0x18474(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18474(%rbp)
jmp    1a2f <eri_list+0x8df>
movsd  -0x18488(%rbp),%xmm0
ff
mulsd  -0x18498(%rbp),%xmm0
ff
mov    0x90(%rbp),%rax
movslq -0x18490(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18490(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18490(%rbp)
jmp    15fd <eri_list+0x4ad>
add    $0x184c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<eri_list>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18518,%rsp
mov    %r9,%r13
mov    %r8,0x68(%rsp)
mov    %rcx,0x78(%rsp)
movapd %xmm6,%xmm12
movapd %xmm5,%xmm9
movapd %xmm4,%xmm6
mov    %rdx,%rbp
mov    %rsi,0x60(%rsp)
mov    %rdi,0x70(%rsp)
movapd %xmm2,%xmm5
movsd  0x185b8(%rsp),%xmm2
movsd  0x18580(%rsp),%xmm4
movsd  0x18558(%rsp),%xmm8
movsd  0x18550(%rsp),%xmm13
movapd %xmm3,0x30(%rsp)
unpcklpd %xmm4,%xmm3
movapd %xmm7,0x50(%rsp)
movapd %xmm7,%xmm10
unpcklpd %xmm2,%xmm10
movapd %xmm0,%xmm11
unpcklpd %xmm13,%xmm11
mulpd  %xmm3,%xmm11
movapd %xmm1,%xmm13
unpcklpd %xmm8,%xmm13
mulpd  %xmm3,%xmm13
movsd  0x18560(%rsp),%xmm2
movapd %xmm5,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm3,%xmm7
movapd %xmm3,%xmm8
addpd  %xmm10,%xmm8
movsd  0xe0e(%rip),%xmm3
mulsd  %xmm8,%xmm3
movapd %xmm8,%xmm14
unpckhpd %xmm8,%xmm14
mulsd  %xmm3,%xmm14
movsd  0x18588(%rsp),%xmm15
movapd %xmm6,%xmm3
unpcklpd %xmm15,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm11
movsd  0x18590(%rsp),%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm2,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm13
movsd  0x18598(%rsp),%xmm4
movapd %xmm12,%xmm3
unpcklpd %xmm4,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm7
movapd %xmm0,0x120(%rsp)
movapd %xmm6,0x150(%rsp)
subsd  %xmm6,%xmm0
movapd %xmm1,0x130(%rsp)
movapd %xmm9,0x160(%rsp)
subsd  %xmm9,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm5,0x140(%rsp)
movapd %xmm12,0x170(%rsp)
subsd  %xmm12,%xmm5
mulsd  %xmm5,%xmm5
addsd  %xmm0,%xmm5
movapd %xmm5,0xa0(%rsp)
movsd  0x18550(%rsp),%xmm0
subsd  %xmm15,%xmm0
movsd  0x18558(%rsp),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x18560(%rsp),%xmm12
subsd  %xmm4,%xmm12
mulsd  %xmm12,%xmm12
addsd  %xmm0,%xmm12
movapd %xmm12,0x80(%rsp)
movapd 0xcd1(%rip),%xmm0
divpd  %xmm8,%xmm0
mulpd  %xmm0,%xmm11
mulpd  %xmm0,%xmm13
movapd %xmm0,%xmm3
movapd %xmm0,0x20(%rsp)
movapd %xmm11,%xmm0
unpckhpd %xmm11,%xmm0
movapd %xmm11,0x110(%rsp)
movapd %xmm11,%xmm1
movapd %xmm0,0xe0(%rsp)
subsd  %xmm0,%xmm1
movapd %xmm13,%xmm2
unpckhpd %xmm13,%xmm2
movapd %xmm13,0x100(%rsp)
movapd %xmm13,%xmm0
movapd %xmm2,0xd0(%rsp)
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulpd  %xmm3,%xmm7
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
movapd %xmm7,0xf0(%rsp)
movapd %xmm7,%xmm0
movapd %xmm2,0xc0(%rsp)
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x185c8(%rsp),%ebx
mov    0x185c0(%rsp),%edi
movsd  0x18580(%rsp),%xmm1
addsd  %xmm1,%xmm8
movsd  0x185b8(%rsp),%xmm1
addsd  %xmm1,%xmm8
movapd %xmm8,0x10(%rsp)
divsd  %xmm8,%xmm14
mulsd  0xc1c(%rip),%xmm0
movapd %xmm14,0x90(%rsp)
mulsd  %xmm14,%xmm0
lea    0x190(%rsp),%rsi
call   1030 <fgamma_set@plt>
movapd 0x20(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x40(%rsp)
xorpd  %xmm0,%xmm0
movapd 0x10(%rsp),%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm1,%xmm0
jb     1452 <eri_list+0x302>
sqrtsd %xmm0,%xmm0
jmp    1457 <eri_list+0x307>
call   1060 <sqrt@plt>
movsd  %xmm0,0x10(%rsp)
movapd 0x30(%rsp),%xmm0
xorpd  0xba5(%rip),%xmm0
mulsd  0x50(%rsp),%xmm0
movapd 0xa0(%rsp),%xmm2
mulsd  %xmm0,%xmm2
movsd  0x185b8(%rsp),%xmm0
movsd  0x18580(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd 0x80(%rsp),%xmm0
mulsd  %xmm1,%xmm0
mulsd  0x40(%rsp),%xmm0
mulsd  0x20(%rsp),%xmm2
subsd  %xmm0,%xmm2
movapd %xmm2,%xmm0
call   1050 <exp@plt>
movsd  %xmm0,0x50(%rsp)
lea    0x410(%rsp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
lea    0x310(%rsp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
lea    0x210(%rsp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1040 <memset@plt>
test   %ebx,%ebx
jle    1949 <eri_list+0x7f9>
movapd 0x20(%rsp),%xmm0
mulsd  0xb1e(%rip),%xmm0
mulsd  0x40(%rsp),%xmm0
divsd  0x10(%rsp),%xmm0
mulsd  0x50(%rsp),%xmm0
movapd %xmm0,0x180(%rsp)
mov    %ebx,%eax
mov    %rax,0xb8(%rsp)
xor    %r9d,%r9d
mov    %r13,0x80(%rsp)
mov    %rbp,0x10(%rsp)
jmp    158f <eri_list+0x43f>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mulsd  0x180(%rsp),%xmm0
mov    0x185d0(%rsp),%rax
mov    0x30(%rsp),%r9
movsd  %xmm0,(%rax,%r9,8)
add    $0x1,%r9
cmp    0xb8(%rsp),%r9
mov    0x80(%rsp),%r13
mov    0x10(%rsp),%rbp
je     1949 <eri_list+0x7f9>
mov    0x70(%rsp),%rax
mov    (%rax,%r9,4),%esi
mov    %esi,%eax
shl    $0x6,%eax
mov    0x78(%rsp),%rcx
mov    (%rcx,%r9,4),%edx
mov    %edx,%edi
shl    $0x4,%edi
add    %eax,%edi
mov    0x18568(%rsp),%rax
mov    (%rax,%r9,4),%ecx
lea    (%rdi,%rcx,4),%eax
mov    0x185a0(%rsp),%rdi
mov    (%rdi,%r9,4),%r8d
add    %r8d,%eax
movslq %eax,%rbx
shl    $0x4,%eax
cltq
lea    (%rsp,%rax,8),%r14
add    $0x10510,%r14
cmpb   $0x0,0x410(%rsp,%rbx,1)
mov    %r9,0x30(%rsp)
jne    1651 <eri_list+0x501>
movaps 0x90(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %r14,%rdi
movapd 0x110(%rsp),%xmm0
movapd 0x120(%rsp),%xmm1
movapd 0x150(%rsp),%xmm2
movapd 0xe0(%rsp),%xmm3
movsd  0x18550(%rsp),%xmm4
movsd  0x18588(%rsp),%xmm5
movapd 0x20(%rsp),%xmm6
movapd 0x40(%rsp),%xmm7
call   1070 <eriB_1d@plt>
mov    0x30(%rsp),%r9
movb   $0x1,0x410(%rsp,%rbx,1)
01
mov    0x60(%rsp),%rax
mov    (%rax,%r9,4),%esi
mov    %esi,%eax
shl    $0x6,%eax
mov    0x68(%rsp),%rcx
mov    (%rcx,%r9,4),%edx
mov    %edx,%edi
shl    $0x4,%edi
add    %eax,%edi
mov    0x18570(%rsp),%rax
mov    (%rax,%r9,4),%ecx
lea    (%rdi,%rcx,4),%eax
mov    0x185a8(%rsp),%rdi
mov    (%rdi,%r9,4),%r8d
add    %r8d,%eax
movslq %eax,%rbx
shl    $0x4,%eax
cltq
lea    (%rsp,%rax,8),%r12
add    $0x8510,%r12
cmpb   $0x0,0x310(%rsp,%rbx,1)
jne    170e <eri_list+0x5be>
movaps 0x90(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %r12,%rdi
movapd 0x100(%rsp),%xmm0
movapd 0x130(%rsp),%xmm1
movapd 0x160(%rsp),%xmm2
movapd 0xd0(%rsp),%xmm3
movsd  0x18558(%rsp),%xmm4
movsd  0x18590(%rsp),%xmm5
movapd 0x20(%rsp),%xmm6
movapd 0x40(%rsp),%xmm7
call   1070 <eriB_1d@plt>
mov    0x30(%rsp),%r9
movb   $0x1,0x310(%rsp,%rbx,1)
01
mov    0x0(%rbp,%r9,4),%esi
mov    %esi,%eax
shl    $0x6,%eax
mov    0x0(%r13,%r9,4),%edx
mov    %edx,%edi
shl    $0x4,%edi
add    %eax,%edi
mov    0x18578(%rsp),%rax
mov    (%rax,%r9,4),%ecx
lea    (%rdi,%rcx,4),%eax
mov    0x185b0(%rsp),%rdi
mov    (%rdi,%r9,4),%r8d
add    %r8d,%eax
movslq %eax,%rbx
shl    $0x4,%eax
cltq
lea    (%rsp,%rax,8),%r15
add    $0x510,%r15
cmpb   $0x0,0x210(%rsp,%rbx,1)
mov    %rax,0xa0(%rsp)
jne    17f1 <eri_list+0x6a1>
movaps 0x90(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %r15,%rdi
movapd 0xf0(%rsp),%xmm0
movapd 0x140(%rsp),%xmm1
movapd 0x170(%rsp),%xmm2
movapd 0xc0(%rsp),%xmm3
movsd  0x18560(%rsp),%xmm4
movsd  0x18598(%rsp),%xmm5
movapd 0x20(%rsp),%xmm6
movapd 0x40(%rsp),%xmm7
call   1070 <eriB_1d@plt>
mov    0x30(%rsp),%r9
movb   $0x1,0x210(%rsp,%rbx,1)
01
mov    0x0(%rbp,%r9,4),%esi
mov    0x0(%r13,%r9,4),%edx
mov    0x18578(%rsp),%rax
mov    (%rax,%r9,4),%ecx
mov    0x185b0(%rsp),%rax
mov    (%rax,%r9,4),%r8d
mov    0x70(%rsp),%rax
mov    (%rax,%r9,4),%eax
mov    0x78(%rsp),%rdi
add    (%rdi,%r9,4),%eax
mov    0x18568(%rsp),%rdi
add    (%rdi,%r9,4),%eax
mov    0x185a0(%rsp),%rdi
mov    (%rdi,%r9,4),%edi
mov    %eax,%ebx
add    %edi,%ebx
js     1550 <eri_list+0x400>
mov    0x60(%rsp),%rbp
mov    0x0(%rbp,%r9,4),%ebp
mov    0x185a8(%rsp),%rbx
mov    (%rbx,%r9,4),%r10d
add    %esi,%edx
add    %ecx,%edx
lea    (%rdx,%r8,1),%r11d
mov    0x68(%rsp),%rcx
add    (%rcx,%r9,4),%ebp
mov    0x18570(%rsp),%rcx
add    (%rcx,%r9,4),%ebp
lea    (%r10,%rbp,1),%ecx
mov    %ecx,0x50(%rsp)
lea    (%r8,%rdx,1),%ebx
add    $0x1,%ebx
lea    (%r10,%rbp,1),%esi
add    $0x1,%esi
lea    (%rdi,%rax,1),%r8d
add    $0x1,%r8d
mov    %ebx,%edx
and    $0xfffffffe,%edx
lea    0x518(%rsp),%rax
mov    0xa0(%rsp),%rcx
lea    (%rax,%rcx,8),%rbp
xorpd  %xmm0,%xmm0
lea    0x198(%rsp),%r10
xor    %edi,%edi
jmp    18b1 <eri_list+0x761>
nop
add    $0x1,%rdi
add    $0x8,%r10
cmp    %r8,%rdi
je     1554 <eri_list+0x404>
cmpl   $0x0,0x50(%rsp)
js     18a0 <eri_list+0x750>
mov    %r10,%rcx
xor    %eax,%eax
jmp    18cd <eri_list+0x77d>
nop
add    $0x1,%rax
add    $0x8,%rcx
cmp    %rsi,%rax
je     18a0 <eri_list+0x750>
test   %r11d,%r11d
js     18c0 <eri_list+0x770>
movsd  (%r14,%rdi,8),%xmm1
mulsd  (%r12,%rax,8),%xmm1
xor    %r13d,%r13d
cmp    $0x1,%ebx
je     1924 <eri_list+0x7d4>
cs nopw 0x0(%rax,%rax,1)
movsd  -0x8(%rbp,%r13,8),%xmm2
mulsd  %xmm1,%xmm2
mulsd  -0x8(%rcx,%r13,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x0(%rbp,%r13,8),%xmm0
mulsd  %xmm1,%xmm0
mulsd  (%rcx,%r13,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%r13
cmp    %r13,%rdx
jne    18f0 <eri_list+0x7a0>
test   $0x1,%bl
je     18c0 <eri_list+0x770>
lea    (%rax,%rdi,1),%r9
mulsd  (%r15,%r13,8),%xmm1
add    %r13,%r9
mulsd  0x190(%rsp,%r9,8),%xmm1
addsd  %xmm1,%xmm0
jmp    18c0 <eri_list+0x770>
add    $0x18518,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @eri_list(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, i32 %28, i32 %29, double* %30) {
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca i32*
%36 = alloca i32*
%37 = alloca i32*
%38 = alloca double
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca i32*
%43 = alloca i32*
%44 = alloca i32*
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca double
%49 = alloca i32*
%50 = alloca i32*
%51 = alloca i32*
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca i32*
%57 = alloca i32*
%58 = alloca i32*
%59 = alloca double
%60 = alloca i32
%61 = alloca i32
%62 = alloca double*
%63 = alloca [256 x i8]
%64 = alloca [256 x i8]
%65 = alloca [256 x i8]
%66 = alloca [4096 x double]
%67 = alloca [4096 x double]
%68 = alloca [4096 x double]
%69 = alloca double*
%70 = alloca double*
%71 = alloca double*
%72 = alloca [16 x double]
%73 = alloca double
%74 = alloca double
%75 = alloca double
%76 = alloca double
%77 = alloca double
%78 = alloca double
%79 = alloca double
%80 = alloca double
%81 = alloca double
%82 = alloca double
%83 = alloca double
%84 = alloca double
%85 = alloca i32
%86 = alloca i32
%87 = alloca i32
%88 = alloca double
%89 = alloca i32
%90 = alloca i32
%91 = alloca double
%92 = alloca i32
%93 = alloca i32
%94 = alloca i32
store double %0, double* %32
store double %1, double* %33
store double %2, double* %34
store i32* %3, i32** %35
store i32* %4, i32** %36
store i32* %5, i32** %37
store double %6, double* %38
store double %7, double* %39
store double %8, double* %40
store double %9, double* %41
store i32* %10, i32** %42
store i32* %11, i32** %43
store i32* %12, i32** %44
store double %13, double* %45
store double %14, double* %46
store double %15, double* %47
store double %16, double* %48
store i32* %17, i32** %49
store i32* %18, i32** %50
store i32* %19, i32** %51
store double %20, double* %52
store double %21, double* %53
store double %22, double* %54
store double %23, double* %55
store i32* %24, i32** %56
store i32* %25, i32** %57
store i32* %26, i32** %58
store double %27, double* %59
store i32 %28, i32* %60
store i32 %29, i32* %61
store double* %30, double** %62
%95 = load double, double* %38
%96 = load double, double* %45
%97 = fadd double %95, %96
%98 = fdiv double 1.000000e+00, %97
store double %98, double* %82
%99 = load double, double* %52
%100 = load double, double* %59
%101 = fadd double %99, %100
%102 = fdiv double 1.000000e+00, %101
store double %102, double* %83
%103 = load double, double* %38
%104 = load double, double* %45
%105 = fadd double %103, %104
%106 = fmul double 4.000000e+00, %105
%107 = load double, double* %52
%108 = load double, double* %59
%109 = fadd double %107, %108
%110 = fmul double %106, %109
%111 = load double, double* %38
%112 = load double, double* %45
%113 = fadd double %111, %112
%114 = load double, double* %52
%115 = fadd double %113, %114
%116 = load double, double* %59
%117 = fadd double %115, %116
%118 = fdiv double %110, %117
store double %118, double* %84
%119 = load double, double* %38
%120 = load double, double* %32
%121 = load double, double* %45
%122 = load double, double* %39
%123 = fmul double %121, %122
%124 = call double @llvm.fmuladd.f64(double %119, double %120, double %123)
%125 = load double, double* %82
%126 = fmul double %124, %125
store double %126, double* %76
%127 = load double, double* %38
%128 = load double, double* %33
%129 = load double, double* %45
%130 = load double, double* %40
%131 = fmul double %129, %130
%132 = call double @llvm.fmuladd.f64(double %127, double %128, double %131)
%133 = load double, double* %82
%134 = fmul double %132, %133
store double %134, double* %77
%135 = load double, double* %38
%136 = load double, double* %34
%137 = load double, double* %45
%138 = load double, double* %41
%139 = fmul double %137, %138
%140 = call double @llvm.fmuladd.f64(double %135, double %136, double %139)
%141 = load double, double* %82
%142 = fmul double %140, %141
store double %142, double* %78
%143 = load double, double* %52
%144 = load double, double* %46
%145 = load double, double* %59
%146 = load double, double* %53
%147 = fmul double %145, %146
%148 = call double @llvm.fmuladd.f64(double %143, double %144, double %147)
%149 = load double, double* %83
%150 = fmul double %148, %149
store double %150, double* %79
%151 = load double, double* %52
%152 = load double, double* %47
%153 = load double, double* %59
%154 = load double, double* %54
%155 = fmul double %153, %154
%156 = call double @llvm.fmuladd.f64(double %151, double %152, double %155)
%157 = load double, double* %83
%158 = fmul double %156, %157
store double %158, double* %80
%159 = load double, double* %52
%160 = load double, double* %48
%161 = load double, double* %59
%162 = load double, double* %55
%163 = fmul double %161, %162
%164 = call double @llvm.fmuladd.f64(double %159, double %160, double %163)
%165 = load double, double* %83
%166 = fmul double %164, %165
store double %166, double* %81
%167 = load double, double* %32
%168 = load double, double* %39
%169 = fsub double %167, %168
%170 = load double, double* %32
%171 = load double, double* %39
%172 = fsub double %170, %171
%173 = load double, double* %33
%174 = load double, double* %40
%175 = fsub double %173, %174
%176 = load double, double* %33
%177 = load double, double* %40
%178 = fsub double %176, %177
%179 = fmul double %175, %178
%180 = call double @llvm.fmuladd.f64(double %169, double %172, double %179)
%181 = load double, double* %34
%182 = load double, double* %41
%183 = fsub double %181, %182
%184 = load double, double* %34
%185 = load double, double* %41
%186 = fsub double %184, %185
%187 = call double @llvm.fmuladd.f64(double %183, double %186, double %180)
store double %187, double* %73
%188 = load double, double* %46
%189 = load double, double* %53
%190 = fsub double %188, %189
%191 = load double, double* %46
%192 = load double, double* %53
%193 = fsub double %191, %192
%194 = load double, double* %47
%195 = load double, double* %54
%196 = fsub double %194, %195
%197 = load double, double* %47
%198 = load double, double* %54
%199 = fsub double %197, %198
%200 = fmul double %196, %199
%201 = call double @llvm.fmuladd.f64(double %190, double %193, double %200)
%202 = load double, double* %48
%203 = load double, double* %55
%204 = fsub double %202, %203
%205 = load double, double* %48
%206 = load double, double* %55
%207 = fsub double %205, %206
%208 = call double @llvm.fmuladd.f64(double %204, double %207, double %201)
store double %208, double* %74
%209 = load double, double* %76
%210 = load double, double* %79
%211 = fsub double %209, %210
%212 = load double, double* %76
%213 = load double, double* %79
%214 = fsub double %212, %213
%215 = load double, double* %77
%216 = load double, double* %80
%217 = fsub double %215, %216
%218 = load double, double* %77
%219 = load double, double* %80
%220 = fsub double %218, %219
%221 = fmul double %217, %220
%222 = call double @llvm.fmuladd.f64(double %211, double %214, double %221)
%223 = load double, double* %78
%224 = load double, double* %81
%225 = fsub double %223, %224
%226 = load double, double* %78
%227 = load double, double* %81
%228 = fsub double %226, %227
%229 = call double @llvm.fmuladd.f64(double %225, double %228, double %222)
store double %229, double* %75
%230 = load double, double* %75
%231 = fmul double 2.500000e-01, %230
%232 = load double, double* %84
%233 = fmul double %231, %232
store double %233, double* %91
%234 = load i32, i32* %60
%235 = load double, double* %91
%236 = getelementptr inbounds [16 x double], [16 x double]* %72, i64 0, i64 0
%237 = call i32 @fgamma_set(i32 %234, double %235, double* %236)
%238 = load double, double* %82
%239 = fmul double 0x40417E50A9DC6553, %238
%240 = load double, double* %83
%241 = fmul double %239, %240
%242 = load double, double* %38
%243 = load double, double* %45
%244 = fadd double %242, %243
%245 = load double, double* %52
%246 = fadd double %244, %245
%247 = load double, double* %59
%248 = fadd double %246, %247
%249 = call double @sqrt(double %248)
%250 = fdiv double %241, %249
%251 = load double, double* %38
%252 = fneg double %251
%253 = load double, double* %45
%254 = fmul double %252, %253
%255 = load double, double* %73
%256 = fmul double %254, %255
%257 = load double, double* %82
%258 = load double, double* %52
%259 = load double, double* %59
%260 = fmul double %258, %259
%261 = load double, double* %74
%262 = fmul double %260, %261
%263 = load double, double* %83
%264 = fmul double %262, %263
%265 = fneg double %264
%266 = call double @llvm.fmuladd.f64(double %256, double %257, double %265)
%267 = call double @exp(double %266)
%268 = fmul double %250, %267
store double %268, double* %91
%269 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 0
%270 = call i32 @memset(i8* %269, i32 0, i32 256)
%271 = getelementptr inbounds [256 x i8], [256 x i8]* %64, i64 0, i64 0
%272 = call i32 @memset(i8* %271, i32 0, i32 256)
%273 = getelementptr inbounds [256 x i8], [256 x i8]* %65, i64 0, i64 0
%274 = call i32 @memset(i8* %273, i32 0, i32 256)
store i32 0, i32* %90
br label %275
275: ; preds = %629, %31
%276 = load i32, i32* %90
%277 = load i32, i32* %61
%278 = icmp slt i32 %276, %277
br i1 %278, label %279, label %632
279: ; preds = %275
%280 = load i32*, i32** %35
%281 = load i32, i32* %90
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i32, i32* %280, i64 %282
%284 = load i32, i32* %283
%285 = mul nsw i32 %284, 64
%286 = load i32*, i32** %42
%287 = load i32, i32* %90
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds i32, i32* %286, i64 %288
%290 = load i32, i32* %289
%291 = mul nsw i32 %290, 16
%292 = add nsw i32 %285, %291
%293 = load i32*, i32** %49
%294 = load i32, i32* %90
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i32, i32* %293, i64 %295
%297 = load i32, i32* %296
%298 = mul nsw i32 %297, 4
%299 = add nsw i32 %292, %298
%300 = load i32*, i32** %56
%301 = load i32, i32* %90
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i32, i32* %300, i64 %302
%304 = load i32, i32* %303
%305 = add nsw i32 %299, %304
store i32 %305, i32* %89
%306 = getelementptr inbounds [4096 x double], [4096 x double]* %66, i64 0, i64 0
%307 = load i32, i32* %89
%308 = mul nsw i32 16, %307
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %306, i64 %309
store double* %310, double** %69
%311 = load i32, i32* %89
%312 = sext i32 %311 to i64
%313 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 %312
%314 = load i8, i8* %313
%315 = icmp ne i8 %314, 0
br i1 %315, label %351, label %316
316: ; preds = %279
%317 = load double*, double** %69
%318 = load i32*, i32** %35
%319 = load i32, i32* %90
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds i32, i32* %318, i64 %320
%322 = load i32, i32* %321
%323 = load i32*, i32** %42
%324 = load i32, i32* %90
%325 = sext i32 %324 to i64
%326 = getelementptr inbounds i32, i32* %323, i64 %325
%327 = load i32, i32* %326
%328 = load i32*, i32** %49
%329 = load i32, i32* %90
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds i32, i32* %328, i64 %330
%332 = load i32, i32* %331
%333 = load i32*, i32** %56
%334 = load i32, i32* %90
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i32, i32* %333, i64 %335
%337 = load i32, i32* %336
%338 = load double, double* %76
%339 = load double, double* %32
%340 = load double, double* %39
%341 = load double, double* %79
%342 = load double, double* %46
%343 = load double, double* %53
%344 = load double, double* %82
%345 = load double, double* %83
%346 = load double, double* %84
%347 = call i32 @eriB_1d(double* %317, i32 %322, i32 %327, i32 %332, i32 %337, double %338, double %339, double %340, double %341, double %342, double %343, double %344, double %345, double %346)
%348 = load i32, i32* %89
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds [256 x i8], [256 x i8]* %63, i64 0, i64 %349
store i8 1, i8* %350
br label %351
351: ; preds = %316, %279
%352 = load i32*, i32** %36
%353 = load i32, i32* %90
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i32, i32* %352, i64 %354
%356 = load i32, i32* %355
%357 = mul nsw i32 %356, 64
%358 = load i32*, i32** %43
%359 = load i32, i32* %90
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i32, i32* %358, i64 %360
%362 = load i32, i32* %361
%363 = mul nsw i32 %362, 16
%364 = add nsw i32 %357, %363
%365 = load i32*, i32** %50
%366 = load i32, i32* %90
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i32, i32* %365, i64 %367
%369 = load i32, i32* %368
%370 = mul nsw i32 %369, 4
%371 = add nsw i32 %364, %370
%372 = load i32*, i32** %57
%373 = load i32, i32* %90
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds i32, i32* %372, i64 %374
%376 = load i32, i32* %375
%377 = add nsw i32 %371, %376
store i32 %377, i32* %89
%378 = getelementptr inbounds [4096 x double], [4096 x double]* %67, i64 0, i64 0
%379 = load i32, i32* %89
%380 = mul nsw i32 16, %379
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds double, double* %378, i64 %381
store double* %382, double** %70
%383 = load i32, i32* %89
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds [256 x i8], [256 x i8]* %64, i64 0, i64 %384
%386 = load i8, i8* %385
%387 = icmp ne i8 %386, 0
br i1 %387, label %423, label %388
388: ; preds = %351
%389 = load double*, double** %70
%390 = load i32*, i32** %36
%391 = load i32, i32* %90
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds i32, i32* %390, i64 %392
%394 = load i32, i32* %393
%395 = load i32*, i32** %43
%396 = load i32, i32* %90
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds i32, i32* %395, i64 %397
%399 = load i32, i32* %398
%400 = load i32*, i32** %50
%401 = load i32, i32* %90
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds i32, i32* %400, i64 %402
%404 = load i32, i32* %403
%405 = load i32*, i32** %57
%406 = load i32, i32* %90
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %405, i64 %407
%409 = load i32, i32* %408
%410 = load double, double* %77
%411 = load double, double* %33
%412 = load double, double* %40
%413 = load double, double* %80
%414 = load double, double* %47
%415 = load double, double* %54
%416 = load double, double* %82
%417 = load double, double* %83
%418 = load double, double* %84
%419 = call i32 @eriB_1d(double* %389, i32 %394, i32 %399, i32 %404, i32 %409, double %410, double %411, double %412, double %413, double %414, double %415, double %416, double %417, double %418)
%420 = load i32, i32* %89
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds [256 x i8], [256 x i8]* %64, i64 0, i64 %421
store i8 1, i8* %422
br label %423
423: ; preds = %388, %351
%424 = load i32*, i32** %37
%425 = load i32, i32* %90
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds i32, i32* %424, i64 %426
%428 = load i32, i32* %427
%429 = mul nsw i32 %428, 64
%430 = load i32*, i32** %44
%431 = load i32, i32* %90
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds i32, i32* %430, i64 %432
%434 = load i32, i32* %433
%435 = mul nsw i32 %434, 16
%436 = add nsw i32 %429, %435
%437 = load i32*, i32** %51
%438 = load i32, i32* %90
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds i32, i32* %437, i64 %439
%441 = load i32, i32* %440
%442 = mul nsw i32 %441, 4
%443 = add nsw i32 %436, %442
%444 = load i32*, i32** %58
%445 = load i32, i32* %90
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds i32, i32* %444, i64 %446
%448 = load i32, i32* %447
%449 = add nsw i32 %443, %448
store i32 %449, i32* %89
%450 = getelementptr inbounds [4096 x double], [4096 x double]* %68, i64 0, i64 0
%451 = load i32, i32* %89
%452 = mul nsw i32 16, %451
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double, double* %450, i64 %453
store double* %454, double** %71
%455 = load i32, i32* %89
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds [256 x i8], [256 x i8]* %65, i64 0, i64 %456
%458 = load i8, i8* %457
%459 = icmp ne i8 %458, 0
br i1 %459, label %495, label %460
460: ; preds = %423
%461 = load double*, double** %71
%462 = load i32*, i32** %37
%463 = load i32, i32* %90
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i32, i32* %462, i64 %464
%466 = load i32, i32* %465
%467 = load i32*, i32** %44
%468 = load i32, i32* %90
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i32, i32* %467, i64 %469
%471 = load i32, i32* %470
%472 = load i32*, i32** %51
%473 = load i32, i32* %90
%474 = sext i32 %473 to i64
%475 = getelementptr inbounds i32, i32* %472, i64 %474
%476 = load i32, i32* %475
%477 = load i32*, i32** %58
%478 = load i32, i32* %90
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds i32, i32* %477, i64 %479
%481 = load i32, i32* %480
%482 = load double, double* %78
%483 = load double, double* %34
%484 = load double, double* %41
%485 = load double, double* %81
%486 = load double, double* %48
%487 = load double, double* %55
%488 = load double, double* %82
%489 = load double, double* %83
%490 = load double, double* %84
%491 = call i32 @eriB_1d(double* %461, i32 %466, i32 %471, i32 %476, i32 %481, double %482, double %483, double %484, double %485, double %486, double %487, double %488, double %489, double %490)
%492 = load i32, i32* %89
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds [256 x i8], [256 x i8]* %65, i64 0, i64 %493
store i8 1, i8* %494
br label %495
495: ; preds = %460, %423
store double 0.000000e+00, double* %88
%496 = load i32*, i32** %35
%497 = load i32, i32* %90
%498 = sext i32 %497 to i64
%499 = getelementptr inbounds i32, i32* %496, i64 %498
%500 = load i32, i32* %499
%501 = load i32*, i32** %42
%502 = load i32, i32* %90
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i32, i32* %501, i64 %503
%505 = load i32, i32* %504
%506 = add nsw i32 %500, %505
%507 = load i32*, i32** %49
%508 = load i32, i32* %90
%509 = sext i32 %508 to i64
%510 = getelementptr inbounds i32, i32* %507, i64 %509
%511 = load i32, i32* %510
%512 = add nsw i32 %506, %511
%513 = load i32*, i32** %56
%514 = load i32, i32* %90
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds i32, i32* %513, i64 %515
%517 = load i32, i32* %516
%518 = add nsw i32 %512, %517
%519 = add nsw i32 %518, 1
store i32 %519, i32* %92
%520 = load i32*, i32** %36
%521 = load i32, i32* %90
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i32, i32* %520, i64 %522
%524 = load i32, i32* %523
%525 = load i32*, i32** %43
%526 = load i32, i32* %90
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds i32, i32* %525, i64 %527
%529 = load i32, i32* %528
%530 = add nsw i32 %524, %529
%531 = load i32*, i32** %50
%532 = load i32, i32* %90
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i32, i32* %531, i64 %533
%535 = load i32, i32* %534
%536 = add nsw i32 %530, %535
%537 = load i32*, i32** %57
%538 = load i32, i32* %90
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i32, i32* %537, i64 %539
%541 = load i32, i32* %540
%542 = add nsw i32 %536, %541
%543 = add nsw i32 %542, 1
store i32 %543, i32* %93
%544 = load i32*, i32** %37
%545 = load i32, i32* %90
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds i32, i32* %544, i64 %546
%548 = load i32, i32* %547
%549 = load i32*, i32** %44
%550 = load i32, i32* %90
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds i32, i32* %549, i64 %551
%553 = load i32, i32* %552
%554 = add nsw i32 %548, %553
%555 = load i32*, i32** %51
%556 = load i32, i32* %90
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds i32, i32* %555, i64 %557
%559 = load i32, i32* %558
%560 = add nsw i32 %554, %559
%561 = load i32*, i32** %58
%562 = load i32, i32* %90
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds i32, i32* %561, i64 %563
%565 = load i32, i32* %564
%566 = add nsw i32 %560, %565
%567 = add nsw i32 %566, 1
store i32 %567, i32* %94
store i32 0, i32* %85
br label %568
568: ; preds = %618, %495
%569 = load i32, i32* %85
%570 = load i32, i32* %92
%571 = icmp slt i32 %569, %570
br i1 %571, label %572, label %621
572: ; preds = %568
store i32 0, i32* %86
br label %573
573: ; preds = %614, %572
%574 = load i32, i32* %86
%575 = load i32, i32* %93
%576 = icmp slt i32 %574, %575
br i1 %576, label %577, label %617
577: ; preds = %573
store i32 0, i32* %87
br label %578
578: ; preds = %610, %577
%579 = load i32, i32* %87
%580 = load i32, i32* %94
%581 = icmp slt i32 %579, %580
br i1 %581, label %582, label %613
582: ; preds = %578
%583 = load double*, double** %69
%584 = load i32, i32* %85
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds double, double* %583, i64 %585
%587 = load double, double* %586
%588 = load double*, double** %70
%589 = load i32, i32* %86
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds double, double* %588, i64 %590
%592 = load double, double* %591
%593 = fmul double %587, %592
%594 = load double*, double** %71
%595 = load i32, i32* %87
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %594, i64 %596
%598 = load double, double* %597
%599 = fmul double %593, %598
%600 = load i32, i32* %85
%601 = load i32, i32* %86
%602 = add nsw i32 %600, %601
%603 = load i32, i32* %87
%604 = add nsw i32 %602, %603
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds [16 x double], [16 x double]* %72, i64 0, i64 %605
%607 = load double, double* %606
%608 = load double, double* %88
%609 = call double @llvm.fmuladd.f64(double %599, double %607, double %608)
store double %609, double* %88
br label %610
610: ; preds = %582
%611 = load i32, i32* %87
%612 = add nsw i32 %611, 1
store i32 %612, i32* %87
br label %578
613: ; preds = %578
br label %614
614: ; preds = %613
%615 = load i32, i32* %86
%616 = add nsw i32 %615, 1
store i32 %616, i32* %86
br label %573
617: ; preds = %573
br label %618
618: ; preds = %617
%619 = load i32, i32* %85
%620 = add nsw i32 %619, 1
store i32 %620, i32* %85
br label %568
621: ; preds = %568
%622 = load double, double* %88
%623 = load double, double* %91
%624 = fmul double %622, %623
%625 = load double*, double** %62
%626 = load i32, i32* %90
%627 = sext i32 %626 to i64
%628 = getelementptr inbounds double, double* %625, i64 %627
store double %624, double* %628
br label %629
629: ; preds = %621
%630 = load i32, i32* %90
%631 = add nsw i32 %630, 1
store i32 %631, i32* %90
br label %275
632: ; preds = %275
ret void
}

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