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


x86 assembly (clang, -O0):
<genSetBxyzSxyzF>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x78(%rbp),%eax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
movss  0x48(%rbp),%xmm8
movss  0x40(%rbp),%xmm8
movss  0x38(%rbp),%xmm8
movss  0x30(%rbp),%xmm8
movss  0x28(%rbp),%xmm8
movss  0x20(%rbp),%xmm8
movss  0x18(%rbp),%xmm8
movss  0x10(%rbp),%xmm8
movss  %xmm0,-0x8(%rbp)
movss  %xmm1,-0xc(%rbp)
movss  %xmm2,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
movss  %xmm4,-0x1c(%rbp)
movss  %xmm5,-0x20(%rbp)
movss  %xmm6,-0x24(%rbp)
mov    %esi,-0x28(%rbp)
movss  %xmm7,-0x2c(%rbp)
mov    %edx,-0x30(%rbp)
mov    %ecx,-0x34(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e3c(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  0x28(%rbp),%xmm0
addss  0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1e19(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1dee(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  0x28(%rbp),%xmm1
addss  0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
addss  -0x2c(%rbp),%xmm1
addss  0x28(%rbp),%xmm1
addss  0x48(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x8(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  -0x1c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0xc(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  -0x20(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x18(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
movss  -0x2c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  0x28(%rbp),%xmm0
movss  0x10(%rbp),%xmm2
movss  0x48(%rbp),%xmm1
mulss  0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movss  0x28(%rbp),%xmm0
movss  0x18(%rbp),%xmm2
movss  0x48(%rbp),%xmm1
mulss  0x38(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x68(%rbp)
movss  0x28(%rbp),%xmm0
movss  0x20(%rbp),%xmm2
movss  0x48(%rbp),%xmm1
mulss  0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x8(%rbp),%xmm1
subss  -0x1c(%rbp),%xmm1
movss  -0x8(%rbp),%xmm2
subss  -0x1c(%rbp),%xmm2
movss  -0xc(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
movss  -0xc(%rbp),%xmm3
subss  -0x20(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x10(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  -0x10(%rbp),%xmm2
subss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  0x10(%rbp),%xmm1
subss  0x30(%rbp),%xmm1
movss  0x10(%rbp),%xmm2
subss  0x30(%rbp),%xmm2
movss  0x18(%rbp),%xmm0
subss  0x38(%rbp),%xmm0
movss  0x18(%rbp),%xmm3
subss  0x38(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  0x20(%rbp),%xmm0
subss  0x40(%rbp),%xmm0
movss  0x20(%rbp),%xmm2
subss  0x40(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x58(%rbp),%xmm1
subss  -0x64(%rbp),%xmm1
movss  -0x58(%rbp),%xmm2
subss  -0x64(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm0
subss  -0x68(%rbp),%xmm0
movss  -0x5c(%rbp),%xmm3
subss  -0x68(%rbp),%xmm3
mulss  %xmm3,%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
subss  -0x6c(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
subss  -0x6c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1bb7(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x78(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
mov    -0x14(%rbp),%edi
add    -0x28(%rbp),%edi
add    -0x30(%rbp),%edi
add    -0x34(%rbp),%edi
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
mov    0x70(%rbp),%rsi
mov    $0x1,%al
call   1030 <fgamma_set@plt>
movss  -0x70(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1b5e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movss  -0x74(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movss  -0x18(%rbp),%xmm0
addss  -0x2c(%rbp),%xmm0
addss  0x28(%rbp),%xmm0
addss  0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
call   1050 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xc8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movss  -0x18(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  -0x2c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x70(%rbp),%xmm2
movss  0x28(%rbp),%xmm1
mulss  0x48(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
mulss  -0x74(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <exp@plt>
movaps %xmm0,%xmm1
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1a87(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1590 <genSetBxyzSxyzF+0x450>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4(%rbp)
jmp    2436 <genSetBxyzSxyzF+0x12f6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x9c(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2429 <genSetBxyzSxyzF+0x12e9>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    2416 <genSetBxyzSxyzF+0x12d6>
cmpl   $0x0,-0x7c(%rbp)
je     1b23 <genSetBxyzSxyzF+0x9e3>
mov    -0x80(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     1b23 <genSetBxyzSxyzF+0x9e3>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1b1e <genSetBxyzSxyzF+0x9de>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1b05 <genSetBxyzSxyzF+0x9c5>
mov    0x78(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0xa0(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
add    -0x88(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    0x78(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x9c(%rbp),%ecx
mov    -0x80(%rbp),%edx
add    $0x1,%edx
imul   -0xa0(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
add    -0x88(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    0x78(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0x7c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x9c(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0xa0(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
add    -0x88(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
add    -0x84(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jl     1915 <genSetBxyzSxyzF+0x7d5>
mov    -0x40(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x8(%rbp),%xmm0
subss  -0x1c(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0xc(%rbp),%xmm0
subss  -0x20(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x10(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
jmp    17bf <genSetBxyzSxyzF+0x67f>
mov    -0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
add    -0x84(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
add    -0x28(%rbp),%eax
add    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
sub    -0x98(%rbp),%eax
mov    %eax,-0x94(%rbp)
cmpl   $0x0,-0x94(%rbp)
jl     1aec <genSetBxyzSxyzF+0x9ac>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x98(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jl     1a78 <genSetBxyzSxyzF+0x938>
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xb0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xb4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    197f <genSetBxyzSxyzF+0x83f>
movss  -0xac(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    1945 <genSetBxyzSxyzF+0x805>
jmp    1af1 <genSetBxyzSxyzF+0x9b1>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1634 <genSetBxyzSxyzF+0x4f4>
jmp    1b0a <genSetBxyzSxyzF+0x9ca>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1616 <genSetBxyzSxyzF+0x4d6>
jmp    2403 <genSetBxyzSxyzF+0x12c3>
movl   $0x0,-0x84(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    23fe <genSetBxyzSxyzF+0x12be>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    23e5 <genSetBxyzSxyzF+0x12a5>
cmpl   $0x0,-0x84(%rbp)
je     2024 <genSetBxyzSxyzF+0xee4>
mov    -0x88(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     2024 <genSetBxyzSxyzF+0xee4>
mov    0x78(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0xa0(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
add    -0x88(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    0x78(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0xa0(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
add    -0x88(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    0x78(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0xa0(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
sub    $0x1,%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
add    -0x88(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
add    -0x84(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jl     1e48 <genSetBxyzSxyzF+0xd08>
mov    -0x40(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x10(%rbp),%xmm0
subss  0x30(%rbp),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x18(%rbp),%xmm0
subss  0x38(%rbp),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
mov    -0x90(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x20(%rbp),%xmm0
subss  0x40(%rbp),%xmm0
mov    0x50(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
jmp    1cf2 <genSetBxyzSxyzF+0xbb2>
mov    -0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
add    -0x84(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
add    -0x28(%rbp),%eax
add    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
sub    -0x98(%rbp),%eax
mov    %eax,-0x94(%rbp)
cmpl   $0x0,-0x94(%rbp)
jl     201f <genSetBxyzSxyzF+0xedf>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x98(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jl     1fab <genSetBxyzSxyzF+0xe6b>
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xb0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xb4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    1eb2 <genSetBxyzSxyzF+0xd72>
movss  -0xac(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    1e78 <genSetBxyzSxyzF+0xd38>
jmp    23cc <genSetBxyzSxyzF+0x128c>
mov    0x78(%rbp),%eax
add    $0x1,%eax
shl    $0x2,%eax
mov    -0x7c(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0xa0(%rbp),%edx
add    %edx,%ecx
mov    -0x84(%rbp),%edx
imul   -0xa4(%rbp),%edx
add    %edx,%ecx
add    -0x88(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x40(%rbp),%rdi
movslq -0x8c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x84(%rbp),%ecx
mov    -0x88(%rbp),%r8d
movss  -0x58(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x8(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x1c(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x64(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x10(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  0x30(%rbp),%xmm5
cvtss2sd %xmm5,%xmm5
movss  -0x70(%rbp),%xmm6
cvtss2sd %xmm6,%xmm6
movss  -0x74(%rbp),%xmm7
cvtss2sd %xmm7,%xmm7
movss  -0x78(%rbp),%xmm8
cvtss2sd %xmm8,%xmm8
movsd  %xmm8,(%rsp)
mov    $0x8,%al
call   1060 <eriB_1d@plt>
mov    -0x48(%rbp),%rdi
movslq -0x8c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x84(%rbp),%ecx
mov    -0x88(%rbp),%r8d
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0xc(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x20(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x68(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x18(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  0x38(%rbp),%xmm5
cvtss2sd %xmm5,%xmm5
movss  -0x70(%rbp),%xmm6
cvtss2sd %xmm6,%xmm6
movss  -0x74(%rbp),%xmm7
cvtss2sd %xmm7,%xmm7
movss  -0x78(%rbp),%xmm8
cvtss2sd %xmm8,%xmm8
movsd  %xmm8,(%rsp)
mov    $0x8,%al
call   1060 <eriB_1d@plt>
mov    0x50(%rbp),%rdi
movslq -0x8c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x7c(%rbp),%esi
mov    -0x80(%rbp),%edx
mov    -0x84(%rbp),%ecx
mov    -0x88(%rbp),%r8d
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  -0x10(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  -0x24(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
movss  -0x6c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x20(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  0x40(%rbp),%xmm5
cvtss2sd %xmm5,%xmm5
movss  -0x70(%rbp),%xmm6
cvtss2sd %xmm6,%xmm6
movss  -0x74(%rbp),%xmm7
cvtss2sd %xmm7,%xmm7
movss  -0x78(%rbp),%xmm8
cvtss2sd %xmm8,%xmm8
movsd  %xmm8,(%rsp)
mov    $0x8,%al
call   1060 <eriB_1d@plt>
mov    -0x7c(%rbp),%eax
add    -0x80(%rbp),%eax
add    -0x84(%rbp),%eax
add    -0x88(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x14(%rbp),%eax
add    -0x28(%rbp),%eax
add    -0x30(%rbp),%eax
add    -0x34(%rbp),%eax
sub    -0x98(%rbp),%eax
mov    %eax,-0x94(%rbp)
cmpl   $0x0,-0x94(%rbp)
jl     23c7 <genSetBxyzSxyzF+0x1287>
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x98(%rbp),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x0,-0x90(%rbp)
jl     2353 <genSetBxyzSxyzF+0x1213>
mov    -0x40(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xac(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xac(%rbp)
ff
mov    -0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xb0(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb0(%rbp)
ff
mov    0x50(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x70(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x90(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0xb4(%rbp),%xmm1
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xb4(%rbp)
ff
mov    -0x90(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x90(%rbp)
jmp    225a <genSetBxyzSxyzF+0x111a>
movss  -0xac(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb0(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
jmp    2220 <genSetBxyzSxyzF+0x10e0>
jmp    23cc <genSetBxyzSxyzF+0x128c>
jmp    23d1 <genSetBxyzSxyzF+0x1291>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1b4b <genSetBxyzSxyzF+0xa0b>
jmp    23ea <genSetBxyzSxyzF+0x12aa>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1b2d <genSetBxyzSxyzF+0x9ed>
jmp    2403 <genSetBxyzSxyzF+0x12c3>
jmp    2408 <genSetBxyzSxyzF+0x12c8>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    15e5 <genSetBxyzSxyzF+0x4a5>
jmp    241b <genSetBxyzSxyzF+0x12db>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    15cd <genSetBxyzSxyzF+0x48d>
movss  -0xa8(%rbp),%xmm0
ff
movss  %xmm0,-0x4(%rbp)
movss  -0x4(%rbp),%xmm0
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<genSetBxyzSxyzF>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3b8,%rsp
mov    %r9,0x10(%rsp)
mov    %r8,0x28(%rsp)
movaps %xmm6,%xmm13
movaps %xmm5,%xmm11
movaps %xmm4,%xmm6
mov    %edi,%ebx
movaps %xmm2,%xmm10
movaps %xmm1,%xmm8
movss  0x428(%rsp),%xmm2
movss  0x408(%rsp),%xmm4
movss  0x3f8(%rsp),%xmm12
movss  0x3f0(%rsp),%xmm5
movaps %xmm3,0xd0(%rsp)
movaps %xmm3,%xmm1
unpcklps %xmm4,%xmm1
movaps %xmm7,0x40(%rsp)
movaps %xmm7,%xmm9
unpcklps %xmm2,%xmm9
movaps %xmm0,%xmm14
unpcklps %xmm5,%xmm14
mulps  %xmm1,%xmm14
movaps %xmm8,%xmm15
unpcklps %xmm12,%xmm15
mulps  %xmm1,%xmm15
movss  0x400(%rsp),%xmm2
movaps %xmm10,%xmm7
unpcklps %xmm2,%xmm7
mulps  %xmm1,%xmm7
addps  %xmm9,%xmm1
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
xorps  %xmm12,%xmm12
cvtss2sd %xmm1,%xmm12
mulsd  0x1e28(%rip),%xmm12
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm12
movss  0x410(%rsp),%xmm4
movaps %xmm6,%xmm3
unpcklps %xmm4,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm3,%xmm14
movss  0x418(%rsp),%xmm2
movaps %xmm11,%xmm3
unpcklps %xmm2,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm3,%xmm15
movss  0x420(%rsp),%xmm5
movaps %xmm13,%xmm3
unpcklps %xmm5,%xmm3
mulps  %xmm9,%xmm3
addps  %xmm3,%xmm7
movaps %xmm0,0x160(%rsp)
movaps %xmm0,%xmm3
movaps %xmm6,0x190(%rsp)
subss  %xmm6,%xmm3
movaps %xmm8,0x170(%rsp)
movaps %xmm11,0x1a0(%rsp)
subss  %xmm11,%xmm8
movaps %xmm8,0x280(%rsp)
mulss  %xmm8,%xmm8
movaps %xmm3,0x290(%rsp)
mulss  %xmm3,%xmm3
addss  %xmm8,%xmm3
movaps %xmm10,0x180(%rsp)
movaps %xmm13,0x230(%rsp)
subss  %xmm13,%xmm10
movaps %xmm10,0x270(%rsp)
mulss  %xmm10,%xmm10
addss  %xmm3,%xmm10
movaps %xmm10,0x30(%rsp)
movss  0x3f0(%rsp),%xmm3
subss  %xmm4,%xmm3
movss  0x3f8(%rsp),%xmm0
subss  %xmm2,%xmm0
movaps %xmm0,0x250(%rsp)
mulss  %xmm0,%xmm0
movaps %xmm3,0x260(%rsp)
mulss  %xmm3,%xmm3
addss  %xmm0,%xmm3
movss  0x400(%rsp),%xmm0
subss  %xmm5,%xmm0
movaps %xmm0,0x240(%rsp)
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
movaps %xmm0,0x1b0(%rsp)
movaps 0x1cda(%rip),%xmm0
divps  %xmm1,%xmm0
mulps  %xmm0,%xmm14
mulps  %xmm0,%xmm15
movaps %xmm0,%xmm4
movaps %xmm0,0xa0(%rsp)
movaps %xmm14,%xmm2
shufps $0x55,%xmm14,%xmm2
movaps %xmm14,0xc0(%rsp)
movaps %xmm14,%xmm0
movaps %xmm2,0x150(%rsp)
subss  %xmm2,%xmm0
movaps %xmm15,%xmm2
shufps $0x55,%xmm15,%xmm2
movaps %xmm15,0x220(%rsp)
movaps %xmm15,%xmm3
movaps %xmm2,0x2a0(%rsp)
subss  %xmm2,%xmm3
mulss  %xmm3,%xmm3
mulss  %xmm0,%xmm0
addss  %xmm3,%xmm0
mulps  %xmm4,%xmm7
movaps %xmm7,%xmm2
shufps $0x55,%xmm7,%xmm2
movaps %xmm7,0x2b0(%rsp)
movaps %xmm7,%xmm3
movaps %xmm2,0x140(%rsp)
subss  %xmm2,%xmm3
mulss  %xmm3,%xmm3
addss  %xmm0,%xmm3
movss  0x408(%rsp),%xmm0
addss  %xmm0,%xmm1
movss  0x428(%rsp),%xmm0
addss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movsd  %xmm0,0xe0(%rsp)
divsd  %xmm0,%xmm12
xorps  %xmm0,%xmm0
cvtsd2ss %xmm12,%xmm0
mov    0x450(%rsp),%rbp
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
mulsd  0x1c25(%rip),%xmm1
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x128(%rsp)
mulsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
mov    %rsi,0x1c8(%rsp)
lea    (%rsi,%rbx,1),%edi
mov    %rdx,0x100(%rsp)
add    %edx,%edi
mov    %rcx,0x108(%rsp)
add    %ecx,%edi
cvtss2sd %xmm0,%xmm0
mov    %edi,0x18(%rsp)
mov    %rbp,%rsi
mov    $0x1,%al
call   1030 <fgamma_set@plt>
movaps 0xa0(%rsp),%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm2,%xmm0
movsd  0x1bcd(%rip),%xmm1
movsd  %xmm0,0x120(%rsp)
mulsd  %xmm0,%xmm1
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
xorps  %xmm0,%xmm0
cvtss2sd %xmm3,%xmm0
movsd  %xmm0,0x118(%rsp)
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
xorpd  %xmm0,%xmm0
movsd  0xe0(%rsp),%xmm1
ucomisd %xmm0,%xmm1
movapd %xmm1,%xmm0
jb     14ae <genSetBxyzSxyzF+0x36e>
sqrtsd %xmm0,%xmm0
jmp    14c3 <genSetBxyzSxyzF+0x383>
movaps %xmm3,0xe0(%rsp)
call   1050 <sqrt@plt>
movaps 0xe0(%rsp),%xmm3
movsd  0x8(%rsp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movaps 0xd0(%rsp),%xmm0
xorps  0x1b2e(%rip),%xmm0
mulss  0x40(%rsp),%xmm0
mulss  0x30(%rsp),%xmm0
movss  0x408(%rsp),%xmm1
movss  0x428(%rsp),%xmm2
mulss  %xmm2,%xmm1
mulss  0x1b0(%rsp),%xmm1
mulss  %xmm3,%xmm1
mulss  0xa0(%rsp),%xmm0
subss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1040 <exp@plt>
mulsd  0x8(%rsp),%xmm0
xorps  %xmm3,%xmm3
cvtsd2ss %xmm0,%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
xorps  %xmm0,%xmm0
movsd  0x1af2(%rip),%xmm2
ucomisd %xmm1,%xmm2
ja     2581 <genSetBxyzSxyzF+0x1441>
test   %ebx,%ebx
js     257e <genSetBxyzSxyzF+0x143e>
movss  %xmm3,0x130(%rsp)
movaps 0x1aa8(%rip),%xmm0
movaps 0x290(%rsp),%xmm5
xorps  %xmm0,%xmm5
movaps 0x280(%rsp),%xmm6
xorps  %xmm0,%xmm6
movaps 0x270(%rsp),%xmm7
xorps  %xmm0,%xmm7
movaps 0x260(%rsp),%xmm8
xorps  %xmm0,%xmm8
movaps 0x250(%rsp),%xmm9
xorps  %xmm0,%xmm9
movaps 0x240(%rsp),%xmm10
xorps  %xmm0,%xmm10
mov    0x458(%rsp),%r9d
mov    0x108(%rsp),%rdi
lea    0x1(%rdi),%ebp
mov    0x100(%rsp),%rax
lea    0x1(%rax),%r11d
mov    %ebp,%edx
imul   %r11d,%edx
mov    0x1c8(%rsp),%r8
lea    0x1(%r8),%ecx
mov    %edx,%esi
imul   %ecx,%esi
lea    0x4(,%r9,4),%r10d
movaps 0xc0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x3a0(%rsp)
movaps 0x160(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x398(%rsp)
movaps 0x190(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x390(%rsp)
movaps 0x150(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x388(%rsp)
movss  0x3f0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x380(%rsp)
movss  0x410(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x378(%rsp)
movaps 0x220(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x370(%rsp)
movaps 0x170(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x368(%rsp)
movaps 0x1a0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x360(%rsp)
movaps 0x2a0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x358(%rsp)
movss  0x3f8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x350(%rsp)
movss  0x418(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x348(%rsp)
movaps 0x2b0(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x340(%rsp)
movaps 0x180(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x338(%rsp)
movaps 0x230(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x330(%rsp)
movaps 0x140(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x328(%rsp)
movss  0x400(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x320(%rsp)
movss  0x420(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0x318(%rsp)
mov    %ebp,0x84(%rsp)
movslq %ebp,%rbp
movslq %r10d,%rax
movslq %esi,%r9
add    $0x1,%ebx
mov    %ecx,%esi
mov    %rsi,0x2e8(%rsp)
mov    %r11d,%esi
mov    %rsi,0x218(%rsp)
mov    %eax,%esi
imul   %ebp,%esi
mov    %esi,0x9c(%rsp)
imul   %r11d,%esi
mov    %esi,0x13c(%rsp)
imul   %ecx,%esi
mov    %esi,0x134(%rsp)
neg    %esi
mov    %esi,0x70(%rsp)
imul   %ebp,%ecx
neg    %ecx
add    %edi,%ecx
add    $0x1,%ecx
imul   %eax,%ecx
imul   %r11d,%ecx
mov    %ecx,0x6c(%rsp)
mov    %edi,%ecx
not    %ecx
imul   %eax,%ecx
mov    %ecx,0x68(%rsp)
mov    %edi,%ecx
imul   %eax,%ecx
neg    %ecx
mov    %ecx,0x64(%rsp)
mov    %r9,0x2c0(%rsp)
imul   %rax,%r9
shl    $0x2,%r9
mov    %r9,0x2c8(%rsp)
mov    %edx,0x138(%rsp)
movslq %edx,%rcx
mov    %rcx,0x2d0(%rsp)
imul   %rax,%rcx
shl    $0x2,%rcx
mov    %rcx,0x2e0(%rsp)
mov    %rax,%rcx
imul   %rbp,%rcx
shl    $0x2,%rcx
mov    %rcx,0x308(%rsp)
mov    0x430(%rsp),%rcx
movslq 0x18(%rsp),%rdx
mov    %rdx,0xe0(%rsp)
mov    %edi,%edx
mov    %rdx,0x3b0(%rsp)
mov    %r8d,%edx
mov    %rdx,0x2d8(%rsp)
mov    %rbp,0x2f8(%rsp)
mov    %ebp,%edx
mov    %rdx,0x230(%rsp)
mov    %rax,0x310(%rsp)
lea    0x0(,%rax,4),%rax
mov    %rax,0x2a0(%rsp)
xor    %eax,%eax
mov    %rax,0xf8(%rsp)
mov    %rcx,0x1e0(%rsp)
mov    0x10(%rsp),%rax
mov    %rax,0x1d8(%rsp)
mov    0x28(%rsp),%rax
mov    %rax,0x1d0(%rsp)
xor    %eax,%eax
mov    %rax,0x30(%rsp)
mov    %rbx,0x2f0(%rsp)
mov    %r10d,0x1b0(%rsp)
movaps %xmm5,0x290(%rsp)
movaps %xmm6,0x280(%rsp)
movaps %xmm7,0x270(%rsp)
movaps %xmm8,0x260(%rsp)
movaps %xmm9,0x250(%rsp)
movaps %xmm10,0x240(%rsp)
jmp    1978 <genSetBxyzSxyzF+0x838>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x30(%rsp),%rdx
add    $0x1,%rdx
addl   $0xffffffff,0x18(%rsp)
mov    0x134(%rsp),%eax
mov    0xf8(%rsp),%rcx
add    %eax,%ecx
mov    %rcx,0xf8(%rsp)
add    %eax,0x70(%rsp)
add    %eax,0x6c(%rsp)
add    %eax,0x68(%rsp)
add    %eax,0x64(%rsp)
mov    0x2c8(%rsp),%rax
add    %rax,0x1d0(%rsp)
add    %rax,0x1d8(%rsp)
add    %rax,0x1e0(%rsp)
mov    %rdx,%rax
mov    %rdx,0x30(%rsp)
cmp    %rbx,%rdx
je     2573 <genSetBxyzSxyzF+0x1433>
cmpl   $0x0,0x1c8(%rsp)
js     1910 <genSetBxyzSxyzF+0x7d0>
mov    0x30(%rsp),%rdx
mov    %rdx,%rax
mov    0x2c0(%rsp),%rcx
imul   %rcx,%rax
mov    %rax,0x220(%rsp)
lea    -0x1(%rdx),%eax
imul   %eax,%ecx
mov    %ecx,0x2b0(%rsp)
mov    0x1e0(%rsp),%rax
mov    %rax,0x1f8(%rsp)
mov    0x1d8(%rsp),%rax
mov    %rax,0x1f0(%rsp)
mov    0x1d0(%rsp),%rax
mov    %rax,0x1e8(%rsp)
mov    0x64(%rsp),%eax
mov    %eax,0x80(%rsp)
mov    0x68(%rsp),%eax
mov    %eax,0x7c(%rsp)
mov    0x6c(%rsp),%eax
mov    %eax,0x78(%rsp)
mov    0x70(%rsp),%eax
mov    %eax,0x74(%rsp)
mov    0xf8(%rsp),%rax
mov    %eax,0x24(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
mov    0x18(%rsp),%eax
mov    %eax,0x20(%rsp)
mov    %edx,%eax
mov    %edx,0x1c(%rsp)
jmp    1a9f <genSetBxyzSxyzF+0x95f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x1c(%rsp)
addl   $0xffffffff,0x20(%rsp)
mov    0x13c(%rsp),%eax
add    %eax,0x24(%rsp)
add    %eax,0x74(%rsp)
add    %eax,0x78(%rsp)
add    %eax,0x7c(%rsp)
add    %eax,0x80(%rsp)
mov    0x2e0(%rsp),%rax
add    %rax,0x1e8(%rsp)
add    %rax,0x1f0(%rsp)
add    %rax,0x1f8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
cmp    0x2e8(%rsp),%rcx
mov    0x2f0(%rsp),%rbx
je     1910 <genSetBxyzSxyzF+0x7d0>
cmpq   $0x0,0x30(%rsp)
je     1e40 <genSetBxyzSxyzF+0xd00>
mov    0x40(%rsp),%rax
cmp    0x2d8(%rsp),%rax
je     1e40 <genSetBxyzSxyzF+0xd00>
cmpl   $0x0,0x100(%rsp)
js     1a30 <genSetBxyzSxyzF+0x8f0>
mov    0x30(%rsp),%rax
mov    0x40(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x110(%rsp)
mov    0x138(%rsp),%eax
mov    %eax,%edx
imul   %ecx,%edx
mov    %edx,0x170(%rsp)
add    $0x1,%ecx
imul   %eax,%ecx
mov    %ecx,0x160(%rsp)
mov    0x78(%rsp),%eax
mov    %eax,0x150(%rsp)
mov    0x74(%rsp),%eax
mov    %eax,0x140(%rsp)
mov    0x24(%rsp),%eax
mov    %eax,0xb8(%rsp)
xor    %eax,%eax
mov    %rax,0xc0(%rsp)
mov    0x20(%rsp),%eax
mov    %eax,0x58(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,0xb0(%rsp)
jmp    1b9e <genSetBxyzSxyzF+0xa5e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0xb0(%rsp)
01
addl   $0xffffffff,0x58(%rsp)
mov    0x9c(%rsp),%eax
add    %eax,0xb8(%rsp)
add    %eax,0x140(%rsp)
add    %eax,0x150(%rsp)
mov    %rcx,%rax
mov    %rcx,0xc0(%rsp)
cmp    0x218(%rsp),%rcx
je     1a30 <genSetBxyzSxyzF+0x8f0>
cmpl   $0x0,0x108(%rsp)
js     1b50 <genSetBxyzSxyzF+0xa10>
movslq 0xb0(%rsp),%r14
add    $0x1,%r14
mov    0x110(%rsp),%rax
mov    0xc0(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x1a0(%rsp)
mov    0x84(%rsp),%eax
imul   %ecx,%eax
mov    %rax,0x190(%rsp)
mov    0x150(%rsp),%eax
mov    %eax,0xd0(%rsp)
mov    0x140(%rsp),%eax
mov    %eax,0x180(%rsp)
mov    0xb8(%rsp),%eax
xor    %r8d,%r8d
mov    0x58(%rsp),%esi
jmp    1c48 <genSetBxyzSxyzF+0xb08>
nopl   (%rax)
add    $0x1,%r8
add    $0xffffffff,%esi
add    $0x1,%r14
mov    0x1b0(%rsp),%r10d
mov    0x8(%rsp),%eax
add    %r10d,%eax
add    %r10d,0x180(%rsp)
add    %r10d,0xd0(%rsp)
cmp    0x230(%rsp),%r8
je     1b50 <genSetBxyzSxyzF+0xa10>
mov    %esi,0xa0(%rsp)
mov    %eax,0x8(%rsp)
cltq
mov    0x190(%rsp),%rcx
add    %r8d,%ecx
mov    0x220(%rsp),%rdx
add    %ecx,%edx
add    0x170(%rsp),%edx
imul   %r10d,%edx
add    0x2b0(%rsp),%ecx
add    0x160(%rsp),%ecx
imul   %r10d,%ecx
mov    0x1a0(%rsp),%rsi
lea    (%rsi,%r8,1),%r12
movslq %ecx,%rcx
add    %r12,%rcx
mov    0x28(%rsp),%rdi
movss  (%rdi,%rcx,4),%xmm0
movslq %edx,%r10
lea    (%r12,%r10,1),%rdx
movss  %xmm0,(%rdi,%rdx,4)
mov    0x10(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
mov    0x430(%rsp),%rbx
movss  (%rbx,%rcx,4),%xmm0
lea    (%rdi,%rax,4),%r11
movss  %xmm0,(%rbx,%rdx,4)
lea    (%rsi,%rax,4),%r9
lea    (%rbx,%rax,4),%r15
test   %r12,%r12
je     1d7f <genSetBxyzSxyzF+0xc3f>
movslq 0x180(%rsp),%rcx
mov    0x28(%rsp),%rbx
lea    (%rbx,%rcx,4),%rbp
mov    0x10(%rsp),%rdi
lea    (%rdi,%rcx,4),%rax
mov    0x430(%rsp),%r13
lea    0x0(%r13,%rcx,4),%rsi
movslq 0xd0(%rsp),%rdx
lea    (%rbx,%rdx,4),%rbx
lea    (%rdi,%rdx,4),%rcx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
mov    %r14,%rdi
nopw   0x0(%rax,%rax,1)
movss  -0x8(%rbp,%rdi,4),%xmm0
mulss  %xmm5,%xmm0
addss  -0x8(%rbx,%rdi,4),%xmm0
movss  %xmm0,-0x8(%r11,%rdi,4)
movss  -0x8(%rax,%rdi,4),%xmm0
mulss  %xmm6,%xmm0
addss  -0x8(%rcx,%rdi,4),%xmm0
movss  %xmm0,-0x8(%r9,%rdi,4)
movss  -0x8(%rsi,%rdi,4),%xmm0
mulss  %xmm7,%xmm0
addss  -0x8(%rdx,%rdi,4),%xmm0
movss  %xmm0,-0x8(%r15,%rdi,4)
add    $0xffffffffffffffff,%rdi
cmp    $0x1,%rdi
jg     1d30 <genSetBxyzSxyzF+0xbf0>
cmp    0xe0(%rsp),%r12
mov    0x440(%rsp),%rdx
mov    0xa0(%rsp),%esi
jg     1c10 <genSetBxyzSxyzF+0xad0>
movslq %esi,%r13
mov    0x450(%rsp),%rax
lea    (%rax,%r13,4),%r12
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
mov    %r14,%rax
nopl   0x0(%rax)
movss  -0x4(%r12,%rax,4),%xmm2
movss  -0x4(%r11,%rax,4),%xmm3
movss  -0x4(%r9,%rax,4),%xmm4
unpcklps %xmm3,%xmm4
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm3,%xmm1
mulss  -0x4(%r15,%rax,4),%xmm2
addss  %xmm2,%xmm0
add    $0xffffffffffffffff,%rax
jg     1dc0 <genSetBxyzSxyzF+0xc80>
lea    (%r10,%r13,1),%rax
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mov    0x438(%rsp),%rcx
movss  %xmm2,(%rcx,%rax,4)
movss  %xmm1,(%rdx,%rax,4)
mov    0x448(%rsp),%rcx
movss  %xmm0,(%rcx,%rax,4)
lea    -0x1(%r13),%rax
add    $0xfffffffffffffffc,%r12
test   %r13,%r13
mov    %rax,%r13
jg     1db0 <genSetBxyzSxyzF+0xc70>
jmp    1c10 <genSetBxyzSxyzF+0xad0>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0x100(%rsp)
js     1a30 <genSetBxyzSxyzF+0x8f0>
mov    0x40(%rsp),%rcx
mov    %rcx,%rax
imul   0x2d0(%rsp),%rax
add    0x220(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0x30(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x300(%rsp)
mov    0x1f8(%rsp),%rax
mov    %rax,0x210(%rsp)
mov    0x1f0(%rsp),%rax
mov    %rax,0x208(%rsp)
mov    0x1e8(%rsp),%rax
mov    %rax,0x200(%rsp)
mov    0x80(%rsp),%eax
mov    %eax,0x98(%rsp)
mov    0x7c(%rsp),%eax
mov    %eax,0x94(%rsp)
mov    0x24(%rsp),%eax
mov    %eax,0x90(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%eax
mov    %eax,0x8c(%rsp)
mov    0x1c(%rsp),%eax
mov    %eax,0x88(%rsp)
jmp    1f5b <genSetBxyzSxyzF+0xe1b>
nop
mov    0x8(%rsp),%rcx
add    $0x1,%rcx
addl   $0x1,0x88(%rsp)
addl   $0xffffffff,0x8c(%rsp)
ff
mov    0x9c(%rsp),%eax
add    %eax,0x90(%rsp)
add    %eax,0x94(%rsp)
add    %eax,0x98(%rsp)
mov    0x308(%rsp),%rax
add    %rax,0x200(%rsp)
add    %rax,0x208(%rsp)
add    %rax,0x210(%rsp)
mov    %rcx,%rax
mov    %rcx,0x8(%rsp)
cmp    0x218(%rsp),%rcx
je     1a30 <genSetBxyzSxyzF+0x8f0>
cmpl   $0x0,0x108(%rsp)
js     1ef0 <genSetBxyzSxyzF+0xdb0>
mov    0x8(%rsp),%rcx
mov    %rcx,%rdx
imul   0x2f8(%rsp),%rdx
mov    0x300(%rsp),%rax
add    %rcx,%rax
mov    %rax,0xc0(%rsp)
mov    0x58(%rsp),%rax
mov    %rdx,0xb0(%rsp)
add    %rdx,%rax
mov    %rax,0x110(%rsp)
lea    -0x1(%rcx),%eax
imul   0x84(%rsp),%eax
mov    %rax,0x3a8(%rsp)
mov    0x210(%rsp),%r15
mov    0x208(%rsp),%rbp
mov    0x200(%rsp),%r12
mov    0x98(%rsp),%eax
mov    %eax,0x170(%rsp)
mov    0x94(%rsp),%eax
mov    %eax,0x160(%rsp)
mov    0x90(%rsp),%ecx
xor    %r8d,%r8d
mov    0x8c(%rsp),%edx
mov    0x88(%rsp),%esi
jmp    2061 <genSetBxyzSxyzF+0xf21>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r8
mov    0x190(%rsp),%esi
add    $0x1,%esi
mov    0x1a0(%rsp),%edx
add    $0xffffffff,%edx
mov    0x180(%rsp),%ecx
add    %r10d,%ecx
add    %r10d,0x160(%rsp)
add    %r10d,0x170(%rsp)
mov    0x2a0(%rsp),%rax
add    %rax,%r12
add    %rax,%rbp
add    %rax,%r15
cmp    0x230(%rsp),%r8
je     1ef0 <genSetBxyzSxyzF+0xdb0>
mov    %esi,0x190(%rsp)
movslq %esi,%rax
add    $0x1,%rax
mov    %rax,0xd0(%rsp)
mov    %edx,0x1a0(%rsp)
movslq %edx,%r13
mov    0x450(%rsp),%rax
lea    (%rax,%r13,4),%rbx
cmpq   $0x0,0x8(%rsp)
mov    %ecx,0x180(%rsp)
mov    %r8,0xa0(%rsp)
je     22e0 <genSetBxyzSxyzF+0x11a0>
cmp    0x3b0(%rsp),%r8
je     22e0 <genSetBxyzSxyzF+0x11a0>
movslq %ecx,%r9
mov    0x58(%rsp),%rax
lea    (%r8,%rax,1),%ecx
mov    0xb0(%rsp),%rax
lea    (%rcx,%rax,1),%edx
imul   %r10d,%edx
mov    0x3a8(%rsp),%rax
add    %eax,%ecx
add    $0x1,%ecx
imul   %r10d,%ecx
mov    0xc0(%rsp),%rax
lea    (%rax,%r8,1),%rdi
movslq %ecx,%rcx
add    %rdi,%rcx
mov    0x28(%rsp),%r8
movss  (%r8,%rcx,4),%xmm0
movslq %edx,%rax
mov    %rax,0x150(%rsp)
lea    (%rdi,%rax,1),%rdx
movss  %xmm0,(%r8,%rdx,4)
mov    0x10(%rsp),%rsi
movss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rsi,%rdx,4)
mov    0x430(%rsp),%rax
movss  (%rax,%rcx,4),%xmm0
lea    (%r8,%r9,4),%rcx
movss  %xmm0,(%rax,%rdx,4)
lea    (%rsi,%r9,4),%rdx
lea    (%rax,%r9,4),%rsi
mov    %rdi,0x140(%rsp)
test   %edi,%edi
je     2208 <genSetBxyzSxyzF+0x10c8>
movslq 0x160(%rsp),%rax
mov    0x28(%rsp),%r9
lea    (%r9,%rax,4),%rdi
mov    %rdi,0xb8(%rsp)
mov    0x10(%rsp),%rdi
lea    (%rdi,%rax,4),%r11
mov    0x430(%rsp),%rdi
lea    (%rdi,%rax,4),%r14
movslq 0x170(%rsp),%r8
lea    (%r9,%r8,4),%r10
mov    0x10(%rsp),%rdi
lea    (%rdi,%r8,4),%rdi
mov    0x430(%rsp),%rax
lea    (%rax,%r8,4),%r8
mov    0xb8(%rsp),%rax
mov    0xd0(%rsp),%r9
movss  -0x8(%rax,%r9,4),%xmm0
mulss  %xmm8,%xmm0
addss  -0x8(%r10,%r9,4),%xmm0
movss  %xmm0,-0x8(%rcx,%r9,4)
movss  -0x8(%r11,%r9,4),%xmm0
mulss  %xmm9,%xmm0
addss  -0x8(%rdi,%r9,4),%xmm0
movss  %xmm0,-0x8(%rdx,%r9,4)
movss  -0x8(%r14,%r9,4),%xmm0
mulss  %xmm10,%xmm0
addss  -0x8(%r8,%r9,4),%xmm0
movss  %xmm0,-0x8(%rsi,%r9,4)
add    $0xffffffffffffffff,%r9
cmp    $0x1,%r9
jg     21b0 <genSetBxyzSxyzF+0x1070>
mov    0x140(%rsp),%rax
cmp    0xe0(%rsp),%rax
mov    0x1b0(%rsp),%r10d
mov    0x440(%rsp),%r9
mov    0xa0(%rsp),%r8
mov    0xd0(%rsp),%r11
mov    0x150(%rsp),%r14
jg     2010 <genSetBxyzSxyzF+0xed0>
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
mov    %r11,%rax
nopl   0x0(%rax)
movss  -0x4(%rbx,%rax,4),%xmm2
movss  -0x4(%rcx,%rax,4),%xmm3
movss  -0x4(%rdx,%rax,4),%xmm4
unpcklps %xmm3,%xmm4
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm3,%xmm1
mulss  -0x4(%rsi,%rax,4),%xmm2
addss  %xmm2,%xmm0
add    $0xffffffffffffffff,%rax
jg     2260 <genSetBxyzSxyzF+0x1120>
lea    (%r14,%r13,1),%rax
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mov    0x438(%rsp),%rdi
movss  %xmm2,(%rdi,%rax,4)
movss  %xmm1,(%r9,%rax,4)
mov    0x448(%rsp),%rdi
movss  %xmm0,(%rdi,%rax,4)
mov    0x440(%rsp),%r9
lea    -0x1(%r13),%rax
add    $0xfffffffffffffffc,%rbx
test   %r13,%r13
mov    %rax,%r13
jg     2250 <genSetBxyzSxyzF+0x1110>
jmp    2010 <genSetBxyzSxyzF+0xed0>
xchg   %ax,%ax
mov    0x110(%rsp),%rax
lea    (%rax,%r8,1),%r14
imul   0x310(%rsp),%r14
mov    0x28(%rsp),%rax
lea    (%rax,%r14,4),%rdi
movsd  0x128(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x30(%rsp),%rsi
mov    %rsi,0x30(%rsp)
mov    0x40(%rsp),%rdx
mov    %rdx,0x40(%rsp)
mov    0x8(%rsp),%rcx
mov    %rcx,0x8(%rsp)
movsd  0x3a0(%rsp),%xmm0
movsd  0x398(%rsp),%xmm1
movsd  0x390(%rsp),%xmm2
movsd  0x388(%rsp),%xmm3
movsd  0x380(%rsp),%xmm4
movsd  0x378(%rsp),%xmm5
movsd  0x120(%rsp),%xmm6
movsd  0x118(%rsp),%xmm7
mov    $0x8,%al
call   1060 <eriB_1d@plt>
mov    0x10(%rsp),%rax
lea    (%rax,%r14,4),%rdi
movsd  0x128(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    0xa0(%rsp),%r8
movsd  0x370(%rsp),%xmm0
movsd  0x368(%rsp),%xmm1
movsd  0x360(%rsp),%xmm2
movsd  0x358(%rsp),%xmm3
movsd  0x350(%rsp),%xmm4
movsd  0x348(%rsp),%xmm5
movsd  0x120(%rsp),%xmm6
movsd  0x118(%rsp),%xmm7
mov    $0x8,%al
call   1060 <eriB_1d@plt>
mov    0x430(%rsp),%rax
lea    (%rax,%r14,4),%rdi
movsd  0x128(%rsp),%xmm0
movsd  %xmm0,(%rsp)
mov    0x30(%rsp),%rsi
mov    0x40(%rsp),%rdx
mov    0x8(%rsp),%rcx
mov    0xa0(%rsp),%r8
movsd  0x340(%rsp),%xmm0
movsd  0x338(%rsp),%xmm1
movsd  0x330(%rsp),%xmm2
movsd  0x328(%rsp),%xmm3
movsd  0x320(%rsp),%xmm4
movsd  0x318(%rsp),%xmm5
movsd  0x120(%rsp),%xmm6
movsd  0x118(%rsp),%xmm7
mov    $0x8,%al
call   1060 <eriB_1d@plt>
mov    0xa0(%rsp),%r8
mov    0x1b0(%rsp),%r10d
movaps 0x240(%rsp),%xmm10
movaps 0x250(%rsp),%xmm9
movaps 0x260(%rsp),%xmm8
movaps 0x270(%rsp),%xmm7
movaps 0x280(%rsp),%xmm6
movaps 0x290(%rsp),%xmm5
mov    0xc0(%rsp),%rax
add    %r8,%rax
cmp    0xe0(%rsp),%rax
mov    0x440(%rsp),%rdx
mov    0xd0(%rsp),%rsi
jg     2010 <genSetBxyzSxyzF+0xed0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xorps  %xmm1,%xmm1
xorps  %xmm0,%xmm0
mov    %rsi,%rax
nopl   0x0(%rax)
movss  -0x4(%rbx,%rax,4),%xmm2
movss  -0x4(%r12,%rax,4),%xmm3
movss  -0x4(%rbp,%rax,4),%xmm4
unpcklps %xmm3,%xmm4
movaps %xmm2,%xmm3
shufps $0x0,%xmm2,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm3,%xmm1
mulss  -0x4(%r15,%rax,4),%xmm2
addss  %xmm2,%xmm0
add    $0xffffffffffffffff,%rax
jg     2500 <genSetBxyzSxyzF+0x13c0>
lea    (%r14,%r13,1),%rax
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
mov    0x438(%rsp),%rcx
movss  %xmm2,(%rcx,%rax,4)
movss  %xmm1,(%rdx,%rax,4)
mov    0x448(%rsp),%rcx
movss  %xmm0,(%rcx,%rax,4)
lea    -0x1(%r13),%rax
add    $0xfffffffffffffffc,%rbx
test   %r13,%r13
mov    %rax,%r13
jg     24f0 <genSetBxyzSxyzF+0x13b0>
jmp    2010 <genSetBxyzSxyzF+0xed0>
movss  0x130(%rsp),%xmm0
jmp    2581 <genSetBxyzSxyzF+0x1441>
movaps %xmm3,%xmm0
add    $0x3b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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