#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ eriB_1d(double *, int, int, int, int, double, double, double,
                           double, double, double, double, double, double);
double exp(double);
int /*<<< orphan*/ fgamma_set(int, double, double *);
double sqrt(double);
double genSetBxyzF(double xa, double ya, double za, int maxa, double alphaa,
                   double xb, double yb, double zb, int maxb, double alphab,
                   double xc, double yc, double zc, int maxc, double alphac,
                   double xd, double yd, double zd, int maxd, double alphad,
                   double *Bx, double *By, double *Bz, double *F, int maxL) {
  double rab2, rcd2, rpq2, xp, yp, zp, xq, yq, zq;
  double eta1, eta2, zeta;
  int a, b, c, d;
  int i, j, k, n;
  int na, nb, nc;
  double t;
  eta1 = 1.0 / (alphaa + alphab);
  eta2 = 1.0 / (alphac + alphad);
  zeta = 4.0 * (alphaa + alphab) * (alphac + alphad) /
         (alphaa + alphab + alphac + alphad);
  xp = (alphaa * xa + alphab * xb) * eta1;
  yp = (alphaa * ya + alphab * yb) * eta1;
  zp = (alphaa * za + alphab * zb) * eta1;
  xq = (alphac * xc + alphad * xd) * eta2;
  yq = (alphac * yc + alphad * yd) * eta2;
  zq = (alphac * zc + alphad * zd) * eta2;
  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(maxa + maxb + maxc + maxd, t, F);
  t = 34.986836655249725 * eta1 * eta2 /
      sqrt(alphaa + alphab + alphac + alphad) *
      exp(-alphaa * alphab * rab2 * eta1 - alphac * alphad * rcd2 * eta2);
  if (t < 1.0E-15)
    return 0.0;
  nc = (maxd + 1);
  nb = nc * (maxc + 1);
  na = nb * (maxb + 1);
  for (a = 0; a < maxa + 1; a++)
    for (b = 0; b < maxb + 1; b++)
      if (a != 0 && b != maxb) {
        for (c = 0; c < maxc + 1; c++)
          for (d = 0; d < maxd + 1; d++) {
            i = 4 * (maxL + 1) * (a * na + b * nb + c * nc + d);
            j = 4 * (maxL + 1) * ((a - 1) * na + (b + 1) * nb + c * nc + d);
            k = 4 * (maxL + 1) * ((a - 1) * na + b * nb + c * nc + d);
            n = a + b + c + d;
            Bx[i + n] = Bx[j + n];
            By[i + n] = By[j + n];
            Bz[i + n] = Bz[j + n];
            for (n = n - 1; n >= 0; n--) {
              Bx[i + n] = Bx[j + n] - (xa - xb) * Bx[k + n];
              By[i + n] = By[j + n] - (ya - yb) * By[k + n];
              Bz[i + n] = Bz[j + n] - (za - zb) * Bz[k + n];
            }
          }
      } else
        for (c = 0; c < maxc + 1; c++)
          for (d = 0; d < maxd + 1; d++)
            if (c != 0 && d != maxd) {
              i = 4 * (maxL + 1) * (a * na + b * nb + c * nc + d);
              j = 4 * (maxL + 1) * (a * na + b * nb + (c - 1) * nc + d + 1);
              k = 4 * (maxL + 1) * (a * na + b * nb + (c - 1) * nc + d);
              n = a + b + c + d;
              Bx[i + n] = Bx[j + n];
              By[i + n] = By[j + n];
              Bz[i + n] = Bz[j + n];
              for (n = n - 1; n >= 0; n--) {
                Bx[i + n] = Bx[j + n] - (xc - xd) * Bx[k + n];
                By[i + n] = By[j + n] - (yc - yd) * By[k + n];
                Bz[i + n] = Bz[j + n] - (zc - zd) * Bz[k + n];
              }
            } else {
              i = 4 * (maxL + 1) * (a * na + b * nb + c * nc + d);
              eriB_1d(Bx + i, a, b, c, d, xp, xa, xb, xq, xc, xd, eta1, eta2,
                      zeta);
              eriB_1d(By + i, a, b, c, d, yp, ya, yb, yq, yc, yd, eta1, eta2,
                      zeta);
              eriB_1d(Bz + i, a, b, c, d, zp, za, zb, zq, zc, zd, eta1, eta2,
                      zeta);
            }
  return t;
}


x86 assembly (clang, -O0):
<genSetBxyzF>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    0x60(%rbp),%eax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
movsd  0x48(%rbp),%xmm8
movsd  0x40(%rbp),%xmm8
movsd  0x38(%rbp),%xmm8
movsd  0x30(%rbp),%xmm8
movsd  0x28(%rbp),%xmm8
movsd  0x20(%rbp),%xmm8
movsd  0x18(%rbp),%xmm8
movsd  0x10(%rbp),%xmm8
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
mov    %edi,-0x24(%rbp)
movsd  %xmm3,-0x30(%rbp)
movsd  %xmm4,-0x38(%rbp)
movsd  %xmm5,-0x40(%rbp)
movsd  %xmm6,-0x48(%rbp)
mov    %esi,-0x4c(%rbp)
movsd  %xmm7,-0x58(%rbp)
mov    %edx,-0x5c(%rbp)
mov    %ecx,-0x60(%rbp)
mov    %r8,-0x68(%rbp)
mov    %r9,-0x70(%rbp)
movsd  -0x30(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
movsd  0xe4c(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x28(%rbp),%xmm1
addsd  0x48(%rbp),%xmm1
movsd  0xe2e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x30(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
movsd  0xe08(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x28(%rbp),%xmm1
addsd  0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
addsd  0x28(%rbp),%xmm1
addsd  0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x28(%rbp),%xmm0
movsd  0x10(%rbp),%xmm2
movsd  0x48(%rbp),%xmm1
mulsd  0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x28(%rbp),%xmm0
movsd  0x18(%rbp),%xmm2
movsd  0x48(%rbp),%xmm1
mulsd  0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  0x28(%rbp),%xmm0
movsd  0x20(%rbp),%xmm2
movsd  0x48(%rbp),%xmm1
mulsd  0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x10(%rbp),%xmm1
subsd  -0x38(%rbp),%xmm1
movsd  -0x10(%rbp),%xmm2
subsd  -0x38(%rbp),%xmm2
movsd  -0x18(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm3
subsd  -0x40(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x20(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm2
subsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x10(%rbp),%xmm1
subsd  0x30(%rbp),%xmm1
movsd  0x10(%rbp),%xmm2
subsd  0x30(%rbp),%xmm2
movsd  0x18(%rbp),%xmm0
subsd  0x38(%rbp),%xmm0
movsd  0x18(%rbp),%xmm3
subsd  0x38(%rbp),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x20(%rbp),%xmm0
subsd  0x40(%rbp),%xmm0
movsd  0x20(%rbp),%xmm2
subsd  0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x90(%rbp),%xmm1
ff
subsd  -0xa8(%rbp),%xmm1
ff
movsd  -0x90(%rbp),%xmm2
ff
subsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm0
ff
subsd  -0xb0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm3
ff
subsd  -0xb0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
subsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
subsd  -0xb8(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0xb98(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x24(%rbp),%edi
add    -0x4c(%rbp),%edi
add    -0x5c(%rbp),%edi
add    -0x60(%rbp),%edi
movsd  -0x108(%rbp),%xmm0
ff
mov    0x58(%rbp),%rsi
call   1030 <fgamma_set@plt>
movsd  0xb53(%rip),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
addsd  0x28(%rbp),%xmm0
addsd  0x48(%rbp),%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x118(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x58(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  0x28(%rbp),%xmm1
mulsd  0x48(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0x110(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0xa7b(%rip),%xmm0
ucomisd -0x108(%rbp),%xmm0
ff
jbe    15a0 <genSetBxyzF+0x460>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    1f16 <genSetBxyzF+0xdd6>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0xf4(%rbp)
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1f09 <genSetBxyzF+0xdc9>
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1ef0 <genSetBxyzF+0xdb0>
cmpl   $0x0,-0xd4(%rbp)
je     19a4 <genSetBxyzF+0x864>
mov    -0xd8(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     19a4 <genSetBxyzF+0x864>
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    199f <genSetBxyzF+0x85f>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1986 <genSetBxyzF+0x846>
mov    0x60(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0xd4(%rbp),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   -0xf8(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    0x60(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
add    $0x1,%edx
imul   -0xf8(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xe8(%rbp)
mov    0x60(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0xd4(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   -0xf8(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xd4(%rbp),%eax
add    -0xd8(%rbp),%eax
add    -0xdc(%rbp),%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x68(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xf0(%rbp)
cmpl   $0x0,-0xf0(%rbp)
jl     196d <genSetBxyzF+0x82d>
mov    -0x68(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x20(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xf0(%rbp)
jmp    17f9 <genSetBxyzF+0x6b9>
jmp    1972 <genSetBxyzF+0x832>
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1656 <genSetBxyzF+0x516>
jmp    198b <genSetBxyzF+0x84b>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1638 <genSetBxyzF+0x4f8>
jmp    1ed7 <genSetBxyzF+0xd97>
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1ed2 <genSetBxyzF+0xd92>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1eb9 <genSetBxyzF+0xd79>
cmpl   $0x0,-0xdc(%rbp)
je     1d04 <genSetBxyzF+0xbc4>
mov    -0xe0(%rbp),%eax
cmp    -0x60(%rbp),%eax
je     1d04 <genSetBxyzF+0xbc4>
mov    0x60(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0xd4(%rbp),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   -0xf8(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    0x60(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0xd4(%rbp),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   -0xf8(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
sub    $0x1,%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0xe8(%rbp)
mov    0x60(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0xd4(%rbp),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   -0xf8(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
sub    $0x1,%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xec(%rbp)
mov    -0xd4(%rbp),%eax
add    -0xd8(%rbp),%eax
add    -0xdc(%rbp),%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x68(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xf0(%rbp)
cmpl   $0x0,-0xf0(%rbp)
jl     1cff <genSetBxyzF+0xbbf>
mov    -0x68(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x10(%rbp),%xmm0
subsd  0x30(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x18(%rbp),%xmm0
subsd  0x38(%rbp),%xmm0
mov    -0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xe8(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x20(%rbp),%xmm0
subsd  0x40(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xf0(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xf0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xf0(%rbp)
jmp    1b8b <genSetBxyzF+0xa4b>
jmp    1ea0 <genSetBxyzF+0xd60>
mov    0x60(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0xd4(%rbp),%ecx
imul   -0xf4(%rbp),%ecx
mov    -0xd8(%rbp),%edx
imul   -0xf8(%rbp),%edx
add    %edx,%ecx
mov    -0xdc(%rbp),%edx
imul   -0xfc(%rbp),%edx
add    %edx,%ecx
add    -0xe0(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0xe4(%rbp)
mov    -0x68(%rbp),%rdi
movslq -0xe4(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0xd4(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0xe0(%rbp),%r8d
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0x10(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  -0xa8(%rbp),%xmm3
ff
movsd  0x10(%rbp),%xmm4
movsd  0x30(%rbp),%xmm5
movsd  -0xc0(%rbp),%xmm6
ff
movsd  -0xc8(%rbp),%xmm7
ff
movsd  -0xd0(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1060 <eriB_1d@plt>
mov    -0x70(%rbp),%rdi
movslq -0xe4(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0xd4(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0xe0(%rbp),%r8d
movsd  -0x98(%rbp),%xmm0
ff
movsd  -0x18(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0xb0(%rbp),%xmm3
ff
movsd  0x18(%rbp),%xmm4
movsd  0x38(%rbp),%xmm5
movsd  -0xc0(%rbp),%xmm6
ff
movsd  -0xc8(%rbp),%xmm7
ff
movsd  -0xd0(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1060 <eriB_1d@plt>
mov    0x50(%rbp),%rdi
movslq -0xe4(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0xd4(%rbp),%esi
mov    -0xd8(%rbp),%edx
mov    -0xdc(%rbp),%ecx
mov    -0xe0(%rbp),%r8d
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x20(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm2
movsd  -0xb8(%rbp),%xmm3
ff
movsd  0x20(%rbp),%xmm4
movsd  0x40(%rbp),%xmm5
movsd  -0xc0(%rbp),%xmm6
ff
movsd  -0xc8(%rbp),%xmm7
ff
movsd  -0xd0(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1060 <eriB_1d@plt>
jmp    1ea5 <genSetBxyzF+0xd65>
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    19cc <genSetBxyzF+0x88c>
jmp    1ebe <genSetBxyzF+0xd7e>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    19ae <genSetBxyzF+0x86e>
jmp    1ed7 <genSetBxyzF+0xd97>
jmp    1edc <genSetBxyzF+0xd9c>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    15fe <genSetBxyzF+0x4be>
jmp    1ef5 <genSetBxyzF+0xdb5>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    15e0 <genSetBxyzF+0x4a0>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<genSetBxyzF>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2f8,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x40(%rsp)
mov    %esi,%eax
movapd %xmm6,%xmm12
movapd %xmm5,%xmm9
movapd %xmm4,%xmm5
mov    %edi,%ebx
movapd %xmm2,%xmm6
movsd  0x368(%rsp),%xmm2
movsd  0x348(%rsp),%xmm4
movsd  0x338(%rsp),%xmm8
movsd  0x330(%rsp),%xmm13
movapd %xmm3,0x160(%rsp)
unpcklpd %xmm4,%xmm3
movapd %xmm7,0x80(%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  0x340(%rsp),%xmm2
movapd %xmm6,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm3,%xmm7
movapd %xmm3,%xmm8
addpd  %xmm10,%xmm8
movsd  0xe24(%rip),%xmm3
mulsd  %xmm8,%xmm3
movapd %xmm8,%xmm14
unpckhpd %xmm8,%xmm14
mulsd  %xmm3,%xmm14
movsd  0x350(%rsp),%xmm15
movapd %xmm5,%xmm3
unpcklpd %xmm15,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm11
movsd  0x358(%rsp),%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm2,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm13
movsd  0x360(%rsp),%xmm4
movapd %xmm12,%xmm3
unpcklpd %xmm4,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm7
movapd %xmm0,0x290(%rsp)
movapd %xmm0,%xmm3
movapd %xmm5,0x2c0(%rsp)
subsd  %xmm5,%xmm3
movapd %xmm1,0x2a0(%rsp)
movapd %xmm1,%xmm0
movapd %xmm9,0x2d0(%rsp)
subsd  %xmm9,%xmm0
movapd %xmm0,0x1b0(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm3,0x1c0(%rsp)
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm6,0x2b0(%rsp)
movapd %xmm12,0x2e0(%rsp)
subsd  %xmm12,%xmm6
movapd %xmm6,0x1a0(%rsp)
mulsd  %xmm6,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm6,0xc0(%rsp)
movsd  0x330(%rsp),%xmm1
subsd  %xmm15,%xmm1
movsd  0x338(%rsp),%xmm0
subsd  %xmm2,%xmm0
movapd %xmm0,0x180(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm1,0x190(%rsp)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x340(%rsp),%xmm12
subsd  %xmm4,%xmm12
movapd %xmm12,0x170(%rsp)
mulsd  %xmm12,%xmm12
addsd  %xmm1,%xmm12
movapd %xmm12,0x20(%rsp)
movapd 0xca7(%rip),%xmm0
divpd  %xmm8,%xmm0
mulpd  %xmm0,%xmm11
mulpd  %xmm0,%xmm13
movapd %xmm0,%xmm3
movapd %xmm0,0x120(%rsp)
movapd %xmm11,%xmm0
unpckhpd %xmm11,%xmm0
movapd %xmm11,0x280(%rsp)
movapd %xmm11,%xmm1
movapd %xmm0,0x250(%rsp)
subsd  %xmm0,%xmm1
movapd %xmm13,%xmm2
unpckhpd %xmm13,%xmm2
movapd %xmm13,0x270(%rsp)
movapd %xmm13,%xmm0
movapd %xmm2,0x240(%rsp)
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulpd  %xmm3,%xmm7
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
movapd %xmm7,0x260(%rsp)
movapd %xmm7,%xmm0
movapd %xmm2,0x230(%rsp)
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x378(%rsp),%rsi
movsd  0x348(%rsp),%xmm1
addsd  %xmm1,%xmm8
movsd  0x368(%rsp),%xmm1
addsd  %xmm1,%xmm8
movapd %xmm8,0x110(%rsp)
divsd  %xmm8,%xmm14
mulsd  0xbf2(%rip),%xmm0
movapd %xmm14,0x1d0(%rsp)
mulsd  %xmm14,%xmm0
mov    %rax,0x138(%rsp)
lea    (%rax,%rbx,1),%edi
mov    %rdx,0xe0(%rsp)
add    %edx,%edi
mov    %rcx,0xe8(%rsp)
add    %ecx,%edi
call   1030 <fgamma_set@plt>
movsd  0xbbf(%rip),%xmm0
movapd 0x120(%rsp),%xmm1
mulsd  %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
movapd %xmm1,0x150(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0xb0(%rsp)
movapd 0x110(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14b1 <genSetBxyzF+0x371>
sqrtsd %xmm0,%xmm0
jmp    14b6 <genSetBxyzF+0x376>
call   1050 <sqrt@plt>
movapd 0x160(%rsp),%xmm1
xorpd  0xb49(%rip),%xmm1
movapd 0xb0(%rsp),%xmm2
divsd  %xmm0,%xmm2
movapd %xmm2,0xb0(%rsp)
mulsd  0x80(%rsp),%xmm1
mulsd  0xc0(%rsp),%xmm1
movsd  0x348(%rsp),%xmm0
movsd  0x368(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  0x20(%rsp),%xmm0
mulsd  0x150(%rsp),%xmm0
mulsd  0x120(%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1040 <exp@plt>
mulsd  0xb0(%rsp),%xmm0
movsd  0xafd(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm1,%xmm1
ja     1f43 <genSetBxyzF+0xe03>
test   %ebx,%ebx
js     1f3f <genSetBxyzF+0xdff>
movsd  %xmm0,0x1e0(%rsp)
mov    0x380(%rsp),%r8d
mov    0xe8(%rsp),%rdi
lea    0x1(%rdi),%esi
mov    0xe0(%rsp),%rax
lea    0x1(%rax),%r10d
mov    %esi,%ebp
imul   %r10d,%ebp
mov    0x138(%rsp),%r9
lea    0x1(%r9),%ecx
mov    %ebp,%edx
imul   %ecx,%edx
lea    0x4(,%r8,4),%r8d
movapd 0xa70(%rip),%xmm0
movapd 0x1c0(%rsp),%xmm1
xorpd  %xmm0,%xmm1
movapd 0x1b0(%rsp),%xmm2
xorpd  %xmm0,%xmm2
movapd 0x1a0(%rsp),%xmm3
xorpd  %xmm0,%xmm3
movapd 0x190(%rsp),%xmm4
xorpd  %xmm0,%xmm4
movapd 0x180(%rsp),%xmm5
xorpd  %xmm0,%xmm5
movapd 0x170(%rsp),%xmm6
xorpd  %xmm0,%xmm6
mov    %esi,0x74(%rsp)
movslq %esi,%rsi
movslq %r8d,%rax
movslq %edx,%rdx
mov    %rdx,0x1e8(%rsp)
add    $0x1,%ebx
mov    %ecx,%edx
mov    %rdx,0x200(%rsp)
mov    %r10d,%edx
mov    %rdx,0x140(%rsp)
mov    %eax,%edx
imul   %esi,%edx
mov    %edx,0x7c(%rsp)
imul   %r10d,%edx
mov    %edx,0x108(%rsp)
imul   %ecx,%edx
mov    %edx,0x100(%rsp)
neg    %edx
mov    %edx,0x60(%rsp)
imul   %esi,%ecx
neg    %ecx
add    %edi,%ecx
add    $0x1,%ecx
imul   %eax,%ecx
imul   %r10d,%ecx
mov    %ecx,0x5c(%rsp)
mov    %edi,%ecx
not    %ecx
imul   %eax,%ecx
mov    %ecx,0x58(%rsp)
mov    %edi,%ecx
mov    %rax,0x220(%rsp)
imul   %eax,%ecx
neg    %ecx
mov    %ecx,0x54(%rsp)
mov    %edi,%eax
mov    %rax,0x228(%rsp)
mov    %r9d,%eax
mov    %rax,0x1f8(%rsp)
mov    %ebp,0x104(%rsp)
movslq %ebp,%rax
mov    %rax,0x1f0(%rsp)
mov    %rsi,0x210(%rsp)
mov    %esi,%eax
mov    %rax,0x160(%rsp)
xor    %eax,%eax
mov    %rax,0xd8(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    %rbx,0x208(%rsp)
mov    %r8d,0xb0(%rsp)
movapd %xmm1,0x1c0(%rsp)
movapd %xmm2,0x1b0(%rsp)
movapd %xmm3,0x1a0(%rsp)
movapd %xmm4,0x190(%rsp)
movapd %xmm5,0x180(%rsp)
movapd %xmm6,0x170(%rsp)
jmp    1753 <genSetBxyzF+0x613>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x20(%rsp),%rdx
add    $0x1,%rdx
mov    0x100(%rsp),%eax
mov    0xd8(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,0xd8(%rsp)
add    %eax,0x60(%rsp)
add    %eax,0x5c(%rsp)
add    %eax,0x58(%rsp)
add    %eax,0x54(%rsp)
mov    %rdx,%rax
mov    %rdx,0x20(%rsp)
cmp    %rbx,%rdx
je     1f34 <genSetBxyzF+0xdf4>
cmpl   $0x0,0x138(%rsp)
js     1710 <genSetBxyzF+0x5d0>
mov    0x20(%rsp),%rdx
mov    %rdx,%rax
mov    0x1e8(%rsp),%rcx
imul   %rcx,%rax
mov    %rax,0x148(%rsp)
lea    -0x1(%rdx),%eax
imul   %eax,%ecx
mov    %ecx,0x10c(%rsp)
mov    0x54(%rsp),%eax
mov    %eax,0x70(%rsp)
mov    0x58(%rsp),%eax
mov    %eax,0x6c(%rsp)
mov    0x5c(%rsp),%eax
mov    %eax,0x68(%rsp)
mov    0x60(%rsp),%eax
mov    %eax,0x64(%rsp)
mov    0xd8(%rsp),%rax
mov    %eax,0x14(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %edx,%eax
mov    %edx,0x10(%rsp)
jmp    1817 <genSetBxyzF+0x6d7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x10(%rsp)
mov    0x108(%rsp),%eax
add    %eax,0x14(%rsp)
add    %eax,0x64(%rsp)
add    %eax,0x68(%rsp)
add    %eax,0x6c(%rsp)
add    %eax,0x70(%rsp)
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    0x200(%rsp),%rcx
mov    0x208(%rsp),%rbx
je     1710 <genSetBxyzF+0x5d0>
cmpq   $0x0,0x20(%rsp)
je     1ad0 <genSetBxyzF+0x990>
mov    0x18(%rsp),%rax
cmp    0x1f8(%rsp),%rax
je     1ad0 <genSetBxyzF+0x990>
cmpl   $0x0,0xe0(%rsp)
js     17d0 <genSetBxyzF+0x690>
mov    0x20(%rsp),%rax
mov    0x18(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x90(%rsp)
mov    0x104(%rsp),%eax
mov    %eax,%edx
imul   %ecx,%edx
mov    %edx,0xa8(%rsp)
add    $0x1,%ecx
imul   %eax,%ecx
mov    %ecx,0xf0(%rsp)
mov    0x68(%rsp),%eax
mov    %eax,0xa0(%rsp)
mov    0x64(%rsp),%eax
mov    %eax,0x98(%rsp)
mov    0x14(%rsp),%eax
mov    %eax,0xc(%rsp)
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    0x10(%rsp),%eax
mov    %eax,0x8(%rsp)
jmp    18ea <genSetBxyzF+0x7aa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x38(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x8(%rsp)
mov    0x7c(%rsp),%eax
add    %eax,0xc(%rsp)
add    %eax,0x98(%rsp)
add    %eax,0xa0(%rsp)
mov    %rcx,%rax
mov    %rcx,0x38(%rsp)
cmp    0x140(%rsp),%rcx
je     17d0 <genSetBxyzF+0x690>
cmpl   $0x0,0xe8(%rsp)
js     18b0 <genSetBxyzF+0x770>
movslq 0x8(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x80(%rsp)
mov    0x90(%rsp),%rax
mov    0x38(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x110(%rsp)
mov    0x74(%rsp),%eax
imul   %ecx,%eax
mov    %rax,0xf8(%rsp)
mov    0xa0(%rsp),%eax
mov    %eax,0xc0(%rsp)
mov    0x98(%rsp),%ebx
mov    0xc(%rsp),%ecx
xor    %r8d,%r8d
jmp    197d <genSetBxyzF+0x83d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
addq   $0x1,0x80(%rsp)
mov    0xb0(%rsp),%eax
add    %eax,%ecx
add    %eax,%ebx
add    %eax,0xc0(%rsp)
cmp    0x160(%rsp),%r8
je     18b0 <genSetBxyzF+0x770>
mov    0xf8(%rsp),%rax
lea    (%rax,%r8,1),%edx
mov    0x148(%rsp),%rax
lea    (%rdx,%rax,1),%esi
add    0xa8(%rsp),%esi
mov    0xb0(%rsp),%eax
imul   %eax,%esi
add    0x10c(%rsp),%edx
add    0xf0(%rsp),%edx
imul   %eax,%edx
mov    0x110(%rsp),%rax
lea    (%rax,%r8,1),%rdi
movslq %edx,%rdx
add    %rdi,%rdx
mov    0x40(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm0
movslq %esi,%rsi
add    %rdi,%rsi
movsd  %xmm0,0x0(%rbp,%rsi,8)
mov    0x48(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
mov    0x370(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
test   %rdi,%rdi
je     1950 <genSetBxyzF+0x810>
movslq %ecx,%rsi
mov    0x40(%rsp),%rbp
lea    0x0(,%rsi,8),%rdx
add    %rbp,%rdx
mov    0x48(%rsp),%rdi
lea    (%rdi,%rsi,8),%r9
mov    0x370(%rsp),%rax
lea    (%rax,%rsi,8),%r10
movslq %ebx,%rsi
lea    0x0(%rbp,%rsi,8),%r11
lea    (%rdi,%rsi,8),%r14
lea    (%rax,%rsi,8),%r15
movslq 0xc0(%rsp),%rsi
lea    0x0(,%rsi,8),%r12
add    %rbp,%r12
lea    (%rdi,%rsi,8),%r13
lea    (%rax,%rsi,8),%rdi
mov    0x80(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
movsd  -0x10(%r11,%rsi,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  -0x10(%r12,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%rsi,8)
movsd  -0x10(%r14,%rsi,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  -0x10(%r13,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%r9,%rsi,8)
movsd  -0x10(%r15,%rsi,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  -0x10(%rdi,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%r10,%rsi,8)
add    $0xffffffffffffffff,%rsi
cmp    $0x1,%rsi
jg     1a70 <genSetBxyzF+0x930>
jmp    1950 <genSetBxyzF+0x810>
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0xe0(%rsp)
js     17d0 <genSetBxyzF+0x690>
mov    0x18(%rsp),%rcx
mov    %rcx,%rax
imul   0x1f0(%rsp),%rax
add    0x148(%rsp),%rax
mov    %rax,0xa8(%rsp)
mov    0x20(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x218(%rsp)
mov    0x70(%rsp),%eax
mov    %eax,0xc(%rsp)
mov    0x6c(%rsp),%eax
mov    %eax,0x8(%rsp)
mov    0x14(%rsp),%eax
mov    %eax,0x90(%rsp)
xor    %eax,%eax
mov    %rax,0x80(%rsp)
mov    0x10(%rsp),%eax
mov    %eax,0x78(%rsp)
jmp    1b7d <genSetBxyzF+0xa3d>
xchg   %ax,%ax
mov    0x80(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x78(%rsp)
mov    0x7c(%rsp),%eax
add    %eax,0x90(%rsp)
add    %eax,0x8(%rsp)
add    %eax,0xc(%rsp)
mov    %rcx,%rax
mov    %rcx,0x80(%rsp)
cmp    0x140(%rsp),%rcx
je     17d0 <genSetBxyzF+0x690>
cmpl   $0x0,0xe8(%rsp)
js     1b40 <genSetBxyzF+0xa00>
mov    0x80(%rsp),%rcx
mov    %rcx,%rdx
imul   0x210(%rsp),%rdx
mov    0x218(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x38(%rsp)
mov    0xa8(%rsp),%rax
mov    %rdx,0xf0(%rsp)
add    %rdx,%rax
mov    %rax,0xa0(%rsp)
lea    -0x1(%rcx),%eax
imul   0x74(%rsp),%eax
mov    %rax,0x98(%rsp)
mov    0xc(%rsp),%r11d
mov    0x8(%rsp),%eax
mov    %eax,0xc0(%rsp)
mov    0x90(%rsp),%r14d
xor    %r15d,%r15d
mov    0x78(%rsp),%r12d
jmp    1de9 <genSetBxyzF+0xca9>
nopl   0x0(%rax,%rax,1)
mov    0xa0(%rsp),%rax
lea    (%rax,%r15,1),%r13
imul   0x220(%rsp),%r13
mov    0x40(%rsp),%rax
lea    (%rax,%r13,8),%rdi
movaps 0x1d0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x20(%rsp),%rsi
mov    %rsi,0x20(%rsp)
mov    0x18(%rsp),%rdx
mov    %r14d,0xf8(%rsp)
mov    %rdx,%r14
mov    0x80(%rsp),%rbx
mov    %ebx,%ecx
mov    %r15d,%r8d
movaps 0x280(%rsp),%xmm0
movaps 0x290(%rsp),%xmm1
movaps 0x2c0(%rsp),%xmm2
movaps 0x250(%rsp),%xmm3
movsd  0x330(%rsp),%xmm4
movsd  0x350(%rsp),%xmm5
movaps 0x120(%rsp),%xmm6
movaps 0x150(%rsp),%xmm7
mov    %r11d,0x110(%rsp)
call   1060 <eriB_1d@plt>
mov    0x48(%rsp),%rax
lea    (%rax,%r13,8),%rdi
movaps 0x1d0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x20(%rsp),%rbp
mov    %ebp,%esi
mov    %r14d,%edx
mov    %ebx,%ecx
mov    %r15d,%r8d
movaps 0x270(%rsp),%xmm0
movaps 0x2a0(%rsp),%xmm1
movaps 0x2d0(%rsp),%xmm2
movaps 0x240(%rsp),%xmm3
movsd  0x338(%rsp),%xmm4
movsd  0x358(%rsp),%xmm5
movaps 0x120(%rsp),%xmm6
movaps 0x150(%rsp),%xmm7
call   1060 <eriB_1d@plt>
mov    0x370(%rsp),%rax
lea    (%rax,%r13,8),%rdi
movaps 0x1d0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    %ebp,%esi
mov    %r14d,%edx
mov    0xf8(%rsp),%r14d
mov    %ebx,%ecx
mov    %r15d,%r8d
movapd 0x260(%rsp),%xmm0
movaps 0x2b0(%rsp),%xmm1
movaps 0x2e0(%rsp),%xmm2
movaps 0x230(%rsp),%xmm3
movsd  0x340(%rsp),%xmm4
movsd  0x360(%rsp),%xmm5
movaps 0x120(%rsp),%xmm6
movapd 0x150(%rsp),%xmm7
call   1060 <eriB_1d@plt>
mov    0x110(%rsp),%r11d
movapd 0x170(%rsp),%xmm6
movapd 0x180(%rsp),%xmm5
movapd 0x190(%rsp),%xmm4
movapd 0x1a0(%rsp),%xmm3
movapd 0x1b0(%rsp),%xmm2
movapd 0x1c0(%rsp),%xmm1
add    $0x1,%r15
add    $0x1,%r12d
mov    0xb0(%rsp),%eax
add    %eax,%r14d
add    %eax,0xc0(%rsp)
add    %eax,%r11d
cmp    0x160(%rsp),%r15
je     1b40 <genSetBxyzF+0xa00>
cmpq   $0x0,0x80(%rsp)
je     1c00 <genSetBxyzF+0xac0>
cmp    0x228(%rsp),%r15
je     1c00 <genSetBxyzF+0xac0>
mov    0xa8(%rsp),%rax
add    %r15d,%eax
mov    0xf0(%rsp),%rcx
add    %eax,%ecx
mov    0xb0(%rsp),%esi
imul   %esi,%ecx
mov    0x98(%rsp),%rdx
add    %edx,%eax
add    $0x1,%eax
imul   %esi,%eax
mov    0x38(%rsp),%rdx
add    %r15,%rdx
cltq
add    %rdx,%rax
mov    0x40(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
movslq %ecx,%rcx
add    %rdx,%rcx
movsd  %xmm0,(%rsi,%rcx,8)
mov    0x48(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
mov    0x370(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
test   %edx,%edx
je     1dbf <genSetBxyzF+0xc7f>
movslq %r12d,%rax
add    $0x1,%rax
movslq %r14d,%rcx
mov    %r11d,%r13d
mov    0x40(%rsp),%r11
lea    (%r11,%rcx,8),%r8
mov    0x48(%rsp),%rdx
lea    (%rdx,%rcx,8),%r9
mov    0x370(%rsp),%rsi
lea    (%rsi,%rcx,8),%r10
movslq 0xc0(%rsp),%rcx
lea    (%r11,%rcx,8),%rdi
lea    (%rdx,%rcx,8),%rbp
lea    (%rsi,%rcx,8),%rbx
movslq %r13d,%rsi
lea    (%r11,%rsi,8),%rcx
mov    %r13d,%r11d
lea    (%rdx,%rsi,8),%rdx
mov    0x370(%rsp),%r13
lea    0x0(,%rsi,8),%rsi
add    %r13,%rsi
movsd  -0x10(%rdi,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  -0x10(%rcx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r8,%rax,8)
movsd  -0x10(%rbp,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  -0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r9,%rax,8)
movsd  -0x10(%rbx,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  -0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x10(%r10,%rax,8)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
jg     1ee0 <genSetBxyzF+0xda0>
jmp    1dbf <genSetBxyzF+0xc7f>
movsd  0x1e0(%rsp),%xmm1
jmp    1f43 <genSetBxyzF+0xe03>
movapd %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x2f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @genSetBxyzF(double %0, double %1, double %2, i32 %3, double %4, double %5, double %6, double %7, i32 %8, double %9, double %10, double %11, double %12, i32 %13, double %14, double %15, double %16, double %17, i32 %18, double %19, double* %20, double* %21, double* %22, double* %23, i32 %24) {
%26 = alloca double
%27 = alloca double
%28 = alloca double
%29 = alloca double
%30 = alloca i32
%31 = alloca double
%32 = alloca double
%33 = alloca double
%34 = alloca double
%35 = alloca i32
%36 = alloca double
%37 = alloca double
%38 = alloca double
%39 = alloca double
%40 = alloca i32
%41 = alloca double
%42 = alloca double
%43 = alloca double
%44 = alloca double
%45 = alloca i32
%46 = alloca double
%47 = alloca double*
%48 = alloca double*
%49 = alloca double*
%50 = alloca double*
%51 = alloca i32
%52 = alloca double
%53 = alloca double
%54 = alloca double
%55 = alloca double
%56 = alloca double
%57 = alloca double
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca i32
%65 = alloca i32
%66 = alloca i32
%67 = alloca i32
%68 = alloca i32
%69 = alloca i32
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca i32
%74 = alloca i32
%75 = alloca double
store double %0, double* %27
store double %1, double* %28
store double %2, double* %29
store i32 %3, i32* %30
store double %4, double* %31
store double %5, double* %32
store double %6, double* %33
store double %7, double* %34
store i32 %8, i32* %35
store double %9, double* %36
store double %10, double* %37
store double %11, double* %38
store double %12, double* %39
store i32 %13, i32* %40
store double %14, double* %41
store double %15, double* %42
store double %16, double* %43
store double %17, double* %44
store i32 %18, i32* %45
store double %19, double* %46
store double* %20, double** %47
store double* %21, double** %48
store double* %22, double** %49
store double* %23, double** %50
store i32 %24, i32* %51
%76 = load double, double* %31
%77 = load double, double* %36
%78 = fadd double %76, %77
%79 = fdiv double 1.000000e+00, %78
store double %79, double* %61
%80 = load double, double* %41
%81 = load double, double* %46
%82 = fadd double %80, %81
%83 = fdiv double 1.000000e+00, %82
store double %83, double* %62
%84 = load double, double* %31
%85 = load double, double* %36
%86 = fadd double %84, %85
%87 = fmul double 4.000000e+00, %86
%88 = load double, double* %41
%89 = load double, double* %46
%90 = fadd double %88, %89
%91 = fmul double %87, %90
%92 = load double, double* %31
%93 = load double, double* %36
%94 = fadd double %92, %93
%95 = load double, double* %41
%96 = fadd double %94, %95
%97 = load double, double* %46
%98 = fadd double %96, %97
%99 = fdiv double %91, %98
store double %99, double* %63
%100 = load double, double* %31
%101 = load double, double* %27
%102 = load double, double* %36
%103 = load double, double* %32
%104 = fmul double %102, %103
%105 = call double @llvm.fmuladd.f64(double %100, double %101, double %104)
%106 = load double, double* %61
%107 = fmul double %105, %106
store double %107, double* %55
%108 = load double, double* %31
%109 = load double, double* %28
%110 = load double, double* %36
%111 = load double, double* %33
%112 = fmul double %110, %111
%113 = call double @llvm.fmuladd.f64(double %108, double %109, double %112)
%114 = load double, double* %61
%115 = fmul double %113, %114
store double %115, double* %56
%116 = load double, double* %31
%117 = load double, double* %29
%118 = load double, double* %36
%119 = load double, double* %34
%120 = fmul double %118, %119
%121 = call double @llvm.fmuladd.f64(double %116, double %117, double %120)
%122 = load double, double* %61
%123 = fmul double %121, %122
store double %123, double* %57
%124 = load double, double* %41
%125 = load double, double* %37
%126 = load double, double* %46
%127 = load double, double* %42
%128 = fmul double %126, %127
%129 = call double @llvm.fmuladd.f64(double %124, double %125, double %128)
%130 = load double, double* %62
%131 = fmul double %129, %130
store double %131, double* %58
%132 = load double, double* %41
%133 = load double, double* %38
%134 = load double, double* %46
%135 = load double, double* %43
%136 = fmul double %134, %135
%137 = call double @llvm.fmuladd.f64(double %132, double %133, double %136)
%138 = load double, double* %62
%139 = fmul double %137, %138
store double %139, double* %59
%140 = load double, double* %41
%141 = load double, double* %39
%142 = load double, double* %46
%143 = load double, double* %44
%144 = fmul double %142, %143
%145 = call double @llvm.fmuladd.f64(double %140, double %141, double %144)
%146 = load double, double* %62
%147 = fmul double %145, %146
store double %147, double* %60
%148 = load double, double* %27
%149 = load double, double* %32
%150 = fsub double %148, %149
%151 = load double, double* %27
%152 = load double, double* %32
%153 = fsub double %151, %152
%154 = load double, double* %28
%155 = load double, double* %33
%156 = fsub double %154, %155
%157 = load double, double* %28
%158 = load double, double* %33
%159 = fsub double %157, %158
%160 = fmul double %156, %159
%161 = call double @llvm.fmuladd.f64(double %150, double %153, double %160)
%162 = load double, double* %29
%163 = load double, double* %34
%164 = fsub double %162, %163
%165 = load double, double* %29
%166 = load double, double* %34
%167 = fsub double %165, %166
%168 = call double @llvm.fmuladd.f64(double %164, double %167, double %161)
store double %168, double* %52
%169 = load double, double* %37
%170 = load double, double* %42
%171 = fsub double %169, %170
%172 = load double, double* %37
%173 = load double, double* %42
%174 = fsub double %172, %173
%175 = load double, double* %38
%176 = load double, double* %43
%177 = fsub double %175, %176
%178 = load double, double* %38
%179 = load double, double* %43
%180 = fsub double %178, %179
%181 = fmul double %177, %180
%182 = call double @llvm.fmuladd.f64(double %171, double %174, double %181)
%183 = load double, double* %39
%184 = load double, double* %44
%185 = fsub double %183, %184
%186 = load double, double* %39
%187 = load double, double* %44
%188 = fsub double %186, %187
%189 = call double @llvm.fmuladd.f64(double %185, double %188, double %182)
store double %189, double* %53
%190 = load double, double* %55
%191 = load double, double* %58
%192 = fsub double %190, %191
%193 = load double, double* %55
%194 = load double, double* %58
%195 = fsub double %193, %194
%196 = load double, double* %56
%197 = load double, double* %59
%198 = fsub double %196, %197
%199 = load double, double* %56
%200 = load double, double* %59
%201 = fsub double %199, %200
%202 = fmul double %198, %201
%203 = call double @llvm.fmuladd.f64(double %192, double %195, double %202)
%204 = load double, double* %57
%205 = load double, double* %60
%206 = fsub double %204, %205
%207 = load double, double* %57
%208 = load double, double* %60
%209 = fsub double %207, %208
%210 = call double @llvm.fmuladd.f64(double %206, double %209, double %203)
store double %210, double* %54
%211 = load double, double* %54
%212 = fmul double 2.500000e-01, %211
%213 = load double, double* %63
%214 = fmul double %212, %213
store double %214, double* %75
%215 = load i32, i32* %30
%216 = load i32, i32* %35
%217 = add nsw i32 %215, %216
%218 = load i32, i32* %40
%219 = add nsw i32 %217, %218
%220 = load i32, i32* %45
%221 = add nsw i32 %219, %220
%222 = load double, double* %75
%223 = load double*, double** %50
%224 = call i32 @fgamma_set(i32 %221, double %222, double* %223)
%225 = load double, double* %61
%226 = fmul double 0x40417E50A9DC6553, %225
%227 = load double, double* %62
%228 = fmul double %226, %227
%229 = load double, double* %31
%230 = load double, double* %36
%231 = fadd double %229, %230
%232 = load double, double* %41
%233 = fadd double %231, %232
%234 = load double, double* %46
%235 = fadd double %233, %234
%236 = call double @sqrt(double %235)
%237 = fdiv double %228, %236
%238 = load double, double* %31
%239 = fneg double %238
%240 = load double, double* %36
%241 = fmul double %239, %240
%242 = load double, double* %52
%243 = fmul double %241, %242
%244 = load double, double* %61
%245 = load double, double* %41
%246 = load double, double* %46
%247 = fmul double %245, %246
%248 = load double, double* %53
%249 = fmul double %247, %248
%250 = load double, double* %62
%251 = fmul double %249, %250
%252 = fneg double %251
%253 = call double @llvm.fmuladd.f64(double %243, double %244, double %252)
%254 = call double @exp(double %253)
%255 = fmul double %237, %254
store double %255, double* %75
%256 = load double, double* %75
%257 = fcmp olt double %256, 1.000000e-15
br i1 %257, label %258, label %259
258: ; preds = %25
store double 0.000000e+00, double* %26
br label %790
259: ; preds = %25
%260 = load i32, i32* %45
%261 = add nsw i32 %260, 1
store i32 %261, i32* %74
%262 = load i32, i32* %74
%263 = load i32, i32* %40
%264 = add nsw i32 %263, 1
%265 = mul nsw i32 %262, %264
store i32 %265, i32* %73
%266 = load i32, i32* %73
%267 = load i32, i32* %35
%268 = add nsw i32 %267, 1
%269 = mul nsw i32 %266, %268
store i32 %269, i32* %72
store i32 0, i32* %64
br label %270
270: ; preds = %785, %259
%271 = load i32, i32* %64
%272 = load i32, i32* %30
%273 = add nsw i32 %272, 1
%274 = icmp slt i32 %271, %273
br i1 %274, label %275, label %788
275: ; preds = %270
store i32 0, i32* %65
br label %276
276: ; preds = %781, %275
%277 = load i32, i32* %65
%278 = load i32, i32* %35
%279 = add nsw i32 %278, 1
%280 = icmp slt i32 %277, %279
br i1 %280, label %281, label %784
281: ; preds = %276
%282 = load i32, i32* %64
%283 = icmp ne i32 %282, 0
br i1 %283, label %284, label %494
284: ; preds = %281
%285 = load i32, i32* %65
%286 = load i32, i32* %35
%287 = icmp ne i32 %285, %286
br i1 %287, label %288, label %494
288: ; preds = %284
store i32 0, i32* %66
br label %289
289: ; preds = %490, %288
%290 = load i32, i32* %66
%291 = load i32, i32* %40
%292 = add nsw i32 %291, 1
%293 = icmp slt i32 %290, %292
br i1 %293, label %294, label %493
294: ; preds = %289
store i32 0, i32* %67
br label %295
295: ; preds = %486, %294
%296 = load i32, i32* %67
%297 = load i32, i32* %45
%298 = add nsw i32 %297, 1
%299 = icmp slt i32 %296, %298
br i1 %299, label %300, label %489
300: ; preds = %295
%301 = load i32, i32* %51
%302 = add nsw i32 %301, 1
%303 = mul nsw i32 4, %302
%304 = load i32, i32* %64
%305 = load i32, i32* %72
%306 = mul nsw i32 %304, %305
%307 = load i32, i32* %65
%308 = load i32, i32* %73
%309 = mul nsw i32 %307, %308
%310 = add nsw i32 %306, %309
%311 = load i32, i32* %66
%312 = load i32, i32* %74
%313 = mul nsw i32 %311, %312
%314 = add nsw i32 %310, %313
%315 = load i32, i32* %67
%316 = add nsw i32 %314, %315
%317 = mul nsw i32 %303, %316
store i32 %317, i32* %68
%318 = load i32, i32* %51
%319 = add nsw i32 %318, 1
%320 = mul nsw i32 4, %319
%321 = load i32, i32* %64
%322 = sub nsw i32 %321, 1
%323 = load i32, i32* %72
%324 = mul nsw i32 %322, %323
%325 = load i32, i32* %65
%326 = add nsw i32 %325, 1
%327 = load i32, i32* %73
%328 = mul nsw i32 %326, %327
%329 = add nsw i32 %324, %328
%330 = load i32, i32* %66
%331 = load i32, i32* %74
%332 = mul nsw i32 %330, %331
%333 = add nsw i32 %329, %332
%334 = load i32, i32* %67
%335 = add nsw i32 %333, %334
%336 = mul nsw i32 %320, %335
store i32 %336, i32* %69
%337 = load i32, i32* %51
%338 = add nsw i32 %337, 1
%339 = mul nsw i32 4, %338
%340 = load i32, i32* %64
%341 = sub nsw i32 %340, 1
%342 = load i32, i32* %72
%343 = mul nsw i32 %341, %342
%344 = load i32, i32* %65
%345 = load i32, i32* %73
%346 = mul nsw i32 %344, %345
%347 = add nsw i32 %343, %346
%348 = load i32, i32* %66
%349 = load i32, i32* %74
%350 = mul nsw i32 %348, %349
%351 = add nsw i32 %347, %350
%352 = load i32, i32* %67
%353 = add nsw i32 %351, %352
%354 = mul nsw i32 %339, %353
store i32 %354, i32* %70
%355 = load i32, i32* %64
%356 = load i32, i32* %65
%357 = add nsw i32 %355, %356
%358 = load i32, i32* %66
%359 = add nsw i32 %357, %358
%360 = load i32, i32* %67
%361 = add nsw i32 %359, %360
store i32 %361, i32* %71
%362 = load double*, double** %47
%363 = load i32, i32* %69
%364 = load i32, i32* %71
%365 = add nsw i32 %363, %364
%366 = sext i32 %365 to i64
%367 = getelementptr inbounds double, double* %362, i64 %366
%368 = load double, double* %367
%369 = load double*, double** %47
%370 = load i32, i32* %68
%371 = load i32, i32* %71
%372 = add nsw i32 %370, %371
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %369, i64 %373
store double %368, double* %374
%375 = load double*, double** %48
%376 = load i32, i32* %69
%377 = load i32, i32* %71
%378 = add nsw i32 %376, %377
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds double, double* %375, i64 %379
%381 = load double, double* %380
%382 = load double*, double** %48
%383 = load i32, i32* %68
%384 = load i32, i32* %71
%385 = add nsw i32 %383, %384
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double, double* %382, i64 %386
store double %381, double* %387
%388 = load double*, double** %49
%389 = load i32, i32* %69
%390 = load i32, i32* %71
%391 = add nsw i32 %389, %390
%392 = sext i32 %391 to i64
%393 = getelementptr inbounds double, double* %388, i64 %392
%394 = load double, double* %393
%395 = load double*, double** %49
%396 = load i32, i32* %68
%397 = load i32, i32* %71
%398 = add nsw i32 %396, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %395, i64 %399
store double %394, double* %400
%401 = load i32, i32* %71
%402 = sub nsw i32 %401, 1
store i32 %402, i32* %71
br label %403
403: ; preds = %482, %300
%404 = load i32, i32* %71
%405 = icmp sge i32 %404, 0
br i1 %405, label %406, label %485
406: ; preds = %403
%407 = load double*, double** %47
%408 = load i32, i32* %69
%409 = load i32, i32* %71
%410 = add nsw i32 %408, %409
%411 = sext i32 %410 to i64
%412 = getelementptr inbounds double, double* %407, i64 %411
%413 = load double, double* %412
%414 = load double, double* %27
%415 = load double, double* %32
%416 = fsub double %414, %415
%417 = load double*, double** %47
%418 = load i32, i32* %70
%419 = load i32, i32* %71
%420 = add nsw i32 %418, %419
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds double, double* %417, i64 %421
%423 = load double, double* %422
%424 = fneg double %416
%425 = call double @llvm.fmuladd.f64(double %424, double %423, double %413)
%426 = load double*, double** %47
%427 = load i32, i32* %68
%428 = load i32, i32* %71
%429 = add nsw i32 %427, %428
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %426, i64 %430
store double %425, double* %431
%432 = load double*, double** %48
%433 = load i32, i32* %69
%434 = load i32, i32* %71
%435 = add nsw i32 %433, %434
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds double, double* %432, i64 %436
%438 = load double, double* %437
%439 = load double, double* %28
%440 = load double, double* %33
%441 = fsub double %439, %440
%442 = load double*, double** %48
%443 = load i32, i32* %70
%444 = load i32, i32* %71
%445 = add nsw i32 %443, %444
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %442, i64 %446
%448 = load double, double* %447
%449 = fneg double %441
%450 = call double @llvm.fmuladd.f64(double %449, double %448, double %438)
%451 = load double*, double** %48
%452 = load i32, i32* %68
%453 = load i32, i32* %71
%454 = add nsw i32 %452, %453
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %451, i64 %455
store double %450, double* %456
%457 = load double*, double** %49
%458 = load i32, i32* %69
%459 = load i32, i32* %71
%460 = add nsw i32 %458, %459
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds double, double* %457, i64 %461
%463 = load double, double* %462
%464 = load double, double* %29
%465 = load double, double* %34
%466 = fsub double %464, %465
%467 = load double*, double** %49
%468 = load i32, i32* %70
%469 = load i32, i32* %71
%470 = add nsw i32 %468, %469
%471 = sext i32 %470 to i64
%472 = getelementptr inbounds double, double* %467, i64 %471
%473 = load double, double* %472
%474 = fneg double %466
%475 = call double @llvm.fmuladd.f64(double %474, double %473, double %463)
%476 = load double*, double** %49
%477 = load i32, i32* %68
%478 = load i32, i32* %71
%479 = add nsw i32 %477, %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %476, i64 %480
store double %475, double* %481
br label %482
482: ; preds = %406
%483 = load i32, i32* %71
%484 = add nsw i32 %483, -1
store i32 %484, i32* %71
br label %403
485: ; preds = %403
br label %486
486: ; preds = %485
%487 = load i32, i32* %67
%488 = add nsw i32 %487, 1
store i32 %488, i32* %67
br label %295
489: ; preds = %295
br label %490
490: ; preds = %489
%491 = load i32, i32* %66
%492 = add nsw i32 %491, 1
store i32 %492, i32* %66
br label %289
493: ; preds = %289
br label %780
494: ; preds = %284, %281
store i32 0, i32* %66
br label %495
495: ; preds = %776, %494
%496 = load i32, i32* %66
%497 = load i32, i32* %40
%498 = add nsw i32 %497, 1
%499 = icmp slt i32 %496, %498
br i1 %499, label %500, label %779
500: ; preds = %495
store i32 0, i32* %67
br label %501
501: ; preds = %772, %500
%502 = load i32, i32* %67
%503 = load i32, i32* %45
%504 = add nsw i32 %503, 1
%505 = icmp slt i32 %502, %504
br i1 %505, label %506, label %775
506: ; preds = %501
%507 = load i32, i32* %66
%508 = icmp ne i32 %507, 0
br i1 %508, label %509, label %699
509: ; preds = %506
%510 = load i32, i32* %67
%511 = load i32, i32* %45
%512 = icmp ne i32 %510, %511
br i1 %512, label %513, label %699
513: ; preds = %509
%514 = load i32, i32* %51
%515 = add nsw i32 %514, 1
%516 = mul nsw i32 4, %515
%517 = load i32, i32* %64
%518 = load i32, i32* %72
%519 = mul nsw i32 %517, %518
%520 = load i32, i32* %65
%521 = load i32, i32* %73
%522 = mul nsw i32 %520, %521
%523 = add nsw i32 %519, %522
%524 = load i32, i32* %66
%525 = load i32, i32* %74
%526 = mul nsw i32 %524, %525
%527 = add nsw i32 %523, %526
%528 = load i32, i32* %67
%529 = add nsw i32 %527, %528
%530 = mul nsw i32 %516, %529
store i32 %530, i32* %68
%531 = load i32, i32* %51
%532 = add nsw i32 %531, 1
%533 = mul nsw i32 4, %532
%534 = load i32, i32* %64
%535 = load i32, i32* %72
%536 = mul nsw i32 %534, %535
%537 = load i32, i32* %65
%538 = load i32, i32* %73
%539 = mul nsw i32 %537, %538
%540 = add nsw i32 %536, %539
%541 = load i32, i32* %66
%542 = sub nsw i32 %541, 1
%543 = load i32, i32* %74
%544 = mul nsw i32 %542, %543
%545 = add nsw i32 %540, %544
%546 = load i32, i32* %67
%547 = add nsw i32 %545, %546
%548 = add nsw i32 %547, 1
%549 = mul nsw i32 %533, %548
store i32 %549, i32* %69
%550 = load i32, i32* %51
%551 = add nsw i32 %550, 1
%552 = mul nsw i32 4, %551
%553 = load i32, i32* %64
%554 = load i32, i32* %72
%555 = mul nsw i32 %553, %554
%556 = load i32, i32* %65
%557 = load i32, i32* %73
%558 = mul nsw i32 %556, %557
%559 = add nsw i32 %555, %558
%560 = load i32, i32* %66
%561 = sub nsw i32 %560, 1
%562 = load i32, i32* %74
%563 = mul nsw i32 %561, %562
%564 = add nsw i32 %559, %563
%565 = load i32, i32* %67
%566 = add nsw i32 %564, %565
%567 = mul nsw i32 %552, %566
store i32 %567, i32* %70
%568 = load i32, i32* %64
%569 = load i32, i32* %65
%570 = add nsw i32 %568, %569
%571 = load i32, i32* %66
%572 = add nsw i32 %570, %571
%573 = load i32, i32* %67
%574 = add nsw i32 %572, %573
store i32 %574, i32* %71
%575 = load double*, double** %47
%576 = load i32, i32* %69
%577 = load i32, i32* %71
%578 = add nsw i32 %576, %577
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds double, double* %575, i64 %579
%581 = load double, double* %580
%582 = load double*, double** %47
%583 = load i32, i32* %68
%584 = load i32, i32* %71
%585 = add nsw i32 %583, %584
%586 = sext i32 %585 to i64
%587 = getelementptr inbounds double, double* %582, i64 %586
store double %581, double* %587
%588 = load double*, double** %48
%589 = load i32, i32* %69
%590 = load i32, i32* %71
%591 = add nsw i32 %589, %590
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds double, double* %588, i64 %592
%594 = load double, double* %593
%595 = load double*, double** %48
%596 = load i32, i32* %68
%597 = load i32, i32* %71
%598 = add nsw i32 %596, %597
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds double, double* %595, i64 %599
store double %594, double* %600
%601 = load double*, double** %49
%602 = load i32, i32* %69
%603 = load i32, i32* %71
%604 = add nsw i32 %602, %603
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds double, double* %601, i64 %605
%607 = load double, double* %606
%608 = load double*, double** %49
%609 = load i32, i32* %68
%610 = load i32, i32* %71
%611 = add nsw i32 %609, %610
%612 = sext i32 %611 to i64
%613 = getelementptr inbounds double, double* %608, i64 %612
store double %607, double* %613
%614 = load i32, i32* %71
%615 = sub nsw i32 %614, 1
store i32 %615, i32* %71
br label %616
616: ; preds = %695, %513
%617 = load i32, i32* %71
%618 = icmp sge i32 %617, 0
br i1 %618, label %619, label %698
619: ; preds = %616
%620 = load double*, double** %47
%621 = load i32, i32* %69
%622 = load i32, i32* %71
%623 = add nsw i32 %621, %622
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %620, i64 %624
%626 = load double, double* %625
%627 = load double, double* %37
%628 = load double, double* %42
%629 = fsub double %627, %628
%630 = load double*, double** %47
%631 = load i32, i32* %70
%632 = load i32, i32* %71
%633 = add nsw i32 %631, %632
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds double, double* %630, i64 %634
%636 = load double, double* %635
%637 = fneg double %629
%638 = call double @llvm.fmuladd.f64(double %637, double %636, double %626)
%639 = load double*, double** %47
%640 = load i32, i32* %68
%641 = load i32, i32* %71
%642 = add nsw i32 %640, %641
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds double, double* %639, i64 %643
store double %638, double* %644
%645 = load double*, double** %48
%646 = load i32, i32* %69
%647 = load i32, i32* %71
%648 = add nsw i32 %646, %647
%649 = sext i32 %648 to i64
%650 = getelementptr inbounds double, double* %645, i64 %649
%651 = load double, double* %650
%652 = load double, double* %38
%653 = load double, double* %43
%654 = fsub double %652, %653
%655 = load double*, double** %48
%656 = load i32, i32* %70
%657 = load i32, i32* %71
%658 = add nsw i32 %656, %657
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %655, i64 %659
%661 = load double, double* %660
%662 = fneg double %654
%663 = call double @llvm.fmuladd.f64(double %662, double %661, double %651)
%664 = load double*, double** %48
%665 = load i32, i32* %68
%666 = load i32, i32* %71
%667 = add nsw i32 %665, %666
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds double, double* %664, i64 %668
store double %663, double* %669
%670 = load double*, double** %49
%671 = load i32, i32* %69
%672 = load i32, i32* %71
%673 = add nsw i32 %671, %672
%674 = sext i32 %673 to i64
%675 = getelementptr inbounds double, double* %670, i64 %674
%676 = load double, double* %675
%677 = load double, double* %39
%678 = load double, double* %44
%679 = fsub double %677, %678
%680 = load double*, double** %49
%681 = load i32, i32* %70
%682 = load i32, i32* %71
%683 = add nsw i32 %681, %682
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds double, double* %680, i64 %684
%686 = load double, double* %685
%687 = fneg double %679
%688 = call double @llvm.fmuladd.f64(double %687, double %686, double %676)
%689 = load double*, double** %49
%690 = load i32, i32* %68
%691 = load i32, i32* %71
%692 = add nsw i32 %690, %691
%693 = sext i32 %692 to i64
%694 = getelementptr inbounds double, double* %689, i64 %693
store double %688, double* %694
br label %695
695: ; preds = %619
%696 = load i32, i32* %71
%697 = add nsw i32 %696, -1
store i32 %697, i32* %71
br label %616
698: ; preds = %616
br label %771
699: ; preds = %509, %506
%700 = load i32, i32* %51
%701 = add nsw i32 %700, 1
%702 = mul nsw i32 4, %701
%703 = load i32, i32* %64
%704 = load i32, i32* %72
%705 = mul nsw i32 %703, %704
%706 = load i32, i32* %65
%707 = load i32, i32* %73
%708 = mul nsw i32 %706, %707
%709 = add nsw i32 %705, %708
%710 = load i32, i32* %66
%711 = load i32, i32* %74
%712 = mul nsw i32 %710, %711
%713 = add nsw i32 %709, %712
%714 = load i32, i32* %67
%715 = add nsw i32 %713, %714
%716 = mul nsw i32 %702, %715
store i32 %716, i32* %68
%717 = load double*, double** %47
%718 = load i32, i32* %68
%719 = sext i32 %718 to i64
%720 = getelementptr inbounds double, double* %717, i64 %719
%721 = load i32, i32* %64
%722 = load i32, i32* %65
%723 = load i32, i32* %66
%724 = load i32, i32* %67
%725 = load double, double* %55
%726 = load double, double* %27
%727 = load double, double* %32
%728 = load double, double* %58
%729 = load double, double* %37
%730 = load double, double* %42
%731 = load double, double* %61
%732 = load double, double* %62
%733 = load double, double* %63
%734 = call i32 @eriB_1d(double* %720, i32 %721, i32 %722, i32 %723, i32 %724, double %725, double %726, double %727, double %728, double %729, double %730, double %731, double %732, double %733)
%735 = load double*, double** %48
%736 = load i32, i32* %68
%737 = sext i32 %736 to i64
%738 = getelementptr inbounds double, double* %735, i64 %737
%739 = load i32, i32* %64
%740 = load i32, i32* %65
%741 = load i32, i32* %66
%742 = load i32, i32* %67
%743 = load double, double* %56
%744 = load double, double* %28
%745 = load double, double* %33
%746 = load double, double* %59
%747 = load double, double* %38
%748 = load double, double* %43
%749 = load double, double* %61
%750 = load double, double* %62
%751 = load double, double* %63
%752 = call i32 @eriB_1d(double* %738, i32 %739, i32 %740, i32 %741, i32 %742, double %743, double %744, double %745, double %746, double %747, double %748, double %749, double %750, double %751)
%753 = load double*, double** %49
%754 = load i32, i32* %68
%755 = sext i32 %754 to i64
%756 = getelementptr inbounds double, double* %753, i64 %755
%757 = load i32, i32* %64
%758 = load i32, i32* %65
%759 = load i32, i32* %66
%760 = load i32, i32* %67
%761 = load double, double* %57
%762 = load double, double* %29
%763 = load double, double* %34
%764 = load double, double* %60
%765 = load double, double* %39
%766 = load double, double* %44
%767 = load double, double* %61
%768 = load double, double* %62
%769 = load double, double* %63
%770 = call i32 @eriB_1d(double* %756, i32 %757, i32 %758, i32 %759, i32 %760, double %761, double %762, double %763, double %764, double %765, double %766, double %767, double %768, double %769)
br label %771
771: ; preds = %699, %698
br label %772
772: ; preds = %771
%773 = load i32, i32* %67
%774 = add nsw i32 %773, 1
store i32 %774, i32* %67
br label %501
775: ; preds = %501
br label %776
776: ; preds = %775
%777 = load i32, i32* %66
%778 = add nsw i32 %777, 1
store i32 %778, i32* %66
br label %495
779: ; preds = %495
br label %780
780: ; preds = %779, %493
br label %781
781: ; preds = %780
%782 = load i32, i32* %65
%783 = add nsw i32 %782, 1
store i32 %783, i32* %65
br label %276
784: ; preds = %276
br label %785
785: ; preds = %784
%786 = load i32, i32* %64
%787 = add nsw i32 %786, 1
store i32 %787, i32* %64
br label %270
788: ; preds = %270
%789 = load double, double* %75
store double %789, double* %26
br label %790
790: ; preds = %788, %258
%791 = load double, double* %26
ret double %791
}

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