#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 genSetBxyzSxyzF(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 *Sx,
                       double *Sy, double *Sz, 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;
  register double xSum, ySum, zSum;
  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];
            }
            n = a + b + c + d;
            for (k = maxa + maxb + maxc + maxd - n; k >= 0; k--) {
              xSum = ySum = zSum = 0.0;
              for (j = n; j >= 0; j--) {
                xSum += Bx[i + j] * F[k + j];
                ySum += By[i + j] * F[k + j];
                zSum += Bz[i + j] * F[k + j];
              }
              Sx[i + k] = xSum;
              Sy[i + k] = ySum;
              Sz[i + k] = zSum;
            }
          }
      } 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];
              }
              n = a + b + c + d;
              for (k = maxa + maxb + maxc + maxd - n; k >= 0; k--) {
                xSum = ySum = zSum = 0.0;
                for (j = n; j >= 0; j--) {
                  xSum += Bx[i + j] * F[k + j];
                  ySum += By[i + j] * F[k + j];
                  zSum += Bz[i + j] * F[k + j];
                }
                Sx[i + k] = xSum;
                Sy[i + k] = ySum;
                Sz[i + k] = zSum;
              }
            } 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);
              n = a + b + c + d;
              for (k = maxa + maxb + maxc + maxd - n; k >= 0; k--) {
                xSum = ySum = zSum = 0.0;
                for (j = n; j >= 0; j--) {
                  xSum += Bx[i + j] * F[k + j];
                  ySum += By[i + j] * F[k + j];
                  zSum += Bz[i + j] * F[k + j];
                }
                Sx[i + k] = xSum;
                Sy[i + k] = ySum;
                Sz[i + k] = zSum;
              }
            }
  return t;
}


x86 assembly (clang, -O0):
<genSetBxyzSxyzF>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    0x78(%rbp),%eax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
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  0x1e40(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x28(%rbp),%xmm1
addsd  0x48(%rbp),%xmm1
movsd  0x1e22(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x30(%rbp),%xmm1
addsd  -0x58(%rbp),%xmm1
movsd  0x1dfc(%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  0x1b8c(%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    0x70(%rbp),%rsi
call   1030 <fgamma_set@plt>
movsd  0x1b47(%rip),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mulsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%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  -0x130(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%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  -0x128(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  0x1a6f(%rip),%xmm0
ucomisd -0x108(%rbp),%xmm0
ff
jbe    15ac <genSetBxyzSxyzF+0x46c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    24be <genSetBxyzSxyzF+0x137e>
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    24b1 <genSetBxyzSxyzF+0x1371>
movl   $0x0,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2498 <genSetBxyzSxyzF+0x1358>
cmpl   $0x0,-0xd4(%rbp)
je     1b8d <genSetBxyzSxyzF+0xa4d>
mov    -0xd8(%rbp),%eax
cmp    -0x4c(%rbp),%eax
je     1b8d <genSetBxyzSxyzF+0xa4d>
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1b88 <genSetBxyzSxyzF+0xa48>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1b6f <genSetBxyzSxyzF+0xa2f>
mov    0x78(%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    0x78(%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    0x78(%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     1979 <genSetBxyzSxyzF+0x839>
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    1805 <genSetBxyzSxyzF+0x6c5>
mov    -0xd4(%rbp),%eax
add    -0xd8(%rbp),%eax
add    -0xdc(%rbp),%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x24(%rbp),%eax
add    -0x4c(%rbp),%eax
add    -0x5c(%rbp),%eax
add    -0x60(%rbp),%eax
sub    -0xf0(%rbp),%eax
mov    %eax,-0xec(%rbp)
cmpl   $0x0,-0xec(%rbp)
jl     1b56 <genSetBxyzSxyzF+0xa16>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0xf0(%rbp),%eax
mov    %eax,-0xe8(%rbp)
cmpl   $0x0,-0xe8(%rbp)
jl     1ae2 <genSetBxyzSxyzF+0x9a2>
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    19e9 <genSetBxyzSxyzF+0x8a9>
movsd  -0x110(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xec(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xec(%rbp)
jmp    19af <genSetBxyzSxyzF+0x86f>
jmp    1b5b <genSetBxyzSxyzF+0xa1b>
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1662 <genSetBxyzSxyzF+0x522>
jmp    1b74 <genSetBxyzSxyzF+0xa34>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1644 <genSetBxyzSxyzF+0x504>
jmp    247f <genSetBxyzSxyzF+0x133f>
movl   $0x0,-0xdc(%rbp)
mov    -0xdc(%rbp),%eax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    247a <genSetBxyzSxyzF+0x133a>
movl   $0x0,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    -0x60(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2461 <genSetBxyzSxyzF+0x1321>
cmpl   $0x0,-0xdc(%rbp)
je     20ca <genSetBxyzSxyzF+0xf8a>
mov    -0xe0(%rbp),%eax
cmp    -0x60(%rbp),%eax
je     20ca <genSetBxyzSxyzF+0xf8a>
mov    0x78(%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    0x78(%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    0x78(%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     1ee8 <genSetBxyzSxyzF+0xda8>
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    1d74 <genSetBxyzSxyzF+0xc34>
mov    -0xd4(%rbp),%eax
add    -0xd8(%rbp),%eax
add    -0xdc(%rbp),%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x24(%rbp),%eax
add    -0x4c(%rbp),%eax
add    -0x5c(%rbp),%eax
add    -0x60(%rbp),%eax
sub    -0xf0(%rbp),%eax
mov    %eax,-0xec(%rbp)
cmpl   $0x0,-0xec(%rbp)
jl     20c5 <genSetBxyzSxyzF+0xf85>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0xf0(%rbp),%eax
mov    %eax,-0xe8(%rbp)
cmpl   $0x0,-0xe8(%rbp)
jl     2051 <genSetBxyzSxyzF+0xf11>
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    1f58 <genSetBxyzSxyzF+0xe18>
movsd  -0x110(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xec(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xec(%rbp)
jmp    1f1e <genSetBxyzSxyzF+0xdde>
jmp    2448 <genSetBxyzSxyzF+0x1308>
mov    0x78(%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>
mov    -0xd4(%rbp),%eax
add    -0xd8(%rbp),%eax
add    -0xdc(%rbp),%eax
add    -0xe0(%rbp),%eax
mov    %eax,-0xf0(%rbp)
mov    -0x24(%rbp),%eax
add    -0x4c(%rbp),%eax
add    -0x5c(%rbp),%eax
add    -0x60(%rbp),%eax
sub    -0xf0(%rbp),%eax
mov    %eax,-0xec(%rbp)
cmpl   $0x0,-0xec(%rbp)
jl     2443 <genSetBxyzSxyzF+0x1303>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0xf0(%rbp),%eax
mov    %eax,-0xe8(%rbp)
cmpl   $0x0,-0xe8(%rbp)
jl     23cf <genSetBxyzSxyzF+0x128f>
mov    -0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x110(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x70(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xec(%rbp),%ecx
add    -0xe8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0xe8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe8(%rbp)
jmp    22d6 <genSetBxyzSxyzF+0x1196>
movsd  -0x110(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x118(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x120(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0xe4(%rbp),%ecx
add    -0xec(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xec(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xec(%rbp)
jmp    229c <genSetBxyzSxyzF+0x115c>
jmp    2448 <genSetBxyzSxyzF+0x1308>
jmp    244d <genSetBxyzSxyzF+0x130d>
mov    -0xe0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe0(%rbp)
jmp    1bb5 <genSetBxyzSxyzF+0xa75>
jmp    2466 <genSetBxyzSxyzF+0x1326>
mov    -0xdc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xdc(%rbp)
jmp    1b97 <genSetBxyzSxyzF+0xa57>
jmp    247f <genSetBxyzSxyzF+0x133f>
jmp    2484 <genSetBxyzSxyzF+0x1344>
mov    -0xd8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd8(%rbp)
jmp    160a <genSetBxyzSxyzF+0x4ca>
jmp    249d <genSetBxyzSxyzF+0x135d>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    15ec <genSetBxyzSxyzF+0x4ac>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<genSetBxyzSxyzF>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3a8,%rsp
mov    %r9,0x10(%rsp)
mov    %r8,0x48(%rsp)
movapd %xmm6,%xmm12
movapd %xmm5,%xmm9
movapd %xmm4,%xmm5
mov    %edi,%ebx
movapd %xmm2,%xmm6
movsd  0x418(%rsp),%xmm2
movsd  0x3f8(%rsp),%xmm4
movsd  0x3e8(%rsp),%xmm8
movsd  0x3e0(%rsp),%xmm13
movapd %xmm3,0xc0(%rsp)
unpcklpd %xmm4,%xmm3
movapd %xmm7,0xf0(%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  0x3f0(%rsp),%xmm2
movapd %xmm6,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm3,%xmm7
movapd %xmm3,%xmm8
addpd  %xmm10,%xmm8
movsd  0x1e26(%rip),%xmm3
mulsd  %xmm8,%xmm3
movapd %xmm8,%xmm14
unpckhpd %xmm8,%xmm14
mulsd  %xmm3,%xmm14
movsd  0x400(%rsp),%xmm15
movapd %xmm5,%xmm3
unpcklpd %xmm15,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm11
movsd  0x408(%rsp),%xmm2
movapd %xmm9,%xmm3
unpcklpd %xmm2,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm13
movsd  0x410(%rsp),%xmm4
movapd %xmm12,%xmm3
unpcklpd %xmm4,%xmm3
mulpd  %xmm10,%xmm3
addpd  %xmm3,%xmm7
movapd %xmm0,0x340(%rsp)
movapd %xmm0,%xmm3
movapd %xmm5,0x370(%rsp)
subsd  %xmm5,%xmm3
movapd %xmm1,0x350(%rsp)
movapd %xmm1,%xmm0
movapd %xmm9,0x380(%rsp)
subsd  %xmm9,%xmm0
movapd %xmm0,0x230(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm3,0x240(%rsp)
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm6,0x360(%rsp)
movapd %xmm12,0x390(%rsp)
subsd  %xmm12,%xmm6
movapd %xmm6,0x220(%rsp)
mulsd  %xmm6,%xmm6
addsd  %xmm1,%xmm6
movapd %xmm6,0x60(%rsp)
movsd  0x3e0(%rsp),%xmm1
subsd  %xmm15,%xmm1
movsd  0x3e8(%rsp),%xmm0
subsd  %xmm2,%xmm0
movapd %xmm0,0x200(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm1,0x210(%rsp)
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x3f0(%rsp),%xmm12
subsd  %xmm4,%xmm12
movapd %xmm12,0x1f0(%rsp)
mulsd  %xmm12,%xmm12
addsd  %xmm1,%xmm12
movapd %xmm12,0x50(%rsp)
movapd 0x1cac(%rip),%xmm0
divpd  %xmm8,%xmm0
mulpd  %xmm0,%xmm11
mulpd  %xmm0,%xmm13
movapd %xmm0,%xmm3
movapd %xmm0,0x150(%rsp)
movapd %xmm11,%xmm0
unpckhpd %xmm11,%xmm0
movapd %xmm11,0x330(%rsp)
movapd %xmm11,%xmm1
movapd %xmm0,0x300(%rsp)
subsd  %xmm0,%xmm1
movapd %xmm13,%xmm2
unpckhpd %xmm13,%xmm2
movapd %xmm13,0x320(%rsp)
movapd %xmm13,%xmm0
movapd %xmm2,0x2f0(%rsp)
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulpd  %xmm3,%xmm7
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
movapd %xmm7,0x310(%rsp)
movapd %xmm7,%xmm0
movapd %xmm2,0x2e0(%rsp)
subsd  %xmm2,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x440(%rsp),%rbp
movsd  0x3f8(%rsp),%xmm1
addsd  %xmm1,%xmm8
movsd  0x418(%rsp),%xmm1
addsd  %xmm1,%xmm8
movapd %xmm8,0x160(%rsp)
divsd  %xmm8,%xmm14
mulsd  0x1bf7(%rip),%xmm0
movapd %xmm14,0x250(%rsp)
mulsd  %xmm14,%xmm0
mov    %rsi,0x178(%rsp)
lea    (%rsi,%rbx,1),%edi
mov    %rdx,0x110(%rsp)
add    %edx,%edi
mov    %rcx,0x118(%rsp)
add    %ecx,%edi
mov    %edi,0x1c(%rsp)
mov    %rbp,%rsi
call   1030 <fgamma_set@plt>
movsd  0x1bbd(%rip),%xmm0
movapd 0x150(%rsp),%xmm1
mulsd  %xmm1,%xmm0
unpckhpd %xmm1,%xmm1
movapd %xmm1,0x1e0(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x30(%rsp)
movapd 0x160(%rsp),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     14b0 <genSetBxyzSxyzF+0x370>
sqrtsd %xmm0,%xmm0
jmp    14b5 <genSetBxyzSxyzF+0x375>
call   1050 <sqrt@plt>
movapd 0xc0(%rsp),%xmm1
xorpd  0x1b4a(%rip),%xmm1
movapd 0x30(%rsp),%xmm2
divsd  %xmm0,%xmm2
movapd %xmm2,0x30(%rsp)
mulsd  0xf0(%rsp),%xmm1
mulsd  0x60(%rsp),%xmm1
movsd  0x3f8(%rsp),%xmm0
movsd  0x418(%rsp),%xmm2
mulsd  %xmm2,%xmm0
mulsd  0x50(%rsp),%xmm0
mulsd  0x1e0(%rsp),%xmm0
mulsd  0x150(%rsp),%xmm1
subsd  %xmm0,%xmm1
movapd %xmm1,%xmm0
call   1040 <exp@plt>
mulsd  0x30(%rsp),%xmm0
movsd  0x1b0a(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm1,%xmm1
ja     23bb <genSetBxyzSxyzF+0x127b>
test   %ebx,%ebx
js     23b7 <genSetBxyzSxyzF+0x1277>
movsd  %xmm0,0x260(%rsp)
mov    0x448(%rsp),%r8d
mov    0x118(%rsp),%r10
lea    0x1(%r10),%esi
mov    0x110(%rsp),%rax
lea    0x1(%rax),%r11d
mov    %esi,%ebp
imul   %r11d,%ebp
mov    0x178(%rsp),%rdi
lea    0x1(%rdi),%ecx
mov    %ebp,%edx
imul   %ecx,%edx
lea    0x4(,%r8,4),%r9d
movapd 0x1a7d(%rip),%xmm0
movapd 0x240(%rsp),%xmm4
xorpd  %xmm0,%xmm4
movapd 0x230(%rsp),%xmm5
xorpd  %xmm0,%xmm5
movapd 0x220(%rsp),%xmm6
xorpd  %xmm0,%xmm6
movapd 0x210(%rsp),%xmm7
xorpd  %xmm0,%xmm7
movapd 0x200(%rsp),%xmm8
xorpd  %xmm0,%xmm8
movapd 0x1f0(%rsp),%xmm9
xorpd  %xmm0,%xmm9
mov    %esi,0xa4(%rsp)
movslq %esi,%rsi
movslq %r9d,%rax
movslq %edx,%r8
add    $0x1,%ebx
mov    %ecx,%edx
mov    %rdx,0x290(%rsp)
mov    %r11d,%edx
mov    %rdx,0x1c8(%rsp)
mov    %eax,%edx
imul   %esi,%edx
mov    %edx,0xbc(%rsp)
imul   %r11d,%edx
mov    %edx,0x148(%rsp)
imul   %ecx,%edx
mov    %edx,0x140(%rsp)
neg    %edx
mov    %edx,0x90(%rsp)
imul   %esi,%ecx
neg    %ecx
add    %r10d,%ecx
add    $0x1,%ecx
imul   %eax,%ecx
imul   %r11d,%ecx
mov    %ecx,0x8c(%rsp)
mov    %r10d,%ecx
not    %ecx
imul   %eax,%ecx
mov    %ecx,0x88(%rsp)
mov    %r10d,%ecx
imul   %eax,%ecx
neg    %ecx
mov    %ecx,0x84(%rsp)
mov    %r8,0x268(%rsp)
imul   %rax,%r8
shl    $0x3,%r8
mov    %r8,0x270(%rsp)
mov    %ebp,0x144(%rsp)
movslq %ebp,%rcx
mov    %rcx,0x278(%rsp)
imul   %rax,%rcx
shl    $0x3,%rcx
mov    %rcx,0x288(%rsp)
mov    %rax,%rcx
imul   %rsi,%rcx
shl    $0x3,%rcx
mov    %rcx,0x2b0(%rsp)
mov    0x420(%rsp),%rcx
movslq 0x1c(%rsp),%rdx
mov    %rdx,0x138(%rsp)
mov    %r10d,%edx
mov    %rdx,0x2d0(%rsp)
mov    %edi,%edx
mov    %rdx,0x280(%rsp)
mov    %rsi,0x2a0(%rsp)
mov    %esi,%edx
mov    %rdx,0x1d8(%rsp)
mov    %rax,0x2b8(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x2d8(%rsp)
xor    %eax,%eax
mov    %rax,0x108(%rsp)
mov    %rcx,0x190(%rsp)
mov    0x10(%rsp),%rax
mov    %rax,0x188(%rsp)
mov    0x48(%rsp),%rax
mov    %rax,0x180(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
mov    %rbx,0x298(%rsp)
mov    %r9d,0x160(%rsp)
movapd %xmm4,0x240(%rsp)
movapd %xmm5,0x230(%rsp)
movapd %xmm6,0x220(%rsp)
movapd %xmm7,0x210(%rsp)
movapd %xmm8,0x200(%rsp)
movapd %xmm9,0x1f0(%rsp)
jmp    1804 <genSetBxyzSxyzF+0x6c4>
nopl   0x0(%rax)
mov    0x50(%rsp),%rdx
add    $0x1,%rdx
addl   $0xffffffff,0x1c(%rsp)
mov    0x140(%rsp),%eax
mov    0x108(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,0x108(%rsp)
add    %eax,0x90(%rsp)
add    %eax,0x8c(%rsp)
add    %eax,0x88(%rsp)
add    %eax,0x84(%rsp)
mov    0x270(%rsp),%rax
add    %rax,0x180(%rsp)
add    %rax,0x188(%rsp)
add    %rax,0x190(%rsp)
mov    %rdx,%rax
mov    %rdx,0x50(%rsp)
cmp    %rbx,%rdx
je     23ac <genSetBxyzSxyzF+0x126c>
cmpl   $0x0,0x178(%rsp)
js     1790 <genSetBxyzSxyzF+0x650>
mov    0x50(%rsp),%rdx
mov    %rdx,%rax
mov    0x268(%rsp),%rcx
imul   %rcx,%rax
mov    %rax,0x1d0(%rsp)
lea    -0x1(%rdx),%eax
imul   %eax,%ecx
mov    %ecx,0x14c(%rsp)
mov    0x190(%rsp),%rax
mov    %rax,0x1a8(%rsp)
mov    0x188(%rsp),%rax
mov    %rax,0x1a0(%rsp)
mov    0x180(%rsp),%rax
mov    %rax,0x198(%rsp)
mov    0x84(%rsp),%eax
mov    %eax,0xa0(%rsp)
mov    0x88(%rsp),%eax
mov    %eax,0x9c(%rsp)
mov    0x8c(%rsp),%eax
mov    %eax,0x98(%rsp)
mov    0x90(%rsp),%eax
mov    %eax,0x94(%rsp)
mov    0x108(%rsp),%rax
mov    %eax,0x28(%rsp)
xor    %eax,%eax
mov    %rax,0x60(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,0x24(%rsp)
mov    %edx,%eax
mov    %edx,0x20(%rsp)
jmp    1948 <genSetBxyzSxyzF+0x808>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x60(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x20(%rsp)
addl   $0xffffffff,0x24(%rsp)
mov    0x148(%rsp),%eax
add    %eax,0x28(%rsp)
add    %eax,0x94(%rsp)
add    %eax,0x98(%rsp)
add    %eax,0x9c(%rsp)
add    %eax,0xa0(%rsp)
mov    0x288(%rsp),%rax
add    %rax,0x198(%rsp)
add    %rax,0x1a0(%rsp)
add    %rax,0x1a8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x60(%rsp)
cmp    0x290(%rsp),%rcx
mov    0x298(%rsp),%rbx
je     1790 <genSetBxyzSxyzF+0x650>
cmpq   $0x0,0x50(%rsp)
je     1cb0 <genSetBxyzSxyzF+0xb70>
mov    0x60(%rsp),%rax
cmp    0x280(%rsp),%rax
je     1cb0 <genSetBxyzSxyzF+0xb70>
cmpl   $0x0,0x110(%rsp)
js     18d0 <genSetBxyzSxyzF+0x790>
mov    0x50(%rsp),%rax
mov    0x60(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x120(%rsp)
mov    0x144(%rsp),%eax
mov    %eax,%edx
imul   %ecx,%edx
mov    %edx,0x2c(%rsp)
add    $0x1,%ecx
imul   %eax,%ecx
mov    %ecx,0xc(%rsp)
mov    0x98(%rsp),%eax
mov    %eax,0x78(%rsp)
mov    0x94(%rsp),%eax
mov    %eax,0xe8(%rsp)
mov    0x28(%rsp),%eax
mov    %eax,0xe0(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    0x24(%rsp),%eax
mov    %eax,0xd8(%rsp)
mov    0x20(%rsp),%eax
mov    %eax,0x70(%rsp)
jmp    1a35 <genSetBxyzSxyzF+0x8f5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x70(%rsp)
addl   $0xffffffff,0xd8(%rsp)
ff
mov    0xbc(%rsp),%eax
add    %eax,0xe0(%rsp)
add    %eax,0xe8(%rsp)
add    %eax,0x78(%rsp)
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
cmp    0x1c8(%rsp),%rcx
je     18d0 <genSetBxyzSxyzF+0x790>
cmpl   $0x0,0x118(%rsp)
js     19f0 <genSetBxyzSxyzF+0x8b0>
movslq 0x70(%rsp),%r14
add    $0x1,%r14
mov    0x120(%rsp),%rax
mov    0x40(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x130(%rsp)
mov    0xa4(%rsp),%eax
imul   %ecx,%eax
mov    %rax,0x128(%rsp)
mov    0x78(%rsp),%eax
mov    %eax,0xc0(%rsp)
mov    0xe8(%rsp),%eax
mov    %eax,0xf0(%rsp)
mov    0xe0(%rsp),%r13d
xor    %r8d,%r8d
mov    0xd8(%rsp),%edi
jmp    1ad4 <genSetBxyzSxyzF+0x994>
nop
add    $0x1,%r8
add    $0xffffffff,%edi
add    $0x1,%r14
mov    0x160(%rsp),%r9d
add    %r9d,%r13d
add    %r9d,0xf0(%rsp)
add    %r9d,0xc0(%rsp)
cmp    0x1d8(%rsp),%r8
je     19f0 <genSetBxyzSxyzF+0x8b0>
mov    %edi,0x30(%rsp)
movslq %r13d,%rax
mov    0x128(%rsp),%rcx
add    %r8d,%ecx
mov    0x1d0(%rsp),%rdx
add    %ecx,%edx
add    0x2c(%rsp),%edx
imul   %r9d,%edx
add    0x14c(%rsp),%ecx
add    0xc(%rsp),%ecx
imul   %r9d,%ecx
mov    0x130(%rsp),%rsi
lea    (%rsi,%r8,1),%r12
movslq %ecx,%rcx
add    %r12,%rcx
mov    0x48(%rsp),%rdi
movsd  (%rdi,%rcx,8),%xmm0
movslq %edx,%r10
lea    (%r12,%r10,1),%rdx
movsd  %xmm0,(%rdi,%rdx,8)
mov    0x10(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x420(%rsp),%rbx
movsd  (%rbx,%rcx,8),%xmm0
lea    (%rdi,%rax,8),%r11
movsd  %xmm0,(%rbx,%rdx,8)
lea    (%rsi,%rax,8),%r9
lea    (%rbx,%rax,8),%r15
test   %r12,%r12
je     1bff <genSetBxyzSxyzF+0xabf>
movslq 0xf0(%rsp),%rcx
mov    0x48(%rsp),%rbx
lea    (%rbx,%rcx,8),%rbp
mov    0x10(%rsp),%rdi
lea    (%rdi,%rcx,8),%rax
mov    0x420(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
movslq 0xc0(%rsp),%rdx
lea    (%rbx,%rdx,8),%rbx
lea    (%rdi,%rdx,8),%rcx
mov    0x420(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
mov    %r14,%rdi
nopw   0x0(%rax,%rax,1)
movsd  -0x10(%rbp,%rdi,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  -0x10(%rbx,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%r11,%rdi,8)
movsd  -0x10(%rax,%rdi,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  -0x10(%rcx,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%r9,%rdi,8)
movsd  -0x10(%rsi,%rdi,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  -0x10(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%r15,%rdi,8)
add    $0xffffffffffffffff,%rdi
cmp    $0x1,%rdi
jg     1bb0 <genSetBxyzSxyzF+0xa70>
cmp    0x138(%rsp),%r12
mov    0x430(%rsp),%rsi
mov    0x30(%rsp),%edi
jg     1aa0 <genSetBxyzSxyzF+0x960>
movslq %edi,%rdx
mov    0x440(%rsp),%rax
lea    (%rax,%rdx,8),%r12
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    %r14,%rax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r12,%rax,8),%xmm2
movsd  -0x8(%r11,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
movsd  -0x8(%r15,%rax,8),%xmm3
movhpd -0x8(%r9,%rax,8),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rax
jg     1c40 <genSetBxyzSxyzF+0xb00>
lea    (%rdx,%r10,1),%rax
mov    0x428(%rsp),%rcx
movsd  %xmm1,(%rcx,%rax,8)
movhpd %xmm0,(%rsi,%rax,8)
mov    0x438(%rsp),%rcx
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x1(%rdx),%rax
add    $0xfffffffffffffff8,%r12
test   %rdx,%rdx
mov    %rax,%rdx
jg     1c30 <genSetBxyzSxyzF+0xaf0>
jmp    1aa0 <genSetBxyzSxyzF+0x960>
xchg   %ax,%ax
cmpl   $0x0,0x110(%rsp)
js     18d0 <genSetBxyzSxyzF+0x790>
mov    0x60(%rsp),%rcx
mov    %rcx,%rax
imul   0x278(%rsp),%rax
add    0x1d0(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x50(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x2a8(%rsp)
mov    0x1a8(%rsp),%rax
mov    %rax,0x1c0(%rsp)
mov    0x1a0(%rsp),%rax
mov    %rax,0x1b8(%rsp)
mov    0x198(%rsp),%rax
mov    %rax,0x1b0(%rsp)
mov    0xa0(%rsp),%eax
mov    %eax,0xb8(%rsp)
mov    0x9c(%rsp),%eax
mov    %eax,0xb4(%rsp)
mov    0x28(%rsp),%eax
mov    %eax,0xb0(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    0x24(%rsp),%eax
mov    %eax,0xac(%rsp)
mov    0x20(%rsp),%eax
mov    %eax,0xa8(%rsp)
jmp    1ddb <genSetBxyzSxyzF+0xc9b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x30(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0xa8(%rsp)
01
addl   $0xffffffff,0xac(%rsp)
ff
mov    0xbc(%rsp),%eax
add    %eax,0xb0(%rsp)
add    %eax,0xb4(%rsp)
add    %eax,0xb8(%rsp)
mov    0x2b0(%rsp),%rax
add    %rax,0x1b0(%rsp)
add    %rax,0x1b8(%rsp)
add    %rax,0x1c0(%rsp)
mov    %rcx,%rax
mov    %rcx,0x30(%rsp)
cmp    0x1c8(%rsp),%rcx
je     18d0 <genSetBxyzSxyzF+0x790>
cmpl   $0x0,0x118(%rsp)
js     1d70 <genSetBxyzSxyzF+0xc30>
mov    0x30(%rsp),%rcx
mov    %rcx,%rdx
imul   0x2a0(%rsp),%rdx
mov    0x2a8(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x78(%rsp)
mov    0x70(%rsp),%rax
mov    %rdx,0x120(%rsp)
add    %rdx,%rax
mov    %rax,0x2c8(%rsp)
lea    -0x1(%rcx),%eax
imul   0xa4(%rsp),%eax
mov    %rax,0x2c0(%rsp)
mov    0x1c0(%rsp),%r15
mov    0x1b8(%rsp),%rbp
mov    0x1b0(%rsp),%r12
mov    0xb8(%rsp),%eax
mov    %eax,0xc(%rsp)
mov    0xb4(%rsp),%eax
mov    %eax,0x40(%rsp)
mov    0xb0(%rsp),%ecx
xor    %r8d,%r8d
mov    0xac(%rsp),%edx
mov    0xa8(%rsp),%esi
jmp    1ec8 <genSetBxyzSxyzF+0xd88>
nopl   0x0(%rax)
add    $0x1,%r8
mov    0x2c(%rsp),%esi
add    $0x1,%esi
mov    0x128(%rsp),%edx
add    $0xffffffff,%edx
mov    0x130(%rsp),%ecx
add    %r9d,%ecx
add    %r9d,0x40(%rsp)
add    %r9d,0xc(%rsp)
mov    0x2d8(%rsp),%rax
add    %rax,%r12
add    %rax,%rbp
add    %rax,%r15
cmp    0x1d8(%rsp),%r8
je     1d70 <genSetBxyzSxyzF+0xc30>
mov    %esi,0x2c(%rsp)
movslq %esi,%rax
add    $0x1,%rax
mov    %rax,0xf0(%rsp)
mov    %edx,0x128(%rsp)
movslq %edx,%r13
mov    0x440(%rsp),%rax
lea    (%rax,%r13,8),%rbx
cmpq   $0x0,0x30(%rsp)
mov    %ecx,0x130(%rsp)
mov    %r8,0xc0(%rsp)
je     2140 <genSetBxyzSxyzF+0x1000>
cmp    0x2d0(%rsp),%r8
je     2140 <genSetBxyzSxyzF+0x1000>
movslq %ecx,%r10
mov    0x70(%rsp),%rax
lea    (%r8,%rax,1),%ecx
mov    0x120(%rsp),%rax
lea    (%rcx,%rax,1),%edx
imul   %r9d,%edx
mov    0x2c0(%rsp),%rax
add    %eax,%ecx
add    $0x1,%ecx
imul   %r9d,%ecx
mov    0x78(%rsp),%rax
lea    (%rax,%r8,1),%rdi
movslq %ecx,%rcx
add    %rdi,%rcx
mov    0x48(%rsp),%r8
movsd  (%r8,%rcx,8),%xmm0
movslq %edx,%rax
mov    %rax,0xe8(%rsp)
lea    (%rdi,%rax,1),%rdx
movsd  %xmm0,(%r8,%rdx,8)
mov    0x10(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x420(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
lea    (%r8,%r10,8),%rcx
movsd  %xmm0,(%rax,%rdx,8)
lea    (%rsi,%r10,8),%rdx
lea    (%rax,%r10,8),%rsi
mov    %rdi,0xe0(%rsp)
test   %edi,%edi
je     2067 <genSetBxyzSxyzF+0xf27>
movslq 0x40(%rsp),%rax
mov    0x48(%rsp),%r9
lea    (%r9,%rax,8),%rdi
mov    %rdi,0xd8(%rsp)
mov    0x10(%rsp),%rdi
lea    (%rdi,%rax,8),%r11
mov    0x420(%rsp),%rdi
lea    (%rdi,%rax,8),%r14
movslq 0xc(%rsp),%r8
lea    (%r9,%r8,8),%r10
mov    0x10(%rsp),%rdi
lea    (%rdi,%r8,8),%rdi
mov    0x420(%rsp),%rax
lea    (%rax,%r8,8),%r8
mov    0xd8(%rsp),%rax
mov    0xf0(%rsp),%r9
nopl   0x0(%rax,%rax,1)
movsd  -0x10(%rax,%r9,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  -0x10(%r10,%r9,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%r9,8)
movsd  -0x10(%r11,%r9,8),%xmm0
mulsd  %xmm8,%xmm0
addsd  -0x10(%rdi,%r9,8),%xmm0
movsd  %xmm0,-0x10(%rdx,%r9,8)
movsd  -0x10(%r14,%r9,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  -0x10(%r8,%r9,8),%xmm0
movsd  %xmm0,-0x10(%rsi,%r9,8)
add    $0xffffffffffffffff,%r9
cmp    $0x1,%r9
jg     2010 <genSetBxyzSxyzF+0xed0>
mov    0xe0(%rsp),%rax
cmp    0x138(%rsp),%rax
mov    0x160(%rsp),%r9d
mov    0x430(%rsp),%r10
mov    0xc0(%rsp),%r8
mov    0xf0(%rsp),%r11
mov    0xe8(%rsp),%r14
jg     1e80 <genSetBxyzSxyzF+0xd40>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    %r11,%rax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rax,8),%xmm2
movsd  -0x8(%rcx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
movsd  -0x8(%rsi,%rax,8),%xmm3
movhpd -0x8(%rdx,%rax,8),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rax
jg     20c0 <genSetBxyzSxyzF+0xf80>
lea    (%r14,%r13,1),%rax
mov    0x428(%rsp),%rdi
movsd  %xmm1,(%rdi,%rax,8)
movhpd %xmm0,(%r10,%rax,8)
mov    0x438(%rsp),%rdi
movlpd %xmm0,(%rdi,%rax,8)
mov    0x430(%rsp),%r10
lea    -0x1(%r13),%rax
add    $0xfffffffffffffff8,%rbx
test   %r13,%r13
mov    %rax,%r13
jg     20b0 <genSetBxyzSxyzF+0xf70>
jmp    1e80 <genSetBxyzSxyzF+0xd40>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x2c8(%rsp),%rax
lea    (%rax,%r8,1),%r14
imul   0x2b8(%rsp),%r14
mov    0x48(%rsp),%rax
lea    (%rax,%r14,8),%rdi
movaps 0x250(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x50(%rsp),%rsi
mov    %rsi,0x50(%rsp)
mov    0x60(%rsp),%rdx
mov    %rdx,0x60(%rsp)
mov    0x30(%rsp),%rcx
mov    %rcx,0x30(%rsp)
movaps 0x330(%rsp),%xmm0
movaps 0x340(%rsp),%xmm1
movaps 0x370(%rsp),%xmm2
movaps 0x300(%rsp),%xmm3
movsd  0x3e0(%rsp),%xmm4
movsd  0x400(%rsp),%xmm5
movaps 0x150(%rsp),%xmm6
movaps 0x1e0(%rsp),%xmm7
call   1060 <eriB_1d@plt>
mov    0x10(%rsp),%rax
lea    (%rax,%r14,8),%rdi
movaps 0x250(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x50(%rsp),%rsi
mov    0x60(%rsp),%rdx
mov    0x30(%rsp),%rcx
mov    0xc0(%rsp),%r8
movaps 0x320(%rsp),%xmm0
movaps 0x350(%rsp),%xmm1
movaps 0x380(%rsp),%xmm2
movaps 0x2f0(%rsp),%xmm3
movsd  0x3e8(%rsp),%xmm4
movsd  0x408(%rsp),%xmm5
movaps 0x150(%rsp),%xmm6
movaps 0x1e0(%rsp),%xmm7
call   1060 <eriB_1d@plt>
mov    0x420(%rsp),%rax
lea    (%rax,%r14,8),%rdi
movaps 0x250(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x50(%rsp),%rsi
mov    0x60(%rsp),%rdx
mov    0x30(%rsp),%rcx
mov    0xc0(%rsp),%r8
movapd 0x310(%rsp),%xmm0
movapd 0x360(%rsp),%xmm1
movapd 0x390(%rsp),%xmm2
movapd 0x2e0(%rsp),%xmm3
movsd  0x3f0(%rsp),%xmm4
movsd  0x410(%rsp),%xmm5
movaps 0x150(%rsp),%xmm6
movaps 0x1e0(%rsp),%xmm7
call   1060 <eriB_1d@plt>
mov    0xc0(%rsp),%r8
mov    0x160(%rsp),%r9d
movapd 0x1f0(%rsp),%xmm9
movapd 0x200(%rsp),%xmm8
movapd 0x210(%rsp),%xmm7
movapd 0x220(%rsp),%xmm6
movapd 0x230(%rsp),%xmm5
movapd 0x240(%rsp),%xmm4
mov    0x78(%rsp),%rax
add    %r8,%rax
cmp    0x138(%rsp),%rax
mov    0x430(%rsp),%rdx
mov    0xf0(%rsp),%rsi
jg     1e80 <genSetBxyzSxyzF+0xd40>
nopl   (%rax)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    %rsi,%rax
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rax,8),%xmm2
movsd  -0x8(%r12,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
movsd  -0x8(%r15,%rax,8),%xmm3
movhpd -0x8(%rbp,%rax,8),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rax
jg     2340 <genSetBxyzSxyzF+0x1200>
lea    (%r14,%r13,1),%rax
mov    0x428(%rsp),%rcx
movsd  %xmm1,(%rcx,%rax,8)
movhpd %xmm0,(%rdx,%rax,8)
mov    0x438(%rsp),%rcx
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x1(%r13),%rax
add    $0xfffffffffffffff8,%rbx
test   %r13,%r13
mov    %rax,%r13
jg     2330 <genSetBxyzSxyzF+0x11f0>
jmp    1e80 <genSetBxyzSxyzF+0xd40>
movsd  0x260(%rsp),%xmm1
jmp    23bb <genSetBxyzSxyzF+0x127b>
movapd %xmm0,%xmm1
movapd %xmm1,%xmm0
add    $0x3a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define double @genSetBxyzSxyzF(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, double* %24, double* %25, double* %26, i32 %27) {
%29 = alloca double
%30 = alloca double
%31 = alloca double
%32 = alloca double
%33 = alloca i32
%34 = alloca double
%35 = alloca double
%36 = alloca double
%37 = alloca double
%38 = alloca i32
%39 = alloca double
%40 = alloca double
%41 = alloca double
%42 = alloca double
%43 = alloca i32
%44 = alloca double
%45 = alloca double
%46 = alloca double
%47 = alloca double
%48 = alloca i32
%49 = alloca double
%50 = alloca double*
%51 = alloca double*
%52 = alloca double*
%53 = alloca double*
%54 = alloca double*
%55 = alloca double*
%56 = alloca double*
%57 = alloca i32
%58 = alloca double
%59 = alloca double
%60 = alloca double
%61 = alloca double
%62 = alloca double
%63 = alloca double
%64 = alloca double
%65 = alloca double
%66 = alloca double
%67 = alloca double
%68 = alloca double
%69 = alloca double
%70 = alloca i32
%71 = alloca i32
%72 = alloca i32
%73 = alloca i32
%74 = alloca i32
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
%79 = alloca i32
%80 = alloca i32
%81 = alloca double
%82 = alloca double
%83 = alloca double
%84 = alloca double
store double %0, double* %30
store double %1, double* %31
store double %2, double* %32
store i32 %3, i32* %33
store double %4, double* %34
store double %5, double* %35
store double %6, double* %36
store double %7, double* %37
store i32 %8, i32* %38
store double %9, double* %39
store double %10, double* %40
store double %11, double* %41
store double %12, double* %42
store i32 %13, i32* %43
store double %14, double* %44
store double %15, double* %45
store double %16, double* %46
store double %17, double* %47
store i32 %18, i32* %48
store double %19, double* %49
store double* %20, double** %50
store double* %21, double** %51
store double* %22, double** %52
store double* %23, double** %53
store double* %24, double** %54
store double* %25, double** %55
store double* %26, double** %56
store i32 %27, i32* %57
%85 = load double, double* %34
%86 = load double, double* %39
%87 = fadd double %85, %86
%88 = fdiv double 1.000000e+00, %87
store double %88, double* %67
%89 = load double, double* %44
%90 = load double, double* %49
%91 = fadd double %89, %90
%92 = fdiv double 1.000000e+00, %91
store double %92, double* %68
%93 = load double, double* %34
%94 = load double, double* %39
%95 = fadd double %93, %94
%96 = fmul double 4.000000e+00, %95
%97 = load double, double* %44
%98 = load double, double* %49
%99 = fadd double %97, %98
%100 = fmul double %96, %99
%101 = load double, double* %34
%102 = load double, double* %39
%103 = fadd double %101, %102
%104 = load double, double* %44
%105 = fadd double %103, %104
%106 = load double, double* %49
%107 = fadd double %105, %106
%108 = fdiv double %100, %107
store double %108, double* %69
%109 = load double, double* %34
%110 = load double, double* %30
%111 = load double, double* %39
%112 = load double, double* %35
%113 = fmul double %111, %112
%114 = call double @llvm.fmuladd.f64(double %109, double %110, double %113)
%115 = load double, double* %67
%116 = fmul double %114, %115
store double %116, double* %61
%117 = load double, double* %34
%118 = load double, double* %31
%119 = load double, double* %39
%120 = load double, double* %36
%121 = fmul double %119, %120
%122 = call double @llvm.fmuladd.f64(double %117, double %118, double %121)
%123 = load double, double* %67
%124 = fmul double %122, %123
store double %124, double* %62
%125 = load double, double* %34
%126 = load double, double* %32
%127 = load double, double* %39
%128 = load double, double* %37
%129 = fmul double %127, %128
%130 = call double @llvm.fmuladd.f64(double %125, double %126, double %129)
%131 = load double, double* %67
%132 = fmul double %130, %131
store double %132, double* %63
%133 = load double, double* %44
%134 = load double, double* %40
%135 = load double, double* %49
%136 = load double, double* %45
%137 = fmul double %135, %136
%138 = call double @llvm.fmuladd.f64(double %133, double %134, double %137)
%139 = load double, double* %68
%140 = fmul double %138, %139
store double %140, double* %64
%141 = load double, double* %44
%142 = load double, double* %41
%143 = load double, double* %49
%144 = load double, double* %46
%145 = fmul double %143, %144
%146 = call double @llvm.fmuladd.f64(double %141, double %142, double %145)
%147 = load double, double* %68
%148 = fmul double %146, %147
store double %148, double* %65
%149 = load double, double* %44
%150 = load double, double* %42
%151 = load double, double* %49
%152 = load double, double* %47
%153 = fmul double %151, %152
%154 = call double @llvm.fmuladd.f64(double %149, double %150, double %153)
%155 = load double, double* %68
%156 = fmul double %154, %155
store double %156, double* %66
%157 = load double, double* %30
%158 = load double, double* %35
%159 = fsub double %157, %158
%160 = load double, double* %30
%161 = load double, double* %35
%162 = fsub double %160, %161
%163 = load double, double* %31
%164 = load double, double* %36
%165 = fsub double %163, %164
%166 = load double, double* %31
%167 = load double, double* %36
%168 = fsub double %166, %167
%169 = fmul double %165, %168
%170 = call double @llvm.fmuladd.f64(double %159, double %162, double %169)
%171 = load double, double* %32
%172 = load double, double* %37
%173 = fsub double %171, %172
%174 = load double, double* %32
%175 = load double, double* %37
%176 = fsub double %174, %175
%177 = call double @llvm.fmuladd.f64(double %173, double %176, double %170)
store double %177, double* %58
%178 = load double, double* %40
%179 = load double, double* %45
%180 = fsub double %178, %179
%181 = load double, double* %40
%182 = load double, double* %45
%183 = fsub double %181, %182
%184 = load double, double* %41
%185 = load double, double* %46
%186 = fsub double %184, %185
%187 = load double, double* %41
%188 = load double, double* %46
%189 = fsub double %187, %188
%190 = fmul double %186, %189
%191 = call double @llvm.fmuladd.f64(double %180, double %183, double %190)
%192 = load double, double* %42
%193 = load double, double* %47
%194 = fsub double %192, %193
%195 = load double, double* %42
%196 = load double, double* %47
%197 = fsub double %195, %196
%198 = call double @llvm.fmuladd.f64(double %194, double %197, double %191)
store double %198, double* %59
%199 = load double, double* %61
%200 = load double, double* %64
%201 = fsub double %199, %200
%202 = load double, double* %61
%203 = load double, double* %64
%204 = fsub double %202, %203
%205 = load double, double* %62
%206 = load double, double* %65
%207 = fsub double %205, %206
%208 = load double, double* %62
%209 = load double, double* %65
%210 = fsub double %208, %209
%211 = fmul double %207, %210
%212 = call double @llvm.fmuladd.f64(double %201, double %204, double %211)
%213 = load double, double* %63
%214 = load double, double* %66
%215 = fsub double %213, %214
%216 = load double, double* %63
%217 = load double, double* %66
%218 = fsub double %216, %217
%219 = call double @llvm.fmuladd.f64(double %215, double %218, double %212)
store double %219, double* %60
%220 = load double, double* %60
%221 = fmul double 2.500000e-01, %220
%222 = load double, double* %69
%223 = fmul double %221, %222
store double %223, double* %81
%224 = load i32, i32* %33
%225 = load i32, i32* %38
%226 = add nsw i32 %224, %225
%227 = load i32, i32* %43
%228 = add nsw i32 %226, %227
%229 = load i32, i32* %48
%230 = add nsw i32 %228, %229
%231 = load double, double* %81
%232 = load double*, double** %56
%233 = call i32 @fgamma_set(i32 %230, double %231, double* %232)
%234 = load double, double* %67
%235 = fmul double 0x40417E50A9DC6553, %234
%236 = load double, double* %68
%237 = fmul double %235, %236
%238 = load double, double* %34
%239 = load double, double* %39
%240 = fadd double %238, %239
%241 = load double, double* %44
%242 = fadd double %240, %241
%243 = load double, double* %49
%244 = fadd double %242, %243
%245 = call double @sqrt(double %244)
%246 = fdiv double %237, %245
%247 = load double, double* %34
%248 = fneg double %247
%249 = load double, double* %39
%250 = fmul double %248, %249
%251 = load double, double* %58
%252 = fmul double %250, %251
%253 = load double, double* %67
%254 = load double, double* %44
%255 = load double, double* %49
%256 = fmul double %254, %255
%257 = load double, double* %59
%258 = fmul double %256, %257
%259 = load double, double* %68
%260 = fmul double %258, %259
%261 = fneg double %260
%262 = call double @llvm.fmuladd.f64(double %252, double %253, double %261)
%263 = call double @exp(double %262)
%264 = fmul double %246, %263
store double %264, double* %81
%265 = load double, double* %81
%266 = fcmp olt double %265, 1.000000e-15
br i1 %266, label %267, label %268
267: ; preds = %28
store double 0.000000e+00, double* %29
br label %1105
268: ; preds = %28
%269 = load i32, i32* %48
%270 = add nsw i32 %269, 1
store i32 %270, i32* %80
%271 = load i32, i32* %80
%272 = load i32, i32* %43
%273 = add nsw i32 %272, 1
%274 = mul nsw i32 %271, %273
store i32 %274, i32* %79
%275 = load i32, i32* %79
%276 = load i32, i32* %38
%277 = add nsw i32 %276, 1
%278 = mul nsw i32 %275, %277
store i32 %278, i32* %78
store i32 0, i32* %70
br label %279
279: ; preds = %1100, %268
%280 = load i32, i32* %70
%281 = load i32, i32* %33
%282 = add nsw i32 %281, 1
%283 = icmp slt i32 %280, %282
br i1 %283, label %284, label %1103
284: ; preds = %279
store i32 0, i32* %71
br label %285
285: ; preds = %1096, %284
%286 = load i32, i32* %71
%287 = load i32, i32* %38
%288 = add nsw i32 %287, 1
%289 = icmp slt i32 %286, %288
br i1 %289, label %290, label %1099
290: ; preds = %285
%291 = load i32, i32* %70
%292 = icmp ne i32 %291, 0
br i1 %292, label %293, label %605
293: ; preds = %290
%294 = load i32, i32* %71
%295 = load i32, i32* %38
%296 = icmp ne i32 %294, %295
br i1 %296, label %297, label %605
297: ; preds = %293
store i32 0, i32* %72
br label %298
298: ; preds = %601, %297
%299 = load i32, i32* %72
%300 = load i32, i32* %43
%301 = add nsw i32 %300, 1
%302 = icmp slt i32 %299, %301
br i1 %302, label %303, label %604
303: ; preds = %298
store i32 0, i32* %73
br label %304
304: ; preds = %597, %303
%305 = load i32, i32* %73
%306 = load i32, i32* %48
%307 = add nsw i32 %306, 1
%308 = icmp slt i32 %305, %307
br i1 %308, label %309, label %600
309: ; preds = %304
%310 = load i32, i32* %57
%311 = add nsw i32 %310, 1
%312 = mul nsw i32 4, %311
%313 = load i32, i32* %70
%314 = load i32, i32* %78
%315 = mul nsw i32 %313, %314
%316 = load i32, i32* %71
%317 = load i32, i32* %79
%318 = mul nsw i32 %316, %317
%319 = add nsw i32 %315, %318
%320 = load i32, i32* %72
%321 = load i32, i32* %80
%322 = mul nsw i32 %320, %321
%323 = add nsw i32 %319, %322
%324 = load i32, i32* %73
%325 = add nsw i32 %323, %324
%326 = mul nsw i32 %312, %325
store i32 %326, i32* %74
%327 = load i32, i32* %57
%328 = add nsw i32 %327, 1
%329 = mul nsw i32 4, %328
%330 = load i32, i32* %70
%331 = sub nsw i32 %330, 1
%332 = load i32, i32* %78
%333 = mul nsw i32 %331, %332
%334 = load i32, i32* %71
%335 = add nsw i32 %334, 1
%336 = load i32, i32* %79
%337 = mul nsw i32 %335, %336
%338 = add nsw i32 %333, %337
%339 = load i32, i32* %72
%340 = load i32, i32* %80
%341 = mul nsw i32 %339, %340
%342 = add nsw i32 %338, %341
%343 = load i32, i32* %73
%344 = add nsw i32 %342, %343
%345 = mul nsw i32 %329, %344
store i32 %345, i32* %75
%346 = load i32, i32* %57
%347 = add nsw i32 %346, 1
%348 = mul nsw i32 4, %347
%349 = load i32, i32* %70
%350 = sub nsw i32 %349, 1
%351 = load i32, i32* %78
%352 = mul nsw i32 %350, %351
%353 = load i32, i32* %71
%354 = load i32, i32* %79
%355 = mul nsw i32 %353, %354
%356 = add nsw i32 %352, %355
%357 = load i32, i32* %72
%358 = load i32, i32* %80
%359 = mul nsw i32 %357, %358
%360 = add nsw i32 %356, %359
%361 = load i32, i32* %73
%362 = add nsw i32 %360, %361
%363 = mul nsw i32 %348, %362
store i32 %363, i32* %76
%364 = load i32, i32* %70
%365 = load i32, i32* %71
%366 = add nsw i32 %364, %365
%367 = load i32, i32* %72
%368 = add nsw i32 %366, %367
%369 = load i32, i32* %73
%370 = add nsw i32 %368, %369
store i32 %370, i32* %77
%371 = load double*, double** %50
%372 = load i32, i32* %75
%373 = load i32, i32* %77
%374 = add nsw i32 %372, %373
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double, double* %371, i64 %375
%377 = load double, double* %376
%378 = load double*, double** %50
%379 = load i32, i32* %74
%380 = load i32, i32* %77
%381 = add nsw i32 %379, %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double, double* %378, i64 %382
store double %377, double* %383
%384 = load double*, double** %51
%385 = load i32, i32* %75
%386 = load i32, i32* %77
%387 = add nsw i32 %385, %386
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds double, double* %384, i64 %388
%390 = load double, double* %389
%391 = load double*, double** %51
%392 = load i32, i32* %74
%393 = load i32, i32* %77
%394 = add nsw i32 %392, %393
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds double, double* %391, i64 %395
store double %390, double* %396
%397 = load double*, double** %52
%398 = load i32, i32* %75
%399 = load i32, i32* %77
%400 = add nsw i32 %398, %399
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %397, i64 %401
%403 = load double, double* %402
%404 = load double*, double** %52
%405 = load i32, i32* %74
%406 = load i32, i32* %77
%407 = add nsw i32 %405, %406
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds double, double* %404, i64 %408
store double %403, double* %409
%410 = load i32, i32* %77
%411 = sub nsw i32 %410, 1
store i32 %411, i32* %77
br label %412
412: ; preds = %491, %309
%413 = load i32, i32* %77
%414 = icmp sge i32 %413, 0
br i1 %414, label %415, label %494
415: ; preds = %412
%416 = load double*, double** %50
%417 = load i32, i32* %75
%418 = load i32, i32* %77
%419 = add nsw i32 %417, %418
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds double, double* %416, i64 %420
%422 = load double, double* %421
%423 = load double, double* %30
%424 = load double, double* %35
%425 = fsub double %423, %424
%426 = load double*, double** %50
%427 = load i32, i32* %76
%428 = load i32, i32* %77
%429 = add nsw i32 %427, %428
%430 = sext i32 %429 to i64
%431 = getelementptr inbounds double, double* %426, i64 %430
%432 = load double, double* %431
%433 = fneg double %425
%434 = call double @llvm.fmuladd.f64(double %433, double %432, double %422)
%435 = load double*, double** %50
%436 = load i32, i32* %74
%437 = load i32, i32* %77
%438 = add nsw i32 %436, %437
%439 = sext i32 %438 to i64
%440 = getelementptr inbounds double, double* %435, i64 %439
store double %434, double* %440
%441 = load double*, double** %51
%442 = load i32, i32* %75
%443 = load i32, i32* %77
%444 = add nsw i32 %442, %443
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds double, double* %441, i64 %445
%447 = load double, double* %446
%448 = load double, double* %31
%449 = load double, double* %36
%450 = fsub double %448, %449
%451 = load double*, double** %51
%452 = load i32, i32* %76
%453 = load i32, i32* %77
%454 = add nsw i32 %452, %453
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %451, i64 %455
%457 = load double, double* %456
%458 = fneg double %450
%459 = call double @llvm.fmuladd.f64(double %458, double %457, double %447)
%460 = load double*, double** %51
%461 = load i32, i32* %74
%462 = load i32, i32* %77
%463 = add nsw i32 %461, %462
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds double, double* %460, i64 %464
store double %459, double* %465
%466 = load double*, double** %52
%467 = load i32, i32* %75
%468 = load i32, i32* %77
%469 = add nsw i32 %467, %468
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds double, double* %466, i64 %470
%472 = load double, double* %471
%473 = load double, double* %32
%474 = load double, double* %37
%475 = fsub double %473, %474
%476 = load double*, double** %52
%477 = load i32, i32* %76
%478 = load i32, i32* %77
%479 = add nsw i32 %477, %478
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds double, double* %476, i64 %480
%482 = load double, double* %481
%483 = fneg double %475
%484 = call double @llvm.fmuladd.f64(double %483, double %482, double %472)
%485 = load double*, double** %52
%486 = load i32, i32* %74
%487 = load i32, i32* %77
%488 = add nsw i32 %486, %487
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %485, i64 %489
store double %484, double* %490
br label %491
491: ; preds = %415
%492 = load i32, i32* %77
%493 = add nsw i32 %492, -1
store i32 %493, i32* %77
br label %412
494: ; preds = %412
%495 = load i32, i32* %70
%496 = load i32, i32* %71
%497 = add nsw i32 %495, %496
%498 = load i32, i32* %72
%499 = add nsw i32 %497, %498
%500 = load i32, i32* %73
%501 = add nsw i32 %499, %500
store i32 %501, i32* %77
%502 = load i32, i32* %33
%503 = load i32, i32* %38
%504 = add nsw i32 %502, %503
%505 = load i32, i32* %43
%506 = add nsw i32 %504, %505
%507 = load i32, i32* %48
%508 = add nsw i32 %506, %507
%509 = load i32, i32* %77
%510 = sub nsw i32 %508, %509
store i32 %510, i32* %76
br label %511
511: ; preds = %593, %494
%512 = load i32, i32* %76
%513 = icmp sge i32 %512, 0
br i1 %513, label %514, label %596
514: ; preds = %511
store double 0.000000e+00, double* %84
store double 0.000000e+00, double* %83
store double 0.000000e+00, double* %82
%515 = load i32, i32* %77
store i32 %515, i32* %75
br label %516
516: ; preds = %568, %514
%517 = load i32, i32* %75
%518 = icmp sge i32 %517, 0
br i1 %518, label %519, label %571
519: ; preds = %516
%520 = load double*, double** %50
%521 = load i32, i32* %74
%522 = load i32, i32* %75
%523 = add nsw i32 %521, %522
%524 = sext i32 %523 to i64
%525 = getelementptr inbounds double, double* %520, i64 %524
%526 = load double, double* %525
%527 = load double*, double** %56
%528 = load i32, i32* %76
%529 = load i32, i32* %75
%530 = add nsw i32 %528, %529
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds double, double* %527, i64 %531
%533 = load double, double* %532
%534 = load double, double* %82
%535 = call double @llvm.fmuladd.f64(double %526, double %533, double %534)
store double %535, double* %82
%536 = load double*, double** %51
%537 = load i32, i32* %74
%538 = load i32, i32* %75
%539 = add nsw i32 %537, %538
%540 = sext i32 %539 to i64
%541 = getelementptr inbounds double, double* %536, i64 %540
%542 = load double, double* %541
%543 = load double*, double** %56
%544 = load i32, i32* %76
%545 = load i32, i32* %75
%546 = add nsw i32 %544, %545
%547 = sext i32 %546 to i64
%548 = getelementptr inbounds double, double* %543, i64 %547
%549 = load double, double* %548
%550 = load double, double* %83
%551 = call double @llvm.fmuladd.f64(double %542, double %549, double %550)
store double %551, double* %83
%552 = load double*, double** %52
%553 = load i32, i32* %74
%554 = load i32, i32* %75
%555 = add nsw i32 %553, %554
%556 = sext i32 %555 to i64
%557 = getelementptr inbounds double, double* %552, i64 %556
%558 = load double, double* %557
%559 = load double*, double** %56
%560 = load i32, i32* %76
%561 = load i32, i32* %75
%562 = add nsw i32 %560, %561
%563 = sext i32 %562 to i64
%564 = getelementptr inbounds double, double* %559, i64 %563
%565 = load double, double* %564
%566 = load double, double* %84
%567 = call double @llvm.fmuladd.f64(double %558, double %565, double %566)
store double %567, double* %84
br label %568
568: ; preds = %519
%569 = load i32, i32* %75
%570 = add nsw i32 %569, -1
store i32 %570, i32* %75
br label %516
571: ; preds = %516
%572 = load double, double* %82
%573 = load double*, double** %53
%574 = load i32, i32* %74
%575 = load i32, i32* %76
%576 = add nsw i32 %574, %575
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %573, i64 %577
store double %572, double* %578
%579 = load double, double* %83
%580 = load double*, double** %54
%581 = load i32, i32* %74
%582 = load i32, i32* %76
%583 = add nsw i32 %581, %582
%584 = sext i32 %583 to i64
%585 = getelementptr inbounds double, double* %580, i64 %584
store double %579, double* %585
%586 = load double, double* %84
%587 = load double*, double** %55
%588 = load i32, i32* %74
%589 = load i32, i32* %76
%590 = add nsw i32 %588, %589
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds double, double* %587, i64 %591
store double %586, double* %592
br label %593
593: ; preds = %571
%594 = load i32, i32* %76
%595 = add nsw i32 %594, -1
store i32 %595, i32* %76
br label %511
596: ; preds = %511
br label %597
597: ; preds = %596
%598 = load i32, i32* %73
%599 = add nsw i32 %598, 1
store i32 %599, i32* %73
br label %304
600: ; preds = %304
br label %601
601: ; preds = %600
%602 = load i32, i32* %72
%603 = add nsw i32 %602, 1
store i32 %603, i32* %72
br label %298
604: ; preds = %298
br label %1095
605: ; preds = %293, %290
store i32 0, i32* %72
br label %606
606: ; preds = %1091, %605
%607 = load i32, i32* %72
%608 = load i32, i32* %43
%609 = add nsw i32 %608, 1
%610 = icmp slt i32 %607, %609
br i1 %610, label %611, label %1094
611: ; preds = %606
store i32 0, i32* %73
br label %612
612: ; preds = %1087, %611
%613 = load i32, i32* %73
%614 = load i32, i32* %48
%615 = add nsw i32 %614, 1
%616 = icmp slt i32 %613, %615
br i1 %616, label %617, label %1090
617: ; preds = %612
%618 = load i32, i32* %72
%619 = icmp ne i32 %618, 0
br i1 %619, label %620, label %912
620: ; preds = %617
%621 = load i32, i32* %73
%622 = load i32, i32* %48
%623 = icmp ne i32 %621, %622
br i1 %623, label %624, label %912
624: ; preds = %620
%625 = load i32, i32* %57
%626 = add nsw i32 %625, 1
%627 = mul nsw i32 4, %626
%628 = load i32, i32* %70
%629 = load i32, i32* %78
%630 = mul nsw i32 %628, %629
%631 = load i32, i32* %71
%632 = load i32, i32* %79
%633 = mul nsw i32 %631, %632
%634 = add nsw i32 %630, %633
%635 = load i32, i32* %72
%636 = load i32, i32* %80
%637 = mul nsw i32 %635, %636
%638 = add nsw i32 %634, %637
%639 = load i32, i32* %73
%640 = add nsw i32 %638, %639
%641 = mul nsw i32 %627, %640
store i32 %641, i32* %74
%642 = load i32, i32* %57
%643 = add nsw i32 %642, 1
%644 = mul nsw i32 4, %643
%645 = load i32, i32* %70
%646 = load i32, i32* %78
%647 = mul nsw i32 %645, %646
%648 = load i32, i32* %71
%649 = load i32, i32* %79
%650 = mul nsw i32 %648, %649
%651 = add nsw i32 %647, %650
%652 = load i32, i32* %72
%653 = sub nsw i32 %652, 1
%654 = load i32, i32* %80
%655 = mul nsw i32 %653, %654
%656 = add nsw i32 %651, %655
%657 = load i32, i32* %73
%658 = add nsw i32 %656, %657
%659 = add nsw i32 %658, 1
%660 = mul nsw i32 %644, %659
store i32 %660, i32* %75
%661 = load i32, i32* %57
%662 = add nsw i32 %661, 1
%663 = mul nsw i32 4, %662
%664 = load i32, i32* %70
%665 = load i32, i32* %78
%666 = mul nsw i32 %664, %665
%667 = load i32, i32* %71
%668 = load i32, i32* %79
%669 = mul nsw i32 %667, %668
%670 = add nsw i32 %666, %669
%671 = load i32, i32* %72
%672 = sub nsw i32 %671, 1
%673 = load i32, i32* %80
%674 = mul nsw i32 %672, %673
%675 = add nsw i32 %670, %674
%676 = load i32, i32* %73
%677 = add nsw i32 %675, %676
%678 = mul nsw i32 %663, %677
store i32 %678, i32* %76
%679 = load i32, i32* %70
%680 = load i32, i32* %71
%681 = add nsw i32 %679, %680
%682 = load i32, i32* %72
%683 = add nsw i32 %681, %682
%684 = load i32, i32* %73
%685 = add nsw i32 %683, %684
store i32 %685, i32* %77
%686 = load double*, double** %50
%687 = load i32, i32* %75
%688 = load i32, i32* %77
%689 = add nsw i32 %687, %688
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds double, double* %686, i64 %690
%692 = load double, double* %691
%693 = load double*, double** %50
%694 = load i32, i32* %74
%695 = load i32, i32* %77
%696 = add nsw i32 %694, %695
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds double, double* %693, i64 %697
store double %692, double* %698
%699 = load double*, double** %51
%700 = load i32, i32* %75
%701 = load i32, i32* %77
%702 = add nsw i32 %700, %701
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds double, double* %699, i64 %703
%705 = load double, double* %704
%706 = load double*, double** %51
%707 = load i32, i32* %74
%708 = load i32, i32* %77
%709 = add nsw i32 %707, %708
%710 = sext i32 %709 to i64
%711 = getelementptr inbounds double, double* %706, i64 %710
store double %705, double* %711
%712 = load double*, double** %52
%713 = load i32, i32* %75
%714 = load i32, i32* %77
%715 = add nsw i32 %713, %714
%716 = sext i32 %715 to i64
%717 = getelementptr inbounds double, double* %712, i64 %716
%718 = load double, double* %717
%719 = load double*, double** %52
%720 = load i32, i32* %74
%721 = load i32, i32* %77
%722 = add nsw i32 %720, %721
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds double, double* %719, i64 %723
store double %718, double* %724
%725 = load i32, i32* %77
%726 = sub nsw i32 %725, 1
store i32 %726, i32* %77
br label %727
727: ; preds = %806, %624
%728 = load i32, i32* %77
%729 = icmp sge i32 %728, 0
br i1 %729, label %730, label %809
730: ; preds = %727
%731 = load double*, double** %50
%732 = load i32, i32* %75
%733 = load i32, i32* %77
%734 = add nsw i32 %732, %733
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds double, double* %731, i64 %735
%737 = load double, double* %736
%738 = load double, double* %40
%739 = load double, double* %45
%740 = fsub double %738, %739
%741 = load double*, double** %50
%742 = load i32, i32* %76
%743 = load i32, i32* %77
%744 = add nsw i32 %742, %743
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds double, double* %741, i64 %745
%747 = load double, double* %746
%748 = fneg double %740
%749 = call double @llvm.fmuladd.f64(double %748, double %747, double %737)
%750 = load double*, double** %50
%751 = load i32, i32* %74
%752 = load i32, i32* %77
%753 = add nsw i32 %751, %752
%754 = sext i32 %753 to i64
%755 = getelementptr inbounds double, double* %750, i64 %754
store double %749, double* %755
%756 = load double*, double** %51
%757 = load i32, i32* %75
%758 = load i32, i32* %77
%759 = add nsw i32 %757, %758
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds double, double* %756, i64 %760
%762 = load double, double* %761
%763 = load double, double* %41
%764 = load double, double* %46
%765 = fsub double %763, %764
%766 = load double*, double** %51
%767 = load i32, i32* %76
%768 = load i32, i32* %77
%769 = add nsw i32 %767, %768
%770 = sext i32 %769 to i64
%771 = getelementptr inbounds double, double* %766, i64 %770
%772 = load double, double* %771
%773 = fneg double %765
%774 = call double @llvm.fmuladd.f64(double %773, double %772, double %762)
%775 = load double*, double** %51
%776 = load i32, i32* %74
%777 = load i32, i32* %77
%778 = add nsw i32 %776, %777
%779 = sext i32 %778 to i64
%780 = getelementptr inbounds double, double* %775, i64 %779
store double %774, double* %780
%781 = load double*, double** %52
%782 = load i32, i32* %75
%783 = load i32, i32* %77
%784 = add nsw i32 %782, %783
%785 = sext i32 %784 to i64
%786 = getelementptr inbounds double, double* %781, i64 %785
%787 = load double, double* %786
%788 = load double, double* %42
%789 = load double, double* %47
%790 = fsub double %788, %789
%791 = load double*, double** %52
%792 = load i32, i32* %76
%793 = load i32, i32* %77
%794 = add nsw i32 %792, %793
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds double, double* %791, i64 %795
%797 = load double, double* %796
%798 = fneg double %790
%799 = call double @llvm.fmuladd.f64(double %798, double %797, double %787)
%800 = load double*, double** %52
%801 = load i32, i32* %74
%802 = load i32, i32* %77
%803 = add nsw i32 %801, %802
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds double, double* %800, i64 %804
store double %799, double* %805
br label %806
806: ; preds = %730
%807 = load i32, i32* %77
%808 = add nsw i32 %807, -1
store i32 %808, i32* %77
br label %727
809: ; preds = %727
%810 = load i32, i32* %70
%811 = load i32, i32* %71
%812 = add nsw i32 %810, %811
%813 = load i32, i32* %72
%814 = add nsw i32 %812, %813
%815 = load i32, i32* %73
%816 = add nsw i32 %814, %815
store i32 %816, i32* %77
%817 = load i32, i32* %33
%818 = load i32, i32* %38
%819 = add nsw i32 %817, %818
%820 = load i32, i32* %43
%821 = add nsw i32 %819, %820
%822 = load i32, i32* %48
%823 = add nsw i32 %821, %822
%824 = load i32, i32* %77
%825 = sub nsw i32 %823, %824
store i32 %825, i32* %76
br label %826
826: ; preds = %908, %809
%827 = load i32, i32* %76
%828 = icmp sge i32 %827, 0
br i1 %828, label %829, label %911
829: ; preds = %826
store double 0.000000e+00, double* %84
store double 0.000000e+00, double* %83
store double 0.000000e+00, double* %82
%830 = load i32, i32* %77
store i32 %830, i32* %75
br label %831
831: ; preds = %883, %829
%832 = load i32, i32* %75
%833 = icmp sge i32 %832, 0
br i1 %833, label %834, label %886
834: ; preds = %831
%835 = load double*, double** %50
%836 = load i32, i32* %74
%837 = load i32, i32* %75
%838 = add nsw i32 %836, %837
%839 = sext i32 %838 to i64
%840 = getelementptr inbounds double, double* %835, i64 %839
%841 = load double, double* %840
%842 = load double*, double** %56
%843 = load i32, i32* %76
%844 = load i32, i32* %75
%845 = add nsw i32 %843, %844
%846 = sext i32 %845 to i64
%847 = getelementptr inbounds double, double* %842, i64 %846
%848 = load double, double* %847
%849 = load double, double* %82
%850 = call double @llvm.fmuladd.f64(double %841, double %848, double %849)
store double %850, double* %82
%851 = load double*, double** %51
%852 = load i32, i32* %74
%853 = load i32, i32* %75
%854 = add nsw i32 %852, %853
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds double, double* %851, i64 %855
%857 = load double, double* %856
%858 = load double*, double** %56
%859 = load i32, i32* %76
%860 = load i32, i32* %75
%861 = add nsw i32 %859, %860
%862 = sext i32 %861 to i64
%863 = getelementptr inbounds double, double* %858, i64 %862
%864 = load double, double* %863
%865 = load double, double* %83
%866 = call double @llvm.fmuladd.f64(double %857, double %864, double %865)
store double %866, double* %83
%867 = load double*, double** %52
%868 = load i32, i32* %74
%869 = load i32, i32* %75
%870 = add nsw i32 %868, %869
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds double, double* %867, i64 %871
%873 = load double, double* %872
%874 = load double*, double** %56
%875 = load i32, i32* %76
%876 = load i32, i32* %75
%877 = add nsw i32 %875, %876
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds double, double* %874, i64 %878
%880 = load double, double* %879
%881 = load double, double* %84
%882 = call double @llvm.fmuladd.f64(double %873, double %880, double %881)
store double %882, double* %84
br label %883
883: ; preds = %834
%884 = load i32, i32* %75
%885 = add nsw i32 %884, -1
store i32 %885, i32* %75
br label %831
886: ; preds = %831
%887 = load double, double* %82
%888 = load double*, double** %53
%889 = load i32, i32* %74
%890 = load i32, i32* %76
%891 = add nsw i32 %889, %890
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds double, double* %888, i64 %892
store double %887, double* %893
%894 = load double, double* %83
%895 = load double*, double** %54
%896 = load i32, i32* %74
%897 = load i32, i32* %76
%898 = add nsw i32 %896, %897
%899 = sext i32 %898 to i64
%900 = getelementptr inbounds double, double* %895, i64 %899
store double %894, double* %900
%901 = load double, double* %84
%902 = load double*, double** %55
%903 = load i32, i32* %74
%904 = load i32, i32* %76
%905 = add nsw i32 %903, %904
%906 = sext i32 %905 to i64
%907 = getelementptr inbounds double, double* %902, i64 %906
store double %901, double* %907
br label %908
908: ; preds = %886
%909 = load i32, i32* %76
%910 = add nsw i32 %909, -1
store i32 %910, i32* %76
br label %826
911: ; preds = %826
br label %1086
912: ; preds = %620, %617
%913 = load i32, i32* %57
%914 = add nsw i32 %913, 1
%915 = mul nsw i32 4, %914
%916 = load i32, i32* %70
%917 = load i32, i32* %78
%918 = mul nsw i32 %916, %917
%919 = load i32, i32* %71
%920 = load i32, i32* %79
%921 = mul nsw i32 %919, %920
%922 = add nsw i32 %918, %921
%923 = load i32, i32* %72
%924 = load i32, i32* %80
%925 = mul nsw i32 %923, %924
%926 = add nsw i32 %922, %925
%927 = load i32, i32* %73
%928 = add nsw i32 %926, %927
%929 = mul nsw i32 %915, %928
store i32 %929, i32* %74
%930 = load double*, double** %50
%931 = load i32, i32* %74
%932 = sext i32 %931 to i64
%933 = getelementptr inbounds double, double* %930, i64 %932
%934 = load i32, i32* %70
%935 = load i32, i32* %71
%936 = load i32, i32* %72
%937 = load i32, i32* %73
%938 = load double, double* %61
%939 = load double, double* %30
%940 = load double, double* %35
%941 = load double, double* %64
%942 = load double, double* %40
%943 = load double, double* %45
%944 = load double, double* %67
%945 = load double, double* %68
%946 = load double, double* %69
%947 = call i32 @eriB_1d(double* %933, i32 %934, i32 %935, i32 %936, i32 %937, double %938, double %939, double %940, double %941, double %942, double %943, double %944, double %945, double %946)
%948 = load double*, double** %51
%949 = load i32, i32* %74
%950 = sext i32 %949 to i64
%951 = getelementptr inbounds double, double* %948, i64 %950
%952 = load i32, i32* %70
%953 = load i32, i32* %71
%954 = load i32, i32* %72
%955 = load i32, i32* %73
%956 = load double, double* %62
%957 = load double, double* %31
%958 = load double, double* %36
%959 = load double, double* %65
%960 = load double, double* %41
%961 = load double, double* %46
%962 = load double, double* %67
%963 = load double, double* %68
%964 = load double, double* %69
%965 = call i32 @eriB_1d(double* %951, i32 %952, i32 %953, i32 %954, i32 %955, double %956, double %957, double %958, double %959, double %960, double %961, double %962, double %963, double %964)
%966 = load double*, double** %52
%967 = load i32, i32* %74
%968 = sext i32 %967 to i64
%969 = getelementptr inbounds double, double* %966, i64 %968
%970 = load i32, i32* %70
%971 = load i32, i32* %71
%972 = load i32, i32* %72
%973 = load i32, i32* %73
%974 = load double, double* %63
%975 = load double, double* %32
%976 = load double, double* %37
%977 = load double, double* %66
%978 = load double, double* %42
%979 = load double, double* %47
%980 = load double, double* %67
%981 = load double, double* %68
%982 = load double, double* %69
%983 = call i32 @eriB_1d(double* %969, i32 %970, i32 %971, i32 %972, i32 %973, double %974, double %975, double %976, double %977, double %978, double %979, double %980, double %981, double %982)
%984 = load i32, i32* %70
%985 = load i32, i32* %71
%986 = add nsw i32 %984, %985
%987 = load i32, i32* %72
%988 = add nsw i32 %986, %987
%989 = load i32, i32* %73
%990 = add nsw i32 %988, %989
store i32 %990, i32* %77
%991 = load i32, i32* %33
%992 = load i32, i32* %38
%993 = add nsw i32 %991, %992
%994 = load i32, i32* %43
%995 = add nsw i32 %993, %994
%996 = load i32, i32* %48
%997 = add nsw i32 %995, %996
%998 = load i32, i32* %77
%999 = sub nsw i32 %997, %998
store i32 %999, i32* %76
br label %1000
1000: ; preds = %1082, %912
%1001 = load i32, i32* %76
%1002 = icmp sge i32 %1001, 0
br i1 %1002, label %1003, label %1085
1003: ; preds = %1000
store double 0.000000e+00, double* %84
store double 0.000000e+00, double* %83
store double 0.000000e+00, double* %82
%1004 = load i32, i32* %77
store i32 %1004, i32* %75
br label %1005
1005: ; preds = %1057, %1003
%1006 = load i32, i32* %75
%1007 = icmp sge i32 %1006, 0
br i1 %1007, label %1008, label %1060
1008: ; preds = %1005
%1009 = load double*, double** %50
%1010 = load i32, i32* %74
%1011 = load i32, i32* %75
%1012 = add nsw i32 %1010, %1011
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds double, double* %1009, i64 %1013
%1015 = load double, double* %1014
%1016 = load double*, double** %56
%1017 = load i32, i32* %76
%1018 = load i32, i32* %75
%1019 = add nsw i32 %1017, %1018
%1020 = sext i32 %1019 to i64
%1021 = getelementptr inbounds double, double* %1016, i64 %1020
%1022 = load double, double* %1021
%1023 = load double, double* %82
%1024 = call double @llvm.fmuladd.f64(double %1015, double %1022, double %1023)
store double %1024, double* %82
%1025 = load double*, double** %51
%1026 = load i32, i32* %74
%1027 = load i32, i32* %75
%1028 = add nsw i32 %1026, %1027
%1029 = sext i32 %1028 to i64
%1030 = getelementptr inbounds double, double* %1025, i64 %1029
%1031 = load double, double* %1030
%1032 = load double*, double** %56
%1033 = load i32, i32* %76
%1034 = load i32, i32* %75
%1035 = add nsw i32 %1033, %1034
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds double, double* %1032, i64 %1036
%1038 = load double, double* %1037
%1039 = load double, double* %83
%1040 = call double @llvm.fmuladd.f64(double %1031, double %1038, double %1039)
store double %1040, double* %83
%1041 = load double*, double** %52
%1042 = load i32, i32* %74
%1043 = load i32, i32* %75
%1044 = add nsw i32 %1042, %1043
%1045 = sext i32 %1044 to i64
%1046 = getelementptr inbounds double, double* %1041, i64 %1045
%1047 = load double, double* %1046
%1048 = load double*, double** %56
%1049 = load i32, i32* %76
%1050 = load i32, i32* %75
%1051 = add nsw i32 %1049, %1050
%1052 = sext i32 %1051 to i64
%1053 = getelementptr inbounds double, double* %1048, i64 %1052
%1054 = load double, double* %1053
%1055 = load double, double* %84
%1056 = call double @llvm.fmuladd.f64(double %1047, double %1054, double %1055)
store double %1056, double* %84
br label %1057
1057: ; preds = %1008
%1058 = load i32, i32* %75
%1059 = add nsw i32 %1058, -1
store i32 %1059, i32* %75
br label %1005
1060: ; preds = %1005
%1061 = load double, double* %82
%1062 = load double*, double** %53
%1063 = load i32, i32* %74
%1064 = load i32, i32* %76
%1065 = add nsw i32 %1063, %1064
%1066 = sext i32 %1065 to i64
%1067 = getelementptr inbounds double, double* %1062, i64 %1066
store double %1061, double* %1067
%1068 = load double, double* %83
%1069 = load double*, double** %54
%1070 = load i32, i32* %74
%1071 = load i32, i32* %76
%1072 = add nsw i32 %1070, %1071
%1073 = sext i32 %1072 to i64
%1074 = getelementptr inbounds double, double* %1069, i64 %1073
store double %1068, double* %1074
%1075 = load double, double* %84
%1076 = load double*, double** %55
%1077 = load i32, i32* %74
%1078 = load i32, i32* %76
%1079 = add nsw i32 %1077, %1078
%1080 = sext i32 %1079 to i64
%1081 = getelementptr inbounds double, double* %1076, i64 %1080
store double %1075, double* %1081
br label %1082
1082: ; preds = %1060
%1083 = load i32, i32* %76
%1084 = add nsw i32 %1083, -1
store i32 %1084, i32* %76
br label %1000
1085: ; preds = %1000
br label %1086
1086: ; preds = %1085, %911
br label %1087
1087: ; preds = %1086
%1088 = load i32, i32* %73
%1089 = add nsw i32 %1088, 1
store i32 %1089, i32* %73
br label %612
1090: ; preds = %612
br label %1091
1091: ; preds = %1090
%1092 = load i32, i32* %72
%1093 = add nsw i32 %1092, 1
store i32 %1093, i32* %72
br label %606
1094: ; preds = %606
br label %1095
1095: ; preds = %1094, %604
br label %1096
1096: ; preds = %1095
%1097 = load i32, i32* %71
%1098 = add nsw i32 %1097, 1
store i32 %1098, i32* %71
br label %285
1099: ; preds = %285
br label %1100
1100: ; preds = %1099
%1101 = load i32, i32* %70
%1102 = add nsw i32 %1101, 1
store i32 %1102, i32* %70
br label %279
1103: ; preds = %279
%1104 = load double, double* %81
store double %1104, double* %29
br label %1105
1105: ; preds = %1103, %267
%1106 = load double, double* %29
ret double %1106
}

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