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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ eriB_1d(double *, int, int, int, int, double, double, double,
                           double, double, double, double, double, double);
int /*<<< orphan*/ fgamma_set(int, double, double *);
void genPrimeSetBxyzSxyzF(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) {
  double 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;
  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;
  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);
  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 * (4 + 1) * (a * na + b * nb + c * nc + d);
            j = 4 * (4 + 1) * ((a - 1) * na + (b + 1) * nb + c * nc + d);
            k = 4 * (4 + 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 * (4 + 1) * (a * na + b * nb + c * nc + d);
              j = 4 * (4 + 1) * (a * na + b * nb + (c - 1) * nc + d + 1);
              k = 4 * (4 + 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 * (4 + 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;
              }
            }
}


x86 assembly (clang, -O0):
<genPrimeSetBxyzSxyzF>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
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,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
movsd  %xmm2,-0x18(%rbp)
mov    %edi,-0x1c(%rbp)
movsd  %xmm3,-0x28(%rbp)
movsd  %xmm4,-0x30(%rbp)
movsd  %xmm5,-0x38(%rbp)
movsd  %xmm6,-0x40(%rbp)
mov    %esi,-0x44(%rbp)
movsd  %xmm7,-0x50(%rbp)
mov    %edx,-0x54(%rbp)
mov    %ecx,-0x58(%rbp)
mov    %r8,-0x60(%rbp)
mov    %r9,-0x68(%rbp)
movsd  -0x28(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
movsd  0x1e53(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x28(%rbp),%xmm1
addsd  0x48(%rbp),%xmm1
movsd  0x1e35(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x28(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
movsd  0x1e0f(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x28(%rbp),%xmm1
addsd  0x48(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  -0x28(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
addsd  0x28(%rbp),%xmm1
addsd  0x48(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x28(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%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  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%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  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
movsd  0x28(%rbp),%xmm0
movsd  0x20(%rbp),%xmm2
movsd  0x48(%rbp),%xmm1
mulsd  0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
subsd  -0x90(%rbp),%xmm1
ff
movsd  -0x78(%rbp),%xmm2
subsd  -0x90(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm0
subsd  -0x98(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm3
subsd  -0x98(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
subsd  -0xa0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1c5e(%rip),%xmm0
mulsd  -0x70(%rbp),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x1c(%rbp),%edi
add    -0x44(%rbp),%edi
add    -0x54(%rbp),%edi
add    -0x58(%rbp),%edi
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x70(%rbp),%rsi
call   1030 <fgamma_set@plt>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0xe0(%rbp)
mov    -0xe0(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0xdc(%rbp)
movl   $0x0,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2294 <genPrimeSetBxyzSxyzF+0x1174>
movl   $0x0,-0xc0(%rbp)
mov    -0xc0(%rbp),%eax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    227b <genPrimeSetBxyzSxyzF+0x115b>
cmpl   $0x0,-0xbc(%rbp)
je     199a <genPrimeSetBxyzSxyzF+0x87a>
mov    -0xc0(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     199a <genPrimeSetBxyzSxyzF+0x87a>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1995 <genPrimeSetBxyzSxyzF+0x875>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    197c <genPrimeSetBxyzSxyzF+0x85c>
mov    -0xbc(%rbp),%eax
imul   -0xdc(%rbp),%eax
mov    -0xc0(%rbp),%ecx
imul   -0xe0(%rbp),%ecx
add    %ecx,%eax
mov    -0xc4(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    %ecx,%eax
add    -0xc8(%rbp),%eax
imul   $0x14,%eax,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xbc(%rbp),%eax
sub    $0x1,%eax
imul   -0xdc(%rbp),%eax
mov    -0xc0(%rbp),%ecx
add    $0x1,%ecx
imul   -0xe0(%rbp),%ecx
add    %ecx,%eax
mov    -0xc4(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    %ecx,%eax
add    -0xc8(%rbp),%eax
imul   $0x14,%eax,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xbc(%rbp),%eax
sub    $0x1,%eax
imul   -0xdc(%rbp),%eax
mov    -0xc0(%rbp),%ecx
imul   -0xe0(%rbp),%ecx
add    %ecx,%eax
mov    -0xc4(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    %ecx,%eax
add    -0xc8(%rbp),%eax
imul   $0x14,%eax,%eax
mov    %eax,-0xd4(%rbp)
mov    -0xbc(%rbp),%eax
add    -0xc0(%rbp),%eax
add    -0xc4(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x60(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0x0,-0xd8(%rbp)
jl     1786 <genPrimeSetBxyzSxyzF+0x666>
mov    -0x60(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x8(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd8(%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    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x10(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd8(%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    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x18(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd8(%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    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd8(%rbp)
jmp    1612 <genPrimeSetBxyzSxyzF+0x4f2>
mov    -0xbc(%rbp),%eax
add    -0xc0(%rbp),%eax
add    -0xc4(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x44(%rbp),%eax
add    -0x54(%rbp),%eax
add    -0x58(%rbp),%eax
sub    -0xd8(%rbp),%eax
mov    %eax,-0xd4(%rbp)
cmpl   $0x0,-0xd4(%rbp)
jl     1963 <genPrimeSetBxyzSxyzF+0x843>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xd8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
cmpl   $0x0,-0xd0(%rbp)
jl     18ef <genPrimeSetBxyzSxyzF+0x7cf>
mov    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0xd0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd0(%rbp)
jmp    17f6 <genPrimeSetBxyzSxyzF+0x6d6>
movsd  -0xf8(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd4(%rbp)
jmp    17bc <genPrimeSetBxyzSxyzF+0x69c>
jmp    1968 <genPrimeSetBxyzSxyzF+0x848>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    148a <genPrimeSetBxyzSxyzF+0x36a>
jmp    1981 <genPrimeSetBxyzSxyzF+0x861>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    146c <genPrimeSetBxyzSxyzF+0x34c>
jmp    2262 <genPrimeSetBxyzSxyzF+0x1142>
movl   $0x0,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    225d <genPrimeSetBxyzSxyzF+0x113d>
movl   $0x0,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2244 <genPrimeSetBxyzSxyzF+0x1124>
cmpl   $0x0,-0xc4(%rbp)
je     1ebc <genPrimeSetBxyzSxyzF+0xd9c>
mov    -0xc8(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     1ebc <genPrimeSetBxyzSxyzF+0xd9c>
mov    -0xbc(%rbp),%eax
imul   -0xdc(%rbp),%eax
mov    -0xc0(%rbp),%ecx
imul   -0xe0(%rbp),%ecx
add    %ecx,%eax
mov    -0xc4(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    %ecx,%eax
add    -0xc8(%rbp),%eax
imul   $0x14,%eax,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xbc(%rbp),%eax
imul   -0xdc(%rbp),%eax
mov    -0xc0(%rbp),%ecx
imul   -0xe0(%rbp),%ecx
add    %ecx,%eax
mov    -0xc4(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xe4(%rbp),%ecx
add    %ecx,%eax
add    -0xc8(%rbp),%eax
add    $0x1,%eax
imul   $0x14,%eax,%eax
mov    %eax,-0xd0(%rbp)
mov    -0xbc(%rbp),%eax
imul   -0xdc(%rbp),%eax
mov    -0xc0(%rbp),%ecx
imul   -0xe0(%rbp),%ecx
add    %ecx,%eax
mov    -0xc4(%rbp),%ecx
sub    $0x1,%ecx
imul   -0xe4(%rbp),%ecx
add    %ecx,%eax
add    -0xc8(%rbp),%eax
imul   $0x14,%eax,%eax
mov    %eax,-0xd4(%rbp)
mov    -0xbc(%rbp),%eax
add    -0xc0(%rbp),%eax
add    -0xc4(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x60(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xd8(%rbp)
cmpl   $0x0,-0xd8(%rbp)
jl     1cda <genPrimeSetBxyzSxyzF+0xbba>
mov    -0x60(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x10(%rbp),%xmm0
subsd  0x30(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd8(%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    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x18(%rbp),%xmm0
subsd  0x38(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd8(%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    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0xd0(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x20(%rbp),%xmm0
subsd  0x40(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd8(%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    -0xcc(%rbp),%ecx
add    -0xd8(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd8(%rbp)
jmp    1b66 <genPrimeSetBxyzSxyzF+0xa46>
mov    -0xbc(%rbp),%eax
add    -0xc0(%rbp),%eax
add    -0xc4(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x44(%rbp),%eax
add    -0x54(%rbp),%eax
add    -0x58(%rbp),%eax
sub    -0xd8(%rbp),%eax
mov    %eax,-0xd4(%rbp)
cmpl   $0x0,-0xd4(%rbp)
jl     1eb7 <genPrimeSetBxyzSxyzF+0xd97>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xd8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
cmpl   $0x0,-0xd0(%rbp)
jl     1e43 <genPrimeSetBxyzSxyzF+0xd23>
mov    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0xd0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd0(%rbp)
jmp    1d4a <genPrimeSetBxyzSxyzF+0xc2a>
movsd  -0xf8(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd4(%rbp)
jmp    1d10 <genPrimeSetBxyzSxyzF+0xbf0>
jmp    222b <genPrimeSetBxyzSxyzF+0x110b>
mov    -0xbc(%rbp),%eax
imul   -0xdc(%rbp),%eax
mov    -0xc0(%rbp),%ecx
imul   -0xe0(%rbp),%ecx
add    %ecx,%eax
mov    -0xc4(%rbp),%ecx
imul   -0xe4(%rbp),%ecx
add    %ecx,%eax
add    -0xc8(%rbp),%eax
imul   $0x14,%eax,%eax
mov    %eax,-0xcc(%rbp)
mov    -0x60(%rbp),%rdi
movslq -0xcc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0xbc(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0xc8(%rbp),%r8d
movsd  -0x78(%rbp),%xmm0
movsd  -0x8(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
movsd  -0x90(%rbp),%xmm3
ff
movsd  0x10(%rbp),%xmm4
movsd  0x30(%rbp),%xmm5
movsd  -0xa8(%rbp),%xmm6
ff
movsd  -0xb0(%rbp),%xmm7
ff
movsd  -0xb8(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1040 <eriB_1d@plt>
mov    -0x68(%rbp),%rdi
movslq -0xcc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0xbc(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0xc8(%rbp),%r8d
movsd  -0x80(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm2
movsd  -0x98(%rbp),%xmm3
ff
movsd  0x18(%rbp),%xmm4
movsd  0x38(%rbp),%xmm5
movsd  -0xa8(%rbp),%xmm6
ff
movsd  -0xb0(%rbp),%xmm7
ff
movsd  -0xb8(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1040 <eriB_1d@plt>
mov    0x50(%rbp),%rdi
movslq -0xcc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0xbc(%rbp),%esi
mov    -0xc0(%rbp),%edx
mov    -0xc4(%rbp),%ecx
mov    -0xc8(%rbp),%r8d
movsd  -0x88(%rbp),%xmm0
movsd  -0x18(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm2
movsd  -0xa0(%rbp),%xmm3
ff
movsd  0x20(%rbp),%xmm4
movsd  0x40(%rbp),%xmm5
movsd  -0xa8(%rbp),%xmm6
ff
movsd  -0xb0(%rbp),%xmm7
ff
movsd  -0xb8(%rbp),%xmm8
ff ff
movsd  %xmm8,(%rsp)
call   1040 <eriB_1d@plt>
mov    -0xbc(%rbp),%eax
add    -0xc0(%rbp),%eax
add    -0xc4(%rbp),%eax
add    -0xc8(%rbp),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x44(%rbp),%eax
add    -0x54(%rbp),%eax
add    -0x58(%rbp),%eax
sub    -0xd8(%rbp),%eax
mov    %eax,-0xd4(%rbp)
cmpl   $0x0,-0xd4(%rbp)
jl     2226 <genPrimeSetBxyzSxyzF+0x1106>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0xd8(%rbp),%eax
mov    %eax,-0xd0(%rbp)
cmpl   $0x0,-0xd0(%rbp)
jl     21b2 <genPrimeSetBxyzSxyzF+0x1092>
mov    -0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
mov    -0xd4(%rbp),%ecx
add    -0xd0(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x108(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0xd0(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd0(%rbp)
jmp    20b9 <genPrimeSetBxyzSxyzF+0xf99>
movsd  -0xf8(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x100(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x108(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0xcc(%rbp),%ecx
add    -0xd4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xd4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd4(%rbp)
jmp    207f <genPrimeSetBxyzSxyzF+0xf5f>
jmp    222b <genPrimeSetBxyzSxyzF+0x110b>
jmp    2230 <genPrimeSetBxyzSxyzF+0x1110>
mov    -0xc8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc8(%rbp)
jmp    19c2 <genPrimeSetBxyzSxyzF+0x8a2>
jmp    2249 <genPrimeSetBxyzSxyzF+0x1129>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    19a4 <genPrimeSetBxyzSxyzF+0x884>
jmp    2262 <genPrimeSetBxyzSxyzF+0x1142>
jmp    2267 <genPrimeSetBxyzSxyzF+0x1147>
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1432 <genPrimeSetBxyzSxyzF+0x312>
jmp    2280 <genPrimeSetBxyzSxyzF+0x1160>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1414 <genPrimeSetBxyzSxyzF+0x2f4>
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<genPrimeSetBxyzSxyzF>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x348,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,0x58(%rsp)
mov    %edi,%ebx
movsd  0x390(%rsp),%xmm10
movsd  0x388(%rsp),%xmm11
movsd  0x380(%rsp),%xmm12
movsd  0x3b8(%rsp),%xmm8
movsd  0x398(%rsp),%xmm9
unpcklpd %xmm9,%xmm3
unpcklpd %xmm8,%xmm7
movapd %xmm0,0x220(%rsp)
movapd %xmm0,%xmm13
unpcklpd %xmm12,%xmm13
mulpd  %xmm3,%xmm13
movapd %xmm1,0x230(%rsp)
movapd %xmm1,%xmm12
unpcklpd %xmm11,%xmm12
mulpd  %xmm3,%xmm12
movapd %xmm2,0x240(%rsp)
unpcklpd %xmm10,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm7,%xmm3
movsd  0x1e59(%rip),%xmm0
mulsd  %xmm3,%xmm0
movapd %xmm3,%xmm10
unpckhpd %xmm3,%xmm10
mulsd  %xmm0,%xmm10
movapd 0x1e1d(%rip),%xmm11
divpd  %xmm3,%xmm11
addsd  %xmm9,%xmm3
addsd  %xmm8,%xmm3
divsd  %xmm3,%xmm10
movsd  0x3a0(%rsp),%xmm1
movapd %xmm4,0x250(%rsp)
movapd %xmm4,%xmm0
unpcklpd %xmm1,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm0,%xmm13
movsd  0x3a8(%rsp),%xmm1
movapd %xmm5,0x260(%rsp)
movapd %xmm5,%xmm0
unpcklpd %xmm1,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm0,%xmm12
movsd  0x3b0(%rsp),%xmm1
movapd %xmm6,0x270(%rsp)
movapd %xmm6,%xmm0
unpcklpd %xmm1,%xmm0
mulpd  %xmm7,%xmm0
addpd  %xmm0,%xmm2
mulpd  %xmm11,%xmm13
mulpd  %xmm11,%xmm12
movapd %xmm13,%xmm0
unpckhpd %xmm13,%xmm0
movapd %xmm13,0x330(%rsp)
movapd %xmm13,%xmm1
movapd %xmm0,0x300(%rsp)
subsd  %xmm0,%xmm1
movapd %xmm12,%xmm3
unpckhpd %xmm12,%xmm3
movapd %xmm12,0x320(%rsp)
movapd %xmm12,%xmm0
movapd %xmm3,0x2f0(%rsp)
subsd  %xmm3,%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm11,0x190(%rsp)
mulpd  %xmm11,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm2,0x310(%rsp)
movapd %xmm2,%xmm0
movapd %xmm3,0x2e0(%rsp)
subsd  %xmm3,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    0x3e0(%rsp),%rbp
mulsd  0x1d1e(%rip),%xmm0
movapd %xmm10,0x1b0(%rsp)
mulsd  %xmm10,%xmm0
mov    %rsi,0x128(%rsp)
lea    (%rsi,%rbx,1),%edi
mov    %rdx,0xe8(%rsp)
add    %edx,%edi
mov    %rcx,0xf0(%rsp)
add    %ecx,%edi
mov    %edi,0x40(%rsp)
mov    %rbp,%rsi
call   1030 <fgamma_set@plt>
mov    %rbx,0xd8(%rsp)
test   %ebx,%ebx
js     21c4 <genPrimeSetBxyzSxyzF+0x10a4>
mov    0xf0(%rsp),%r10
lea    0x1(%r10),%ebp
mov    0xe8(%rsp),%rax
lea    0x1(%rax),%r9d
mov    %ebp,%edx
imul   %r9d,%edx
mov    0x128(%rsp),%r8
lea    0x1(%r8),%ecx
mov    %edx,%ebx
imul   %ecx,%ebx
movapd 0x220(%rsp),%xmm4
subsd  0x250(%rsp),%xmm4
movapd 0x1c73(%rip),%xmm0
xorpd  %xmm0,%xmm4
movapd 0x230(%rsp),%xmm5
subsd  0x260(%rsp),%xmm5
xorpd  %xmm0,%xmm5
movapd 0x240(%rsp),%xmm7
subsd  0x270(%rsp),%xmm7
xorpd  %xmm0,%xmm7
movsd  0x380(%rsp),%xmm10
movsd  0x3a0(%rsp),%xmm1
subsd  %xmm1,%xmm10
xorpd  %xmm0,%xmm10
movsd  0x388(%rsp),%xmm8
movsd  0x3a8(%rsp),%xmm1
subsd  %xmm1,%xmm8
xorpd  %xmm0,%xmm8
movsd  0x390(%rsp),%xmm9
movsd  0x3b0(%rsp),%xmm1
subsd  %xmm1,%xmm9
xorpd  %xmm0,%xmm9
mov    %ebp,0x9c(%rsp)
movslq %ebp,%rbp
mov    %edx,0x118(%rsp)
movslq %edx,%rdi
movslq %ebx,%rax
mov    0xd8(%rsp),%rdx
add    $0x1,%edx
mov    %rdx,0xd8(%rsp)
mov    %ecx,%edx
mov    %rdx,0x1f0(%rsp)
mov    %r9d,%edx
mov    %rdx,0x178(%rsp)
movapd 0x190(%rsp),%xmm0
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x1a0(%rsp)
lea    0x0(,%rax,4),%edx
lea    (%rdx,%rdx,4),%ebx
lea    0x0(,%rdi,4),%edx
lea    (%rdx,%rdx,4),%edx
mov    %edx,0x11c(%rsp)
lea    0x0(,%r10,4),%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rdx,4),%edx
add    $0x14,%edx
mov    %edx,0xb4(%rsp)
mov    %ebx,0x114(%rsp)
neg    %ebx
mov    %ebx,0x84(%rsp)
imul   %ebp,%ecx
neg    %ecx
add    %r10d,%ecx
add    $0x1,%ecx
imul   %r9d,%ecx
shl    $0x2,%ecx
lea    (%rcx,%rcx,4),%ecx
mov    %ecx,0x80(%rsp)
mov    $0xffffffec,%ecx
sub    %esi,%ecx
mov    %ecx,0x7c(%rsp)
neg    %esi
mov    %esi,0x88(%rsp)
mov    %rax,0x1c8(%rsp)
shl    $0x5,%rax
lea    (%rax,%rax,4),%rax
mov    %rax,0x1d0(%rsp)
mov    %rdi,0x1d8(%rsp)
mov    %rdi,%rax
shl    $0x5,%rax
lea    (%rax,%rax,4),%rax
mov    %rax,0x1e8(%rsp)
mov    %rbp,%rax
shl    $0x5,%rax
lea    (%rax,%rax,4),%rax
mov    %rax,0x208(%rsp)
mov    0x3c0(%rsp),%rax
movslq 0x40(%rsp),%rcx
mov    %rcx,0x108(%rsp)
mov    %r10d,%ecx
mov    %rcx,0x218(%rsp)
mov    %r8d,%ecx
mov    %rcx,0x1e0(%rsp)
mov    %rbp,0x1f8(%rsp)
mov    %ebp,%ecx
mov    %rcx,0x188(%rsp)
xor    %ecx,%ecx
mov    %rcx,0xe0(%rsp)
mov    %rax,0x140(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,0x138(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,0x130(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
movapd %xmm4,0x2d0(%rsp)
movapd %xmm5,0x2c0(%rsp)
movapd %xmm7,0x2b0(%rsp)
movapd %xmm10,0x2a0(%rsp)
movapd %xmm8,0x290(%rsp)
movapd %xmm9,0x280(%rsp)
jmp    1656 <genPrimeSetBxyzSxyzF+0x536>
nopl   (%rax)
mov    0x18(%rsp),%rdx
add    $0x1,%rdx
addl   $0xffffffff,0x40(%rsp)
mov    0x114(%rsp),%eax
mov    0xe0(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,0xe0(%rsp)
add    %eax,0x84(%rsp)
add    %eax,0x80(%rsp)
add    %eax,0x7c(%rsp)
add    %eax,0x88(%rsp)
mov    0x1d0(%rsp),%rax
add    %rax,0x130(%rsp)
add    %rax,0x138(%rsp)
add    %rax,0x140(%rsp)
mov    %rdx,%rax
mov    %rdx,0x18(%rsp)
cmp    0xd8(%rsp),%rdx
je     21c4 <genPrimeSetBxyzSxyzF+0x10a4>
cmpl   $0x0,0x128(%rsp)
js     15e0 <genPrimeSetBxyzSxyzF+0x4c0>
mov    0x18(%rsp),%rdx
mov    %rdx,%rax
mov    0x1c8(%rsp),%rcx
imul   %rcx,%rax
mov    %rax,0x180(%rsp)
lea    -0x1(%rdx),%eax
imul   %eax,%ecx
mov    %ecx,0x124(%rsp)
mov    0x140(%rsp),%rax
mov    %rax,0x158(%rsp)
mov    0x138(%rsp),%rax
mov    %rax,0x150(%rsp)
mov    0x130(%rsp),%rax
mov    %rax,0x148(%rsp)
mov    0x88(%rsp),%eax
mov    %eax,0x98(%rsp)
mov    0x7c(%rsp),%eax
mov    %eax,0x94(%rsp)
mov    0x80(%rsp),%eax
mov    %eax,0x90(%rsp)
mov    0x84(%rsp),%eax
mov    %eax,0x8c(%rsp)
mov    0xe0(%rsp),%rax
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    0x40(%rsp),%eax
mov    %eax,0x48(%rsp)
mov    %edx,%eax
mov    %edx,0x44(%rsp)
jmp    1790 <genPrimeSetBxyzSxyzF+0x670>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x44(%rsp)
addl   $0xffffffff,0x48(%rsp)
mov    0x11c(%rsp),%eax
add    %eax,0x4c(%rsp)
add    %eax,0x8c(%rsp)
add    %eax,0x90(%rsp)
add    %eax,0x94(%rsp)
add    %eax,0x98(%rsp)
mov    0x1e8(%rsp),%rax
add    %rax,0x148(%rsp)
add    %rax,0x150(%rsp)
add    %rax,0x158(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    0x1f0(%rsp),%rcx
je     15e0 <genPrimeSetBxyzSxyzF+0x4c0>
cmpq   $0x0,0x18(%rsp)
je     1ae0 <genPrimeSetBxyzSxyzF+0x9c0>
mov    0x20(%rsp),%rax
cmp    0x1e0(%rsp),%rax
je     1ae0 <genPrimeSetBxyzSxyzF+0x9c0>
cmpl   $0x0,0xe8(%rsp)
js     1720 <genPrimeSetBxyzSxyzF+0x600>
mov    0x18(%rsp),%rax
mov    0x20(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0xf8(%rsp)
mov    0x118(%rsp),%eax
mov    %eax,%edx
imul   %ecx,%edx
mov    %edx,0x2c(%rsp)
add    $0x1,%ecx
imul   %eax,%ecx
mov    %ecx,0x28(%rsp)
mov    0x90(%rsp),%eax
mov    %eax,0x68(%rsp)
mov    0x8c(%rsp),%eax
mov    %eax,0xc8(%rsp)
mov    0x4c(%rsp),%eax
mov    %eax,0xc0(%rsp)
xor    %eax,%eax
mov    %rax,0x50(%rsp)
mov    0x48(%rsp),%eax
mov    %eax,0xb8(%rsp)
mov    0x44(%rsp),%eax
mov    %eax,0x60(%rsp)
jmp    1875 <genPrimeSetBxyzSxyzF+0x755>
nopl   0x0(%rax)
mov    0x50(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x60(%rsp)
addl   $0xffffffff,0xb8(%rsp)
ff
mov    0xb4(%rsp),%eax
add    %eax,0xc0(%rsp)
add    %eax,0xc8(%rsp)
add    %eax,0x68(%rsp)
mov    %rcx,%rax
mov    %rcx,0x50(%rsp)
cmp    0x178(%rsp),%rcx
je     1720 <genPrimeSetBxyzSxyzF+0x600>
cmpl   $0x0,0xf0(%rsp)
js     1830 <genPrimeSetBxyzSxyzF+0x710>
movslq 0x60(%rsp),%r14
add    $0x1,%r14
mov    0xf8(%rsp),%rax
mov    0x50(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x100(%rsp)
mov    0x9c(%rsp),%eax
imul   %ecx,%eax
mov    %rax,0xd0(%rsp)
mov    0x68(%rsp),%eax
mov    %eax,0x10(%rsp)
mov    0xc8(%rsp),%eax
mov    %eax,0x30(%rsp)
mov    0xc0(%rsp),%r13d
xor    %r8d,%r8d
mov    0xb8(%rsp),%ebx
jmp    1907 <genPrimeSetBxyzSxyzF+0x7e7>
nopl   0x0(%rax)
add    $0x1,%r8
add    $0xffffffff,%ebx
add    $0x1,%r14
add    $0x14,%r13d
addl   $0x14,0x30(%rsp)
addl   $0x14,0x10(%rsp)
cmp    0x188(%rsp),%r8
je     1830 <genPrimeSetBxyzSxyzF+0x710>
mov    %ebx,0x70(%rsp)
movslq %r13d,%rbp
mov    0xd0(%rsp),%rax
add    %r8d,%eax
mov    0x180(%rsp),%rcx
add    %eax,%ecx
add    0x2c(%rsp),%ecx
shl    $0x2,%ecx
lea    (%rcx,%rcx,4),%ecx
add    0x124(%rsp),%eax
add    0x28(%rsp),%eax
shl    $0x2,%eax
lea    (%rax,%rax,4),%eax
mov    0x100(%rsp),%rdx
lea    (%rdx,%r8,1),%r12
cltq
add    %r12,%rax
mov    0x58(%rsp),%rsi
movsd  (%rsi,%rax,8),%xmm0
movslq %ecx,%r10
lea    (%r12,%r10,1),%rcx
movsd  %xmm0,(%rsi,%rcx,8)
mov    0x38(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
mov    0x3c0(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm0
lea    (%rsi,%rbp,8),%r11
movsd  %xmm0,(%rdi,%rcx,8)
lea    (%rdx,%rbp,8),%r9
lea    (%rdi,%rbp,8),%r15
test   %r12,%r12
je     1a2f <genPrimeSetBxyzSxyzF+0x90f>
movslq 0x30(%rsp),%rcx
mov    0x58(%rsp),%rbx
lea    (%rbx,%rcx,8),%rbp
mov    0x38(%rsp),%rdi
lea    (%rdi,%rcx,8),%rax
mov    0x3c0(%rsp),%rdx
lea    (%rdx,%rcx,8),%rsi
movslq 0x10(%rsp),%rdx
lea    (%rbx,%rdx,8),%rbx
lea    (%rdi,%rdx,8),%rcx
mov    0x3c0(%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  %xmm7,%xmm0
addsd  -0x10(%rdx,%rdi,8),%xmm0
movsd  %xmm0,-0x10(%r15,%rdi,8)
add    $0xffffffffffffffff,%rdi
cmp    $0x1,%rdi
jg     19e0 <genPrimeSetBxyzSxyzF+0x8c0>
cmp    0x108(%rsp),%r12
mov    0x3d8(%rsp),%rcx
mov    0x3c8(%rsp),%rdi
mov    0x70(%rsp),%ebx
jg     18e0 <genPrimeSetBxyzSxyzF+0x7c0>
movslq %ebx,%rdx
mov    0x3e0(%rsp),%rax
lea    (%rax,%rdx,8),%r12
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     1a70 <genPrimeSetBxyzSxyzF+0x950>
lea    (%rdx,%r10,1),%rax
movsd  %xmm1,(%rdi,%rax,8)
mov    0x3d0(%rsp),%rsi
movhpd %xmm0,(%rsi,%rax,8)
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x1(%rdx),%rax
add    $0xfffffffffffffff8,%r12
test   %rdx,%rdx
mov    %rax,%rdx
jg     1a60 <genPrimeSetBxyzSxyzF+0x940>
jmp    18e0 <genPrimeSetBxyzSxyzF+0x7c0>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x0,0xe8(%rsp)
js     1720 <genPrimeSetBxyzSxyzF+0x600>
mov    0x20(%rsp),%rcx
mov    %rcx,%rax
imul   0x1d8(%rsp),%rax
add    0x180(%rsp),%rax
mov    %rax,0x60(%rsp)
mov    0x18(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x200(%rsp)
mov    0x158(%rsp),%rax
mov    %rax,0x170(%rsp)
mov    0x150(%rsp),%rax
mov    %rax,0x168(%rsp)
mov    0x148(%rsp),%rax
mov    %rax,0x160(%rsp)
mov    0x98(%rsp),%eax
mov    %eax,0xb0(%rsp)
mov    0x94(%rsp),%eax
mov    %eax,0xac(%rsp)
mov    0x4c(%rsp),%eax
mov    %eax,0xa8(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    0x48(%rsp),%eax
mov    %eax,0xa4(%rsp)
mov    0x44(%rsp),%eax
mov    %eax,0xa0(%rsp)
jmp    1c0b <genPrimeSetBxyzSxyzF+0xaeb>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x10(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0xa0(%rsp)
01
addl   $0xffffffff,0xa4(%rsp)
ff
mov    0xb4(%rsp),%eax
add    %eax,0xa8(%rsp)
add    %eax,0xac(%rsp)
add    %eax,0xb0(%rsp)
mov    0x208(%rsp),%rax
add    %rax,0x160(%rsp)
add    %rax,0x168(%rsp)
add    %rax,0x170(%rsp)
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
cmp    0x178(%rsp),%rcx
je     1720 <genPrimeSetBxyzSxyzF+0x600>
cmpl   $0x0,0xf0(%rsp)
js     1ba0 <genPrimeSetBxyzSxyzF+0xa80>
mov    0x10(%rsp),%rcx
mov    %rcx,%rdx
imul   0x1f8(%rsp),%rdx
mov    0x200(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x68(%rsp)
mov    0x60(%rsp),%rax
mov    %rdx,0x210(%rsp)
add    %rdx,%rax
mov    %rax,0xf8(%rsp)
lea    -0x1(%rcx),%eax
imul   0x9c(%rsp),%eax
mov    %eax,0x120(%rsp)
mov    0x170(%rsp),%rbx
mov    0x168(%rsp),%r15
mov    0x160(%rsp),%rbp
mov    0xb0(%rsp),%eax
mov    %eax,0x28(%rsp)
mov    0xac(%rsp),%eax
mov    %eax,0x50(%rsp)
mov    0xa8(%rsp),%r9d
xor    %r8d,%r8d
mov    0xa4(%rsp),%r11d
mov    0xa0(%rsp),%ecx
jmp    1cf3 <genPrimeSetBxyzSxyzF+0xbd3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r8
mov    0x100(%rsp),%ecx
add    $0x1,%ecx
add    $0xffffffff,%r11d
add    $0x14,%r9d
addl   $0x14,0x50(%rsp)
addl   $0x14,0x28(%rsp)
add    $0xa0,%rbp
add    $0xa0,%r15
add    $0xa0,%rbx
cmp    0x188(%rsp),%r8
je     1ba0 <genPrimeSetBxyzSxyzF+0xa80>
movslq %ecx,%rax
add    $0x1,%rax
mov    %rax,0x70(%rsp)
movslq %r11d,%r13
mov    0x3e0(%rsp),%rax
lea    (%rax,%r13,8),%r14
cmpq   $0x0,0x10(%rsp)
mov    %r9d,0xd0(%rsp)
mov    %r8,0x30(%rsp)
mov    %r11d,0x2c(%rsp)
mov    %ecx,0x100(%rsp)
je     1f60 <genPrimeSetBxyzSxyzF+0xe40>
cmp    0x218(%rsp),%r8
je     1f60 <genPrimeSetBxyzSxyzF+0xe40>
movslq %r9d,%r9
mov    0x60(%rsp),%rax
lea    (%r8,%rax,1),%ecx
mov    0x210(%rsp),%rax
lea    (%rcx,%rax,1),%edx
shl    $0x2,%edx
lea    (%rdx,%rdx,4),%edx
add    0x120(%rsp),%ecx
lea    (%rcx,%rcx,4),%ecx
lea    0x14(,%rcx,4),%ecx
mov    0x68(%rsp),%rax
lea    (%rax,%r8,1),%rdi
movslq %ecx,%rcx
add    %rdi,%rcx
mov    0x58(%rsp),%r8
movsd  (%r8,%rcx,8),%xmm0
movslq %edx,%rax
mov    %rax,0xc8(%rsp)
lea    (%rdi,%rax,1),%rdx
movsd  %xmm0,(%r8,%rdx,8)
mov    0x38(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
mov    0x3c0(%rsp),%rax
movsd  (%rax,%rcx,8),%xmm0
lea    (%r8,%r9,8),%rcx
movsd  %xmm0,(%rax,%rdx,8)
lea    (%rsi,%r9,8),%rdx
lea    (%rax,%r9,8),%rsi
mov    %rdi,0xc0(%rsp)
test   %edi,%edi
je     1e98 <genPrimeSetBxyzSxyzF+0xd78>
movslq 0x50(%rsp),%rax
mov    0x58(%rsp),%r9
lea    (%r9,%rax,8),%rdi
mov    %rdi,0xb8(%rsp)
mov    0x38(%rsp),%rdi
lea    (%rdi,%rax,8),%r11
mov    0x3c0(%rsp),%rdi
lea    (%rdi,%rax,8),%r12
movslq 0x28(%rsp),%r8
lea    (%r9,%r8,8),%r10
mov    0x38(%rsp),%rdi
lea    (%rdi,%r8,8),%rdi
mov    0x3c0(%rsp),%rax
lea    (%rax,%r8,8),%r8
mov    0xb8(%rsp),%rax
mov    0x70(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x10(%rax,%r9,8),%xmm0
mulsd  %xmm10,%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(%r12,%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     1e40 <genPrimeSetBxyzSxyzF+0xd20>
mov    0xc0(%rsp),%rax
cmp    0x108(%rsp),%rax
mov    0x3d8(%rsp),%r10
mov    0x3c8(%rsp),%rdi
mov    0xd0(%rsp),%r9d
mov    0x30(%rsp),%r8
mov    0x2c(%rsp),%r11d
mov    0xc8(%rsp),%r12
jg     1cb0 <genPrimeSetBxyzSxyzF+0xb90>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    0x70(%rsp),%rax
nopl   (%rax)
movsd  -0x8(%r14,%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     1ef0 <genPrimeSetBxyzSxyzF+0xdd0>
lea    (%r12,%r13,1),%rax
movsd  %xmm1,(%rdi,%rax,8)
mov    0x3d0(%rsp),%rdi
movhpd %xmm0,(%rdi,%rax,8)
mov    0x3c8(%rsp),%rdi
movlpd %xmm0,(%r10,%rax,8)
lea    -0x1(%r13),%rax
add    $0xfffffffffffffff8,%r14
test   %r13,%r13
mov    %rax,%r13
jg     1ee0 <genPrimeSetBxyzSxyzF+0xdc0>
jmp    1cb0 <genPrimeSetBxyzSxyzF+0xb90>
nopl   0x0(%rax)
mov    0xf8(%rsp),%rax
add    %r8,%rax
shl    $0x2,%rax
lea    (%rax,%rax,4),%r12
mov    0x58(%rsp),%rax
lea    (%rax,%r12,8),%rdi
movaps 0x1b0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x18(%rsp),%rsi
mov    %rsi,0x18(%rsp)
mov    0x20(%rsp),%rdx
mov    %rdx,0x20(%rsp)
mov    0x10(%rsp),%rcx
mov    %rcx,0x10(%rsp)
movaps 0x330(%rsp),%xmm0
movaps 0x220(%rsp),%xmm1
movaps 0x250(%rsp),%xmm2
movaps 0x300(%rsp),%xmm3
movsd  0x380(%rsp),%xmm4
movsd  0x3a0(%rsp),%xmm5
movaps 0x190(%rsp),%xmm6
movaps 0x1a0(%rsp),%xmm7
call   1040 <eriB_1d@plt>
mov    0x38(%rsp),%rax
lea    (%rax,%r12,8),%rdi
movaps 0x1b0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rdx
mov    0x10(%rsp),%rcx
mov    0x30(%rsp),%r8
movaps 0x320(%rsp),%xmm0
movaps 0x230(%rsp),%xmm1
movaps 0x260(%rsp),%xmm2
movaps 0x2f0(%rsp),%xmm3
movsd  0x388(%rsp),%xmm4
movsd  0x3a8(%rsp),%xmm5
movaps 0x190(%rsp),%xmm6
movaps 0x1a0(%rsp),%xmm7
call   1040 <eriB_1d@plt>
mov    0x3c0(%rsp),%rax
lea    (%rax,%r12,8),%rdi
movaps 0x1b0(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rdx
mov    0x10(%rsp),%rcx
mov    0x30(%rsp),%r8
movapd 0x310(%rsp),%xmm0
movapd 0x240(%rsp),%xmm1
movapd 0x270(%rsp),%xmm2
movapd 0x2e0(%rsp),%xmm3
movsd  0x390(%rsp),%xmm4
movsd  0x3b0(%rsp),%xmm5
movapd 0x190(%rsp),%xmm6
movaps 0x1a0(%rsp),%xmm7
call   1040 <eriB_1d@plt>
mov    0x2c(%rsp),%r11d
mov    0x30(%rsp),%r8
mov    0xd0(%rsp),%r9d
mov    0x3c8(%rsp),%rsi
mov    0x3d8(%rsp),%rcx
movapd 0x280(%rsp),%xmm9
movapd 0x290(%rsp),%xmm8
movapd 0x2a0(%rsp),%xmm10
movapd 0x2b0(%rsp),%xmm7
movapd 0x2c0(%rsp),%xmm5
movapd 0x2d0(%rsp),%xmm4
mov    0x68(%rsp),%rax
add    %r8,%rax
cmp    0x108(%rsp),%rax
jg     1cb0 <genPrimeSetBxyzSxyzF+0xb90>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
mov    0x70(%rsp),%rax
nopl   (%rax)
movsd  -0x8(%r14,%rax,8),%xmm2
movsd  -0x8(%rbp,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm3,%xmm1
movsd  -0x8(%rbx,%rax,8),%xmm3
movhpd -0x8(%r15,%rax,8),%xmm3
unpcklpd %xmm2,%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm2,%xmm0
add    $0xffffffffffffffff,%rax
jg     2160 <genPrimeSetBxyzSxyzF+0x1040>
lea    (%r12,%r13,1),%rax
movsd  %xmm1,(%rsi,%rax,8)
mov    0x3d0(%rsp),%rdx
movhpd %xmm0,(%rdx,%rax,8)
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x1(%r13),%rax
add    $0xfffffffffffffff8,%r14
test   %r13,%r13
mov    %rax,%r13
jg     2150 <genPrimeSetBxyzSxyzF+0x1030>
jmp    1cb0 <genPrimeSetBxyzSxyzF+0xb90>
add    $0x348,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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