void altmov_(int n, int npt, double *xpt, double *xopt, double *bmat,
             double *zmat, int ndim, double *sl, double *su, int kopt, int knew,
             double adelt, double *xnew, double *xalt, double *alpha,
             double *cauchy, double *glag, double *hcol, double *w) {
  int xpt_dim1, xpt_offset, bmat_dim1, bmat_offset, zmat_dim1, zmat_offset;
  double d__1, d__2;
  int i, j, k;
  double ha, gw, one, diff, half;
  int ilbd, isbd;
  double slbd;
  int iubd;
  double vlag, subd, temp;
  int ksav;
  double step, zero, curv;
  int iflag;
  double scale, csave, tempa, tempb, tempd, const__, sumin, ggfree;
  int ibdsav;
  double dderiv, bigstp, predsq, presav, distsq, stpsav, wfixsq, wsqsav;
  zmat_dim1 = npt;
  zmat_offset = 1 + zmat_dim1;
  zmat -= zmat_offset;
  xpt_dim1 = npt;
  xpt_offset = 1 + xpt_dim1;
  xpt -= xpt_offset;
  --xopt;
  bmat_dim1 = ndim;
  bmat_offset = 1 + bmat_dim1;
  bmat -= bmat_offset;
  --sl;
  --su;
  --xnew;
  --xalt;
  --glag;
  --hcol;
  --w;
  half = .5;
  one = 1.;
  zero = 0.;
  const__ = one + sqrt(2.);
  for (k = 1; k <= npt; ++k) {
    hcol[k] = 0;
  }
  for (j = 1; j <= npt - n - 1; ++j) {
    temp = zmat[knew + j * zmat_dim1];
    for (k = 1; k <= npt; ++k) {
      hcol[k] += temp * zmat[k + j * zmat_dim1];
    }
  }
  *alpha = hcol[knew];
  ha = half * *alpha;
  for (i = 1; i <= n; ++i) {
    glag[i] = bmat[knew + i * bmat_dim1];
  }
  for (k = 1; k <= npt; ++k) {
    temp = zero;
    for (j = 1; j <= n; ++j) {
      temp += xpt[k + j * xpt_dim1] * xopt[j];
    }
    temp = hcol[k] * temp;
    for (i = 1; i <= n; ++i) {
      glag[i] += temp * xpt[k + i * xpt_dim1];
    }
  }
  presav = zero;
  for (k = 1; k <= npt; ++k) {
    if (k == kopt) {
      continue;
    }
    dderiv = zero;
    distsq = zero;
    for (i = 1; i <= n; ++i) {
      temp = xpt[k + i * xpt_dim1] - xopt[i];
      dderiv += glag[i] * temp;
      distsq += temp * temp;
    }
    subd = adelt / sqrt(distsq);
    slbd = -subd;
    ilbd = 0;
    iubd = 0;
    sumin = subd;
    if (1 < sumin) {
      sumin = 1;
    }
    for (i = 1; i <= n; ++i) {
      temp = xpt[k + i * xpt_dim1] - xopt[i];
      if (temp > zero) {
        if (slbd * temp < sl[i] - xopt[i]) {
          slbd = (sl[i] - xopt[i]) / temp;
          ilbd = -i;
        }
        if (subd * temp > su[i] - xopt[i]) {
          subd = (su[i] - xopt[i]) / temp;
          if (sumin > subd) {
            subd = sumin;
          }
          iubd = i;
        }
      } else if (temp < zero) {
        if (slbd * temp > su[i] - xopt[i]) {
          slbd = (su[i] - xopt[i]) / temp;
          ilbd = i;
        }
        if (subd * temp < sl[i] - xopt[i]) {
          subd = (sl[i] - xopt[i]) / temp;
          if (sumin > subd) {
            subd = sumin;
          }
          iubd = -i;
        }
      }
    }
    if (k == knew) {
      diff = dderiv - one;
      step = slbd;
      vlag = slbd * (dderiv - slbd * diff);
      isbd = ilbd;
      temp = subd * (dderiv - subd * diff);
      if (fabs(temp) > fabs(vlag)) {
        step = subd;
        vlag = temp;
        isbd = iubd;
      }
      tempd = half * dderiv;
      tempa = tempd - diff * slbd;
      tempb = tempd - diff * subd;
      if (tempa * tempb < zero) {
        temp = tempd * tempd / diff;
        if (fabs(temp) > fabs(vlag)) {
          step = tempd / diff;
          vlag = temp;
          isbd = 0;
        }
      }
    } else {
      step = slbd;
      vlag = slbd * (one - slbd);
      isbd = ilbd;
      temp = subd * (one - subd);
      if (fabs(temp) > fabs(vlag)) {
        step = subd;
        vlag = temp;
        isbd = iubd;
      }
      if (subd > half) {
        if (fabs(vlag) < .25) {
          step = half;
          vlag = .25;
          isbd = 0;
        }
      }
      vlag *= dderiv;
    }
    temp = step * (one - step) * distsq;
    predsq = vlag * vlag * (vlag * vlag + ha * temp * temp);
    if (predsq > presav) {
      presav = predsq;
      ksav = k;
      stpsav = step;
      ibdsav = isbd;
    }
  }
  for (i = 1; i <= n; ++i) {
    xnew[i] = xopt[i] + stpsav * (xpt[ksav + i * xpt_dim1] - xopt[i]);
    if (su[i] < xnew[i]) {
      xnew[i] = su[i];
    }
    if (sl[i] > xnew[i]) {
      xnew[i] = sl[i];
    }
  }
  if (ibdsav < 0) {
    xnew[-ibdsav] = sl[-ibdsav];
  }
  if (ibdsav > 0) {
    xnew[ibdsav] = su[ibdsav];
  }
  bigstp = adelt + adelt;
  iflag = 0;
L100:
  wfixsq = zero;
  ggfree = zero;
  for (i = 1; i <= n; ++i) {
    w[i] = zero;
    tempa = xopt[i] - sl[i];
    if (glag[i] < tempa) {
      tempa = glag[i];
    }
    tempb = xopt[i] - su[i];
    if (glag[i] > tempb) {
      tempb = glag[i];
    }
    if (tempa > zero || tempb < zero) {
      w[i] = bigstp;
      ggfree += glag[i] * glag[i];
    }
  }
  if (ggfree == zero) {
    *cauchy = zero;
    return;
  }
L120:
  do {
    temp = adelt * adelt - wfixsq;
    if (temp > zero) {
      wsqsav = wfixsq;
      step = sqrt(temp / ggfree);
      ggfree = zero;
      for (i = 1; i <= n; ++i) {
        if (w[i] == bigstp) {
          temp = xopt[i] - step * glag[i];
          if (temp <= sl[i]) {
            w[i] = sl[i] - xopt[i];
            wfixsq += w[i] * w[i];
          } else if (temp >= su[i]) {
            w[i] = su[i] - xopt[i];
            wfixsq += w[i] * w[i];
          } else {
            ggfree += glag[i] * glag[i];
          }
        }
      }
      if (wfixsq > wsqsav && ggfree > zero) {
        goto L120;
      }
    }
  } while (0);
  gw = zero;
  for (i = 1; i <= n; ++i) {
    if (w[i] == bigstp) {
      w[i] = -step * glag[i];
      xalt[i] = xopt[i] + w[i];
      if (su[i] < xalt[i]) {
        xalt[i] = su[i];
      }
      if (sl[i] > xalt[i]) {
        xalt[i] = sl[i];
      }
    } else if (w[i] == zero) {
      xalt[i] = xopt[i];
    } else if (glag[i] > zero) {
      xalt[i] = sl[i];
    } else {
      xalt[i] = su[i];
    }
    gw += glag[i] * w[i];
  }
  curv = zero;
  for (k = 1; k <= npt; ++k) {
    temp = zero;
    for (j = 1; j <= n; ++j) {
      temp += xpt[k + j * xpt_dim1] * w[j];
    }
    curv += hcol[k] * temp * temp;
  }
  if (iflag == 1) {
    curv = -curv;
  }
  if (curv > -gw && curv < -const__ * gw) {
    scale = -gw / curv;
    for (i = 1; i <= n; ++i) {
      xalt[i] = xopt[i] + scale * w[i];
      if (su[i] < xalt[i]) {
        xalt[i] = su[i];
      }
      if (sl[i] > xalt[i]) {
        xalt[i] = sl[i];
      }
    }
    d__1 = half * gw * scale;
    *cauchy = d__1 * d__1;
  } else {
    d__1 = gw + half * curv;
    *cauchy = d__1 * d__1;
  }
  if (iflag == 0) {
    for (i = 1; i <= n; ++i) {
      glag[i] = -glag[i];
      w[n + i] = xalt[i];
    }
    csave = *cauchy;
    iflag = 1;
    goto L100;
  }
  if (csave > *cauchy) {
    for (i = 1; i <= n; ++i) {
      xalt[i] = w[n + i];
    }
    *cauchy = csave;
  }
}


x86 assembly (clang, -O0):
<altmov_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180,%rsp
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rbp)
mov    0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x58(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x58(%rbp)
mov    0x60(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x60(%rbp)
mov    0x68(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x68(%rbp)
movsd  0x1dca(%rip),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x1db2(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  0x1d85(%rip),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x178(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     12c8 <altmov_+0x1b8>
mov    0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    129e <altmov_+0x18e>
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0x4(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1371 <altmov_+0x261>
mov    -0x28(%rbp),%rax
mov    0x30(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     135e <altmov_+0x24e>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x28(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    130a <altmov_+0x1fa>
jmp    1363 <altmov_+0x253>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    12cf <altmov_+0x1bf>
mov    0x60(%rbp),%rax
movslq 0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mulsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     13e1 <altmov_+0x2d1>
mov    -0x20(%rbp),%rax
mov    0x30(%rbp),%ecx
mov    -0x5c(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    13a2 <altmov_+0x292>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     14ed <altmov_+0x3dd>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1462 <altmov_+0x352>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    140b <altmov_+0x2fb>
mov    0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     14da <altmov_+0x3ca>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x5c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1486 <altmov_+0x376>
jmp    14df <altmov_+0x3cf>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13e8 <altmov_+0x2d8>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1d87 <altmov_+0xc77>
mov    -0x64(%rbp),%eax
cmp    0x28(%rbp),%eax
jne    1521 <altmov_+0x411>
jmp    1d79 <altmov_+0xc69>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     15e4 <altmov_+0x4d4>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x5c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x158(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1548 <altmov_+0x438>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x158(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x180(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0xa4(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  0x1998(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    168a <altmov_+0x57a>
movsd  0x1986(%rip),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1908 <altmov_+0x7f8>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x5c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
jbe    17db <altmov_+0x6cb>
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1749 <altmov_+0x639>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
xor    %eax,%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0x94(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    17d6 <altmov_+0x6c6>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    17cd <altmov_+0x6bd>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x5c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    18f5 <altmov_+0x7e5>
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    18f0 <altmov_+0x7e0>
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xc0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
jbe    185c <altmov_+0x74c>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x5c(%rbp),%eax
mov    %eax,-0x94(%rbp)
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  -0xc0(%rbp),%xmm1
ff
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    18eb <altmov_+0x7db>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    18e0 <altmov_+0x7d0>
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
xor    %eax,%eax
sub    -0x5c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
jmp    18f0 <altmov_+0x7e0>
jmp    18f5 <altmov_+0x7e5>
jmp    18fa <altmov_+0x7ea>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1691 <altmov_+0x581>
mov    -0x64(%rbp),%eax
cmp    0x30(%rbp),%eax
jne    1b7b <altmov_+0xa6b>
movsd  -0x138(%rbp),%xmm0
ff
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x138(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm3
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movaps 0x1636(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movaps 0x1623(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a37 <altmov_+0x927>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xa4(%rbp),%eax
mov    %eax,-0x98(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0xb8(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x108(%rbp),%xmm1
ff
movsd  -0xd8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1b76 <altmov_+0xa66>
movsd  -0x110(%rbp),%xmm0
ff
mulsd  -0x110(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movaps 0x1502(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movaps 0x14ef(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b71 <altmov_+0xa61>
movsd  -0x110(%rbp),%xmm0
ff
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x98(%rbp)
jmp    1b76 <altmov_+0xa66>
jmp    1cb7 <altmov_+0xba7>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
subsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x94(%rbp),%eax
mov    %eax,-0x98(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
subsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movaps 0x1438(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
movaps 0x1425(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c35 <altmov_+0xb25>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xa4(%rbp),%eax
mov    %eax,-0x98(%rbp)
movsd  -0xb8(%rbp),%xmm0
ff
ucomisd -0x90(%rbp),%xmm0
ff
jbe    1c9f <altmov_+0xb8f>
movsd  -0xb0(%rbp),%xmm1
ff
movaps 0x13c6(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x13b2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c9a <altmov_+0xb8a>
movsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  0x1390(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movl   $0x0,-0x98(%rbp)
jmp    1c9f <altmov_+0xb8f>
movsd  -0x138(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm1
subsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
mulsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm3
ff
movsd  -0x70(%rbp),%xmm2
mulsd  -0xc0(%rbp),%xmm2
ff
mulsd  -0xc0(%rbp),%xmm2
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x148(%rbp),%xmm0
ff
ucomisd -0x150(%rbp),%xmm0
ff
jbe    1d74 <altmov_+0xc64>
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
mov    -0x64(%rbp),%eax
mov    %eax,-0xc4(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
mov    -0x98(%rbp),%eax
mov    %eax,-0x12c(%rbp)
jmp    1d79 <altmov_+0xc69>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1504 <altmov_+0x3f4>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1e77 <altmov_+0xd67>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x160(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0xc4(%rbp),%ecx
mov    -0x5c(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1e2a <altmov_+0xd1a>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1e64 <altmov_+0xd54>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e69 <altmov_+0xd59>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1d8e <altmov_+0xc7e>
cmpl   $0x0,-0x12c(%rbp)
jge    1eac <altmov_+0xd9c>
mov    0x18(%rbp),%rax
xor    %ecx,%ecx
sub    -0x12c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x12c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x12c(%rbp)
jle    1ed9 <altmov_+0xdc9>
mov    0x20(%rbp),%rax
movslq -0x12c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movslq -0x12c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movl   $0x0,-0xe4(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     206f <altmov_+0xf5f>
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1f93 <altmov_+0xe83>
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x108(%rbp),%xmm0
ff
jbe    1fe5 <altmov_+0xed5>
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
ja     2015 <altmov_+0xf05>
movsd  -0x108(%rbp),%xmm1
movsd  -0xd8(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    205c <altmov_+0xf4c>
movsd  -0x140(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    2061 <altmov_+0xf51>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1f1c <altmov_+0xe0c>
movsd  -0x128(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
jne    20a0 <altmov_+0xf90>
jp     20a0 <altmov_+0xf90>
movsd  -0xd8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    28fe <altmov_+0x17ee>
jmp    20a5 <altmov_+0xf95>
jmp    20aa <altmov_+0xf9a>
movsd  -0x30(%rbp),%xmm0
movsd  -0x30(%rbp),%xmm2
movsd  -0x168(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
jbe    232e <altmov_+0x121e>
movsd  -0x168(%rbp),%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
divsd  -0x128(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     22f8 <altmov_+0x11e8>
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x140(%rbp),%xmm0
ff
jne    22e5 <altmov_+0x11d5>
jp     22e5 <altmov_+0x11d5>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xd0(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     2230 <altmov_+0x1120>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x168(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
jmp    22e0 <altmov_+0x11d0>
movsd  -0xc0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     22a9 <altmov_+0x1199>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x168(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x168(%rbp)
ff
jmp    22db <altmov_+0x11cb>
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x128(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
jmp    22e0 <altmov_+0x11d0>
jmp    22e5 <altmov_+0x11d5>
jmp    22ea <altmov_+0x11da>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    213d <altmov_+0x102d>
movsd  -0x168(%rbp),%xmm0
ff
ucomisd -0x170(%rbp),%xmm0
ff
jbe    2329 <altmov_+0x1219>
movsd  -0x128(%rbp),%xmm0
ff
ucomisd -0xd8(%rbp),%xmm0
ff
jbe    2329 <altmov_+0x1219>
jmp    20a5 <altmov_+0xf95>
jmp    232e <altmov_+0x121e>
jmp    2333 <altmov_+0x1223>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2529 <altmov_+0x1419>
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x140(%rbp),%xmm0
ff
jne    2451 <altmov_+0x1341>
jp     2451 <altmov_+0x1341>
movsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    2412 <altmov_+0x1302>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    244c <altmov_+0x133c>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    24ef <altmov_+0x13df>
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xd8(%rbp),%xmm0
ff
jne    2491 <altmov_+0x1381>
jp     2491 <altmov_+0x1381>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    24ea <altmov_+0x13da>
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xd8(%rbp),%xmm0
ff
jbe    24cb <altmov_+0x13bb>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    24e5 <altmov_+0x13d5>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    24ea <altmov_+0x13da>
jmp    24ef <altmov_+0x13df>
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    2347 <altmov_+0x1237>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe0(%rbp)
ff
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     25fd <altmov_+0x14ed>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     25ba <altmov_+0x14aa>
mov    -0x10(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    -0x60(%rbp),%edx
imul   -0x34(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    2563 <altmov_+0x1453>
mov    0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    2540 <altmov_+0x1430>
cmpl   $0x1,-0xe4(%rbp)
jne    2631 <altmov_+0x1521>
movsd  -0xe0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    27c7 <altmov_+0x16b7>
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x78(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    27c7 <altmov_+0x16b7>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2796 <altmov_+0x1686>
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x68(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    2749 <altmov_+0x1639>
mov    0x20(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    2783 <altmov_+0x1673>
mov    0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2788 <altmov_+0x1678>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    26c8 <altmov_+0x15b8>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
mulsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    27fb <altmov_+0x16eb>
movsd  -0x78(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
mulsd  -0x50(%rbp),%xmm0
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x0,-0xe4(%rbp)
jne    2898 <altmov_+0x1788>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     2879 <altmov_+0x1769>
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x58(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    280f <altmov_+0x16ff>
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x1,-0xe4(%rbp)
jmp    1ef5 <altmov_+0xde5>
movsd  -0xf8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
ucomisd (%rax),%xmm0
jbe    28fe <altmov_+0x17ee>
movl   $0x1,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     28ee <altmov_+0x17de>
mov    0x68(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
movslq -0x5c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    28b5 <altmov_+0x17a5>
movsd  -0xf8(%rbp),%xmm0
ff
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x180,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<altmov_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
movsd  %xmm0,0xc8(%rsp)
mov    %r9,(%rsp)
mov    %r8,0x38(%rsp)
mov    %rcx,0x80(%rsp)
mov    %rdx,0x20(%rsp)
mov    %esi,%r12d
mov    0x190(%rsp),%rax
mov    %esi,%ebp
not    %ebp
mov    %esi,%r14d
test   %esi,%esi
mov    %rdi,0x48(%rsp)
jle    1182 <altmov_+0x62>
lea    0x0(,%r14,8),%rdx
mov    %rax,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    0x48(%rsp),%rdi
movslq %ebp,%r15
mov    0x178(%rsp),%rsi
mov    0x160(%rsp),%ecx
movabs $0x7ffffffffffffffe,%r8
ff ff 7f
mov    %edi,%eax
not    %eax
add    %r12d,%eax
movslq %r12d,%rbp
test   %eax,%eax
mov    %r12,0x90(%rsp)
mov    %rbp,0x98(%rsp)
mov    %r15,0x30(%rsp)
mov    %r14,0x58(%rsp)
jle    14dc <altmov_+0x3bc>
mov    (%rsp),%r11
lea    (%r11,%r15,8),%rsi
lea    0x1(%r12),%r9d
movslq %ecx,%rax
mov    %rax,0x8(%rsp)
mov    %r12d,%eax
sub    %edi,%eax
lea    -0x1(%r9),%rdi
mov    0x190(%rsp),%r10
lea    (%r10,%r9,8),%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x78(%rsp)
lea    0x0(%rbp,%r15,1),%r14
lea    0x1(%rbp,%r15,1),%rdx
mov    %rdx,0x88(%rsp)
lea    (%r14,%r9,1),%rdx
mov    %rdx,0x10(%rsp)
lea    -0x5(%r9),%rdx
mov    %rdx,0x40(%rsp)
mov    %rdx,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
mov    %rdi,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rbx,%rdx
mov    %rbx,0xa0(%rsp)
and    %r8,%rbx
mov    %rbx,0x68(%rsp)
mov    %r10,%rdx
mov    %r9,%rbx
neg    %rbx
mov    %rbx,0x50(%rsp)
lea    (%r11,%r14,8),%r8
add    $0x38,%r8
lea    0x8(%r11,%r14,8),%r15
mov    %rcx,0x18(%rsp)
add    $0x1,%rcx
mov    %rcx,0x70(%rsp)
lea    0x0(,%rbp,8),%r10
mov    $0x1,%r11d
xor    %r13d,%r13d
jmp    12a7 <altmov_+0x187>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x1,%r13
add    %r10,%r8
add    %r10,%r15
cmp    %rax,%r11
je     14b9 <altmov_+0x399>
test   %r12d,%r12d
jle    1290 <altmov_+0x170>
mov    %r12,%rbx
mov    %r11,%r14
mov    0x98(%rsp),%r12
imul   %r12,%r14
mov    0x8(%rsp),%rcx
add    %r14,%rcx
movsd  (%rsi,%rcx,8),%xmm0
mov    $0x1,%ebp
cmp    $0x4,%rdi
jae    12e0 <altmov_+0x1c0>
mov    %rbx,%r12
jmp    1440 <altmov_+0x320>
xchg   %ax,%ax
mov    %r13,%rcx
imul   %r12,%rcx
mov    0x10(%rsp),%rdx
add    %rcx,%rdx
mov    %rax,%r12
mov    %rsi,%rax
mov    %rdi,%rsi
mov    (%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
mov    %rsi,%rdi
mov    %rax,%rsi
mov    %r12,%rax
cmp    0x190(%rsp),%rdx
mov    0x190(%rsp),%rdx
jbe    1339 <altmov_+0x219>
mov    %rbx,%r12
add    0x88(%rsp),%rcx
mov    (%rsp),%rbx
lea    (%rbx,%rcx,8),%rcx
cmp    0x78(%rsp),%rcx
jb     1440 <altmov_+0x320>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x40(%rsp)
jae    1351 <altmov_+0x231>
xor    %r12d,%r12d
jmp    13db <altmov_+0x2bb>
mov    0x68(%rsp),%rcx
xor    %r12d,%r12d
nopl   0x0(%rax)
movupd -0x30(%r8,%r12,8),%xmm2
movupd -0x20(%r8,%r12,8),%xmm3
mulpd  %xmm1,%xmm2
movupd (%rdx,%r12,8),%xmm4
addpd  %xmm2,%xmm4
movupd 0x10(%rdx,%r12,8),%xmm2
movupd 0x20(%rdx,%r12,8),%xmm5
movupd 0x30(%rdx,%r12,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%rdx,%r12,8)
movupd %xmm3,0x10(%rdx,%r12,8)
movupd -0x10(%r8,%r12,8),%xmm2
movupd (%r8,%r12,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%rdx,%r12,8)
movupd %xmm3,0x30(%rdx,%r12,8)
add    $0x8,%r12
add    $0xfffffffffffffffe,%rcx
jne    1360 <altmov_+0x240>
testb  $0x1,0xa0(%rsp)
01
je     1424 <altmov_+0x304>
or     $0x1,%r12
lea    (%r12,%r14,1),%rcx
movupd (%rsi,%rcx,8),%xmm2
movupd 0x10(%rsi,%rcx,8),%xmm3
movupd -0x8(%rdx,%r12,8),%xmm4
movupd 0x8(%rdx,%r12,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x8(%rdx,%r12,8)
movupd %xmm3,0x8(%rdx,%r12,8)
mov    0x70(%rsp),%rbp
cmp    0x18(%rsp),%rdi
mov    0x90(%rsp),%r12
je     1290 <altmov_+0x170>
nopl   0x0(%rax)
mov    %rbp,%rcx
test   $0x1,%r9b
jne    1466 <altmov_+0x346>
add    %rbp,%r14
movsd  (%rsi,%r14,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rdx,%rbp,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rbp,8)
lea    0x1(%rbp),%rcx
not    %rbp
cmp    0x50(%rsp),%rbp
je     1290 <altmov_+0x170>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rdx,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%rcx,8)
movsd  (%r15,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    1480 <altmov_+0x360>
jmp    1290 <altmov_+0x170>
mov    0x48(%rsp),%rdi
mov    0x30(%rsp),%r15
mov    0x58(%rsp),%r14
mov    0x38(%rsp),%r13
mov    0x8(%rsp),%rbp
mov    0x178(%rsp),%rsi
jmp    14ec <altmov_+0x3cc>
movslq %ecx,%rbp
mov    0x190(%rsp),%rdx
mov    0x38(%rsp),%r13
movsd  -0x8(%rdx,%rbp,8),%xmm0
movsd  %xmm0,0x18(%rsp)
movsd  %xmm0,(%rsi)
mov    %edi,%eax
mov    %rax,0x28(%rsp)
test   %edi,%edi
jle    17b4 <altmov_+0x694>
movslq 0x140(%rsp),%rax
mov    %rax,%r10
not    %r10
movslq %eax,%r8
mov    0x28(%rsp),%rcx
lea    0x1(%rcx),%r9
mov    $0x1,%edi
cmpl   $0x4,0x48(%rsp)
jb     1689 <altmov_+0x569>
cmp    $0x1,%eax
jne    1689 <altmov_+0x569>
lea    (%r9,%rbp,1),%rax
lea    -0x10(,%rax,8),%rax
ff
add    %r13,%rax
cmp    0x188(%rsp),%rax
jbe    157b <altmov_+0x45b>
mov    0x188(%rsp),%rax
lea    (%rax,%r9,8),%rax
add    $0xfffffffffffffff8,%rax
lea    -0x8(,%rbp,8),%rcx
ff
add    %r13,%rcx
cmp    %rax,%rcx
jb     1689 <altmov_+0x569>
mov    %rbp,0x8(%rsp)
mov    %r14,%r12
mov    0x28(%rsp),%rdi
and    $0xfffffffc,%edi
lea    -0x4(%rdi),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rax,%rax
je     1627 <altmov_+0x507>
mov    %r11,%rdx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rdx
lea    (%r8,%r8,4),%rax
mov    0x8(%rsp),%rcx
add    %rcx,%rax
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
lea    0x2(%r10),%rax
lea    0x0(,%r8,8),%r14
add    %r8,%rcx
lea    0x0(,%rcx,8),%rbp
add    %r13,%rbp
xor    %ecx,%ecx
mov    0x188(%rsp),%rbx
xchg   %ax,%ax
movups -0x10(%rbp,%rax,8),%xmm0
movups 0x0(%rbp,%rax,8),%xmm1
movups %xmm0,(%rbx,%rcx,8)
movups %xmm1,0x10(%rbx,%rcx,8)
movups -0x10(%rsi,%rax,8),%xmm0
movupd (%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rcx,8)
movupd %xmm1,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    %r14,%rax
add    $0xfffffffffffffffe,%rdx
jne    15f0 <altmov_+0x4d0>
jmp    1629 <altmov_+0x509>
xor    %ecx,%ecx
test   $0x1,%r11b
mov    0x38(%rsp),%r13
mov    0x8(%rsp),%rbp
je     166f <altmov_+0x54f>
lea    0x0(,%r10,8),%rax
add    %r13,%rax
or     $0x1,%rcx
mov    %rcx,%rdx
imul   %r8,%rdx
add    %rbp,%rdx
movups (%rax,%rdx,8),%xmm0
movupd 0x10(%rax,%rdx,8),%xmm1
mov    0x188(%rsp),%rax
movups %xmm0,-0x8(%rax,%rcx,8)
movupd %xmm1,0x8(%rax,%rcx,8)
cmp    %rdi,0x28(%rsp)
mov    %r12,%r14
mov    0x90(%rsp),%r12
je     17b4 <altmov_+0x694>
or     $0x1,%rdi
mov    %r9d,%ecx
sub    %edi,%ecx
mov    %rdi,%rax
not    %rax
add    %r9,%rax
and    $0x3,%rcx
je     16f2 <altmov_+0x5d2>
mov    %rdi,%rdx
imul   %r8,%rdx
add    %rbp,%rdx
add    %r10,%rdx
lea    0x0(,%rdx,8),%rdx
add    %r13,%rdx
lea    0x0(,%r8,8),%rsi
mov    0x188(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx),%xmm0
movsd  %xmm0,-0x8(%rbx,%rdi,8)
add    $0x1,%rdi
add    %rsi,%rdx
add    $0xffffffffffffffff,%rcx
jne    16d0 <altmov_+0x5b0>
cmp    $0x3,%rax
jae    1704 <altmov_+0x5e4>
jmp    17b4 <altmov_+0x694>
mov    0x188(%rsp),%rbx
cmp    $0x3,%rax
jb     17b4 <altmov_+0x694>
lea    0x3(%rdi),%rax
imul   %r8,%rax
add    %rbp,%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
mov    %r8,%r11
shl    $0x5,%r11
lea    0x2(%rdi),%rcx
imul   %r8,%rcx
add    %rbp,%rcx
lea    0x0(,%rcx,8),%rsi
add    %r13,%rsi
mov    %rdi,%rcx
imul   %r8,%rcx
add    %rbp,%rcx
lea    0x0(,%rcx,8),%rdx
add    %r13,%rdx
lea    0x1(%rdi),%rcx
imul   %r8,%rcx
add    %rbp,%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdx,%r10,8),%xmm0
movsd  %xmm0,-0x8(%rbx,%rdi,8)
movsd  (%rcx,%r10,8),%xmm0
movsd  %xmm0,(%rbx,%rdi,8)
movsd  (%rsi,%r10,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdi,8)
movsd  (%rax,%r10,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rdi,8)
add    $0x4,%rdi
add    %r11,%rax
add    %r11,%rsi
add    %r11,%rdx
add    %r11,%rcx
cmp    %rdi,%r9
jne    1770 <altmov_+0x650>
mov    0x150(%rsp),%rbp
mov    0x20(%rsp),%rax
lea    (%rax,%r15,8),%r11
test   %r12d,%r12d
mov    %r11,0x78(%rsp)
jle    1f69 <altmov_+0xe49>
movsd  0x18(%rsp),%xmm0
mulsd  0x181f(%rip),%xmm0
movsd  %xmm0,0x18(%rsp)
mov    0x48(%rsp),%r10
lea    0x1(%r10),%eax
mov    %r12,%r8
add    $0x1,%r12d
lea    -0x1(%rax),%rdi
mov    %rax,0x8(%rsp)
add    $0xfffffffffffffffe,%rax
mov    %rax,(%rsp)
lea    0x0(,%r14,8),%rax
lea    (%rax,%r15,8),%rcx
add    $0x8,%rcx
mov    %r14,%rdx
shl    $0x4,%rdx
lea    (%rdx,%r15,8),%rsi
add    $0x8,%rsi
mov    %rdi,%r15
mov    %rdi,%r13
and    $0xfffffffffffffffe,%r13
neg    %r13
mov    $0x1,%r9d
jmp    1855 <altmov_+0x735>
nopl   0x0(%rax)
add    $0x1,%r9
add    $0x8,%rcx
add    $0x8,%rsi
cmp    %r12,%r9
je     19b1 <altmov_+0x891>
test   %r10d,%r10d
jle    1840 <altmov_+0x720>
cmpq   $0x0,(%rsp)
je     18c0 <altmov_+0x7a0>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
mov    0x20(%rsp),%rbp
mov    0x80(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,1),%xmm1
mulsd  -0x8(%rbx,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  0x0(%rbp,%rsi,1),%xmm0
mulsd  (%rbx,%rax,8),%xmm0
addsd  %xmm1,%xmm0
add    %rdx,%rbp
lea    (%rax,%r13,1),%rdi
add    $0x2,%rdi
add    $0x2,%rax
cmp    $0x1,%rdi
jne    1880 <altmov_+0x760>
jmp    18c9 <altmov_+0x7a9>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
test   $0x1,%r15b
mov    0x150(%rsp),%rbp
je     18f9 <altmov_+0x7d9>
mov    %rax,%rdi
imul   %r14,%rdi
add    %r9,%rdi
movsd  (%r11,%rdi,8),%xmm1
mov    0x80(%rsp),%rdi
mulsd  -0x8(%rdi,%rax,8),%xmm1
addsd  %xmm1,%xmm0
test   %r10d,%r10d
jle    1840 <altmov_+0x720>
mov    0x190(%rsp),%rax
mulsd  -0x8(%rax,%r9,8),%xmm0
cmpq   $0x0,(%rsp)
je     1971 <altmov_+0x851>
mov    $0x1,%eax
mov    0x20(%rsp),%rbp
mov    0x188(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rax,8)
movsd  0x0(%rbp,%rsi,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
add    %rdx,%rbp
lea    (%rax,%r13,1),%rdi
add    $0x2,%rdi
add    $0x2,%rax
cmp    $0x1,%rdi
jne    1930 <altmov_+0x810>
jmp    1976 <altmov_+0x856>
mov    $0x1,%eax
test   $0x1,%r15b
mov    0x150(%rsp),%rbp
je     1840 <altmov_+0x720>
mov    %rax,%rdi
imul   %r14,%rdi
add    %r9,%rdi
mulsd  (%r11,%rdi,8),%xmm0
mov    0x188(%rsp),%rdi
addsd  -0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rax,8)
jmp    1840 <altmov_+0x720>
test   %r8d,%r8d
mov    0x188(%rsp),%rbx
mov    0x80(%rsp),%r9
jle    1f80 <altmov_+0xe60>
mov    %r15,0xc0(%rsp)
mov    %r12,0x88(%rsp)
mov    0x158(%rsp),%edx
lea    0x0(,%r14,8),%r12
mov    0x30(%rsp),%rax
lea    (%r12,%rax,8),%r15
add    $0x8,%r15
mov    %r14,%rdi
shl    $0x4,%rdi
mov    %r14,%rcx
lea    (%rdi,%rax,8),%r14
add    $0x8,%r14
lea    (%rax,%rcx,1),%rax
mov    0x20(%rsp),%rcx
lea    0x8(%rcx,%rax,8),%rax
xorpd  %xmm10,%xmm10
mov    $0x1,%esi
movapd 0x1607(%rip),%xmm11
movsd  0x15d6(%rip),%xmm12
movapd 0x1605(%rip),%xmm13
movsd  0x15bc(%rip),%xmm14
xorpd  %xmm15,%xmm15
mov    0x8(%rsp),%r8
mov    %rdx,0x70(%rsp)
mov    %rdi,0x68(%rsp)
jmp    1a8e <altmov_+0x96e>
nopw   0x0(%rax,%rax,1)
mov    %ecx,%r11d
movapd %xmm15,%xmm1
add    $0x1,%rsi
add    $0x8,%r15
add    $0x8,%r14
add    $0x8,%rax
movapd %xmm1,%xmm15
mov    %r11d,%ecx
cmp    0x88(%rsp),%rsi
je     1f80 <altmov_+0xe60>
cmp    %rdx,%rsi
je     1a60 <altmov_+0x940>
test   %r10d,%r10d
mov    %ecx,0x40(%rsp)
mov    %rax,0x50(%rsp)
mov    %rsi,0x10(%rsp)
jle    1b38 <altmov_+0xa18>
cmpq   $0x0,(%rsp)
je     1b3f <altmov_+0xa1f>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
mov    0x20(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%r15,1),%xmm1
subsd  -0x8(%r9,%rax,8),%xmm1
movsd  -0x8(%rbx,%rax,8),%xmm2
movsd  (%rbx,%rax,8),%xmm3
unpcklpd %xmm1,%xmm2
unpcklpd %xmm1,%xmm1
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
movsd  (%rcx,%r14,1),%xmm9
subsd  (%r9,%rax,8),%xmm9
unpcklpd %xmm9,%xmm3
unpcklpd %xmm9,%xmm9
mulpd  %xmm3,%xmm9
movapd %xmm9,%xmm0
addpd  %xmm1,%xmm0
add    %rdi,%rcx
lea    (%rax,%r13,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    1ad0 <altmov_+0x9b0>
addpd  %xmm1,%xmm9
jmp    1b48 <altmov_+0xa28>
xorpd  %xmm9,%xmm9
jmp    1b8c <altmov_+0xa6c>
xorpd  %xmm0,%xmm0
mov    $0x1,%eax
mov    0x78(%rsp),%rdx
testb  $0x1,0xc0(%rsp)
01
je     1b8c <altmov_+0xa6c>
mov    %rax,%rcx
imul   0x58(%rsp),%rcx
add    0x10(%rsp),%rcx
movsd  (%rdx,%rcx,8),%xmm9
subsd  -0x8(%r9,%rax,8),%xmm9
movsd  -0x8(%rbx,%rax,8),%xmm1
unpcklpd %xmm9,%xmm1
unpcklpd %xmm9,%xmm9
mulpd  %xmm1,%xmm9
addpd  %xmm0,%xmm9
movapd %xmm9,%xmm0
unpckhpd %xmm9,%xmm0
ucomisd %xmm10,%xmm0
movapd %xmm0,0xa0(%rsp)
jb     1bb0 <altmov_+0xa90>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1c1e <altmov_+0xafe>
nop
movsd  %xmm15,0x38(%rsp)
movapd %xmm9,0xd0(%rsp)
call   1040 <sqrt@plt>
movapd 0xd0(%rsp),%xmm9
movsd  0x38(%rsp),%xmm15
movsd  0x1420(%rip),%xmm14
movapd 0x1457(%rip),%xmm13
movsd  0x1416(%rip),%xmm12
movapd 0x1435(%rip),%xmm11
xorpd  %xmm10,%xmm10
mov    0x8(%rsp),%r8
mov    0x80(%rsp),%r9
mov    0x188(%rsp),%rbx
mov    0x48(%rsp),%r10
movapd %xmm0,%xmm1
movsd  0xc8(%rsp),%xmm0
divsd  %xmm1,%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm11,%xmm1
test   %r10d,%r10d
jle    1d59 <altmov_+0xc39>
movapd %xmm12,%xmm2
minsd  %xmm0,%xmm2
xor    %ecx,%ecx
mov    $0x1,%edx
mov    $0xffffffff,%esi
mov    0x50(%rsp),%rdi
xor    %r11d,%r11d
jmp    1c78 <altmov_+0xb58>
nopl   0x0(%rax)
mov    0x8(%rsp),%r8
add    $0x1,%rdx
add    $0xffffffff,%esi
add    %r12,%rdi
cmp    %rdx,%r8
je     1d5e <altmov_+0xc3e>
movsd  (%rdi),%xmm3
movsd  -0x8(%r9,%rdx,8),%xmm4
subsd  %xmm4,%xmm3
ucomisd %xmm10,%xmm3
jbe    1cf0 <altmov_+0xbd0>
movapd %xmm1,%xmm6
mulsd  %xmm3,%xmm6
mov    0x148(%rsp),%rax
movsd  -0x8(%rax,%rdx,8),%xmm5
subsd  %xmm4,%xmm5
ucomisd %xmm6,%xmm5
jbe    1cb9 <altmov_+0xb99>
divsd  %xmm3,%xmm5
mov    %esi,%r11d
movapd %xmm5,%xmm1
movapd %xmm0,%xmm6
mulsd  %xmm3,%xmm6
movsd  -0x8(%rbp,%rdx,8),%xmm5
subsd  %xmm4,%xmm5
ucomisd %xmm5,%xmm6
jbe    1c65 <altmov_+0xb45>
divsd  %xmm3,%xmm5
movapd %xmm2,%xmm0
maxsd  %xmm5,%xmm0
mov    %edx,%ecx
jmp    1c65 <altmov_+0xb45>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
ucomisd %xmm3,%xmm10
jbe    1c65 <altmov_+0xb45>
movapd %xmm1,%xmm6
mulsd  %xmm3,%xmm6
movsd  -0x8(%rbp,%rdx,8),%xmm5
subsd  %xmm4,%xmm5
ucomisd %xmm5,%xmm6
cmova  %edx,%r11d
jbe    1d1f <altmov_+0xbff>
divsd  %xmm3,%xmm5
movapd %xmm5,%xmm1
movapd %xmm0,%xmm6
mulsd  %xmm3,%xmm6
mov    0x148(%rsp),%r8
movsd  -0x8(%r8,%rdx,8),%xmm5
subsd  %xmm4,%xmm5
ucomisd %xmm6,%xmm5
jbe    1c60 <altmov_+0xb40>
divsd  %xmm3,%xmm5
movapd %xmm2,%xmm0
maxsd  %xmm5,%xmm0
mov    %edx,%ecx
neg    %ecx
jmp    1c60 <altmov_+0xb40>
xor    %r11d,%r11d
xor    %ecx,%ecx
mov    0x160(%rsp),%eax
mov    0x10(%rsp),%rsi
cmp    %rax,%rsi
jne    1e70 <altmov_+0xd50>
movapd %xmm9,%xmm8
addsd  0x1297(%rip),%xmm8
movapd %xmm8,%xmm4
mulsd  %xmm1,%xmm4
movapd %xmm9,%xmm6
subsd  %xmm4,%xmm6
mulsd  %xmm1,%xmm6
movapd %xmm8,%xmm5
mulsd  %xmm0,%xmm5
movapd %xmm9,%xmm7
subsd  %xmm5,%xmm7
mulsd  %xmm0,%xmm7
movapd %xmm7,%xmm3
andpd  %xmm13,%xmm3
movapd %xmm6,%xmm2
andpd  %xmm13,%xmm2
ucomisd %xmm2,%xmm3
cmova  %ecx,%r11d
mov    0x68(%rsp),%rdi
mov    0x50(%rsp),%rax
ja     1dd7 <altmov_+0xcb7>
movapd %xmm1,%xmm0
cmpltsd %xmm3,%xmm2
andpd  %xmm2,%xmm7
andnpd %xmm6,%xmm2
orpd   %xmm7,%xmm2
mulsd  %xmm14,%xmm9
movapd %xmm9,%xmm1
subsd  %xmm4,%xmm1
movapd %xmm9,%xmm3
subsd  %xmm5,%xmm3
mulsd  %xmm1,%xmm3
ucomisd %xmm3,%xmm10
mov    0x70(%rsp),%rdx
mov    0x40(%rsp),%ecx
jbe    1f16 <altmov_+0xdf6>
movapd %xmm9,%xmm1
mulsd  %xmm9,%xmm1
divsd  %xmm8,%xmm1
movapd %xmm1,%xmm3
andpd  %xmm13,%xmm3
movapd %xmm2,%xmm4
andpd  %xmm13,%xmm4
ucomisd %xmm4,%xmm3
movapd 0xa0(%rsp),%xmm4
jbe    1f1f <altmov_+0xdff>
divsd  %xmm8,%xmm9
xor    %r11d,%r11d
movapd %xmm1,%xmm2
movapd %xmm9,%xmm0
jmp    1f1f <altmov_+0xdff>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm12,%xmm4
subsd  %xmm1,%xmm4
mulsd  %xmm1,%xmm4
movapd %xmm12,%xmm5
subsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm5
movapd %xmm5,%xmm6
andpd  %xmm13,%xmm6
movapd %xmm4,%xmm2
andpd  %xmm13,%xmm2
ucomisd %xmm2,%xmm6
cmova  %ecx,%r11d
movapd %xmm0,%xmm3
mov    0x68(%rsp),%rdi
mov    0x50(%rsp),%rax
ja     1eb8 <altmov_+0xd98>
movapd %xmm1,%xmm3
cmpltsd %xmm6,%xmm2
andpd  %xmm2,%xmm5
andnpd %xmm4,%xmm2
ucomisd %xmm14,%xmm0
orpd   %xmm5,%xmm2
seta   %cl
movapd %xmm2,%xmm0
andpd  %xmm13,%xmm0
movsd  0x112e(%rip),%xmm1
ucomisd %xmm0,%xmm1
seta   %dl
movapd %xmm14,%xmm0
test   %dl,%cl
mov    $0x0,%ecx
cmovne %ecx,%r11d
jne    1f03 <altmov_+0xde3>
movapd %xmm2,%xmm1
movapd %xmm3,%xmm0
mulsd  %xmm1,%xmm9
movapd %xmm9,%xmm2
mov    0x70(%rsp),%rdx
mov    0x40(%rsp),%ecx
movapd 0xa0(%rsp),%xmm4
movapd %xmm12,%xmm3
subsd  %xmm0,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm4,%xmm3
mulsd  %xmm2,%xmm2
movsd  0x18(%rsp),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm15,%xmm1
jbe    1a60 <altmov_+0x940>
mov    %esi,%ecx
mov    %esi,0x60(%rsp)
movsd  %xmm0,0xb8(%rsp)
jmp    1a68 <altmov_+0x948>
mov    0x48(%rsp),%r10
mov    0x188(%rsp),%rbx
mov    0x80(%rsp),%r9
jmp    1f80 <altmov_+0xe60>
mov    0x168(%rsp),%r14
test   %r10d,%r10d
mov    0x30(%rsp),%r8
mov    0x28(%rsp),%r15
movsd  0xb8(%rsp),%xmm3
jle    2029 <altmov_+0xf09>
movslq 0x60(%rsp),%rdx
mov    0x98(%rsp),%rcx
add    %rcx,%rdx
add    %r8,%rdx
mov    0x20(%rsp),%rax
lea    (%rax,%rdx,8),%rdx
lea    0x0(,%rcx,8),%rsi
xor    %edi,%edi
jmp    1fdc <altmov_+0xebc>
nopl   0x0(%rax)
add    %rsi,%rdx
add    $0x1,%rdi
cmp    %rdi,%r15
je     2029 <altmov_+0xf09>
movsd  (%r9,%rdi,8),%xmm2
movsd  (%rdx),%xmm1
subsd  %xmm2,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r14,%rdi,8)
movsd  0x0(%rbp,%rdi,8),%xmm2
ucomisd %xmm2,%xmm1
jbe    200e <altmov_+0xeee>
movsd  %xmm2,(%r14,%rdi,8)
movapd %xmm2,%xmm1
mov    0x148(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm2
ucomisd %xmm1,%xmm2
jbe    1fd0 <altmov_+0xeb0>
movsd  %xmm2,(%r14,%rdi,8)
jmp    1fd0 <altmov_+0xeb0>
lea    -0x8(%rbp),%rdx
mov    0x148(%rsp),%rsi
test   %r11d,%r11d
js     2041 <altmov_+0xf21>
je     2057 <altmov_+0xf37>
mov    %r11d,%r11d
jmp    2048 <altmov_+0xf28>
lea    -0x8(%rsi),%rdx
neg    %r11d
lea    (%rdx,%r11,8),%rdx
movsd  (%rdx),%xmm1
movsd  %xmm1,-0x8(%r14,%r11,8)
test   %r10d,%r10d
jle    28c2 <altmov_+0x17a2>
mov    0x198(%rsp),%r15
mov    0x170(%rsp),%rdx
lea    0x1(%r10),%edi
movsd  0xc8(%rsp),%xmm1
movapd %xmm1,%xmm8
addsd  %xmm1,%xmm8
mulsd  %xmm1,%xmm1
movsd  %xmm1,0x18(%rsp)
movslq %r10d,%rcx
lea    -0x8(%rbx,%rdi,8),%rax
lea    (%r15,%rcx,8),%r14
mov    %rcx,0x60(%rsp)
add    %rdi,%rcx
lea    -0x8(%r15,%rcx,8),%r11
lea    (%rdx,%rdi,8),%r8
add    $0xfffffffffffffff8,%r8
lea    -0x5(%rdi),%r13
mov    %r13,0x28(%rsp)
shr    $0x2,%r13
add    $0x1,%r13
cmp    %rbx,%r11
seta   %r12b
cmp    %rax,%r14
setb   %dl
and    %r12b,%dl
cmp    %rbx,%r8
seta   %cl
lea    -0x1(%rdi),%r12
cmp    0x170(%rsp),%rax
seta   %al
and    %cl,%al
or     %dl,%al
mov    0x170(%rsp),%rdx
mov    %r14,0xd0(%rsp)
mov    %r8,0xe8(%rsp)
cmp    %r8,%r14
setb   %r8b
mov    %r11,0xf0(%rsp)
cmp    %rdx,%r11
seta   %cl
and    %r8b,%cl
or     %al,%cl
mov    %cl,0xc0(%rsp)
mov    %r12,%r11
and    $0xfffffffffffffffc,%r11
mov    %r13,%rax
mov    %r13,0x58(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%r13
mov    %r13,0xf8(%rsp)
mov    %rdi,%rax
neg    %rax
mov    %rax,0xb8(%rsp)
mov    0x30(%rsp),%rcx
lea    0x0(,%rcx,8),%rax
mov    0x98(%rsp),%r14
lea    (%rax,%r14,8),%rax
add    $0x8,%rax
mov    %rax,0x68(%rsp)
shl    $0x4,%r14
lea    (%r14,%rcx,8),%rax
add    $0x8,%rax
mov    %rax,0x38(%rsp)
mov    %r12,%r13
and    $0xfffffffffffffffe,%r13
neg    %r13
xorpd  %xmm9,%xmm9
movapd 0xe8e(%rip),%xmm10
mov    0x90(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x8(%rsp)
mov    %r11,0x30(%rsp)
lea    0x1(%r11),%rax
mov    %rax,0x100(%rsp)
mov    %rdi,(%rsp)
lea    -0x8(,%rdi,8),%rcx
ff
mov    $0x1,%al
xor    %edi,%edi
mov    %rdi,0x40(%rsp)
mov    0x78(%rsp),%r8
mov    0x20(%rsp),%r11
mov    %rcx,0x10(%rsp)
movsd  %xmm8,0x88(%rsp)
jmp    2229 <altmov_+0x1109>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x180(%rsp),%rax
movsd  (%rax),%xmm1
mov    0x10(%rsp),%rcx
mov    $0x1,%al
mov    %rax,0x40(%rsp)
xor    %eax,%eax
movsd  %xmm1,0x70(%rsp)
test   %r10d,%r10d
jle    28c2 <altmov_+0x17a2>
mov    %eax,0xa0(%rsp)
xor    %eax,%eax
xorpd  %xmm2,%xmm2
jmp    225c <altmov_+0x113c>
nopl   0x0(%rax,%rax,1)
movsd  %xmm8,(%r15,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm2
add    $0x1,%rax
cmp    %rax,%r12
je     22a0 <altmov_+0x1180>
movq   $0x0,(%r15,%rax,8)
movsd  (%r9,%rax,8),%xmm1
movapd %xmm1,%xmm4
subsd  (%rsi,%rax,8),%xmm4
movsd  (%rbx,%rax,8),%xmm3
movapd %xmm3,%xmm5
minsd  %xmm4,%xmm5
ucomisd %xmm9,%xmm5
ja     2240 <altmov_+0x1120>
subsd  0x0(%rbp,%rax,8),%xmm1
maxsd  %xmm1,%xmm3
ucomisd %xmm3,%xmm9
jbe    2253 <altmov_+0x1133>
jmp    2240 <altmov_+0x1120>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm2
jne    22b0 <altmov_+0x1190>
jnp    28c6 <altmov_+0x17a6>
movsd  0x18(%rsp),%xmm1
ucomisd %xmm9,%xmm1
jbe    2420 <altmov_+0x1300>
xorpd  %xmm11,%xmm11
movsd  0x18(%rsp),%xmm1
nopl   0x0(%rax)
divsd  %xmm2,%xmm1
ucomisd %xmm9,%xmm1
jb     22f0 <altmov_+0x11d0>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
test   %r10d,%r10d
jg     235c <altmov_+0x123c>
jmp    24e0 <altmov_+0x13c0>
nopl   0x0(%rax)
movapd %xmm1,%xmm0
movsd  %xmm11,0x50(%rsp)
call   1040 <sqrt@plt>
movsd  0x50(%rsp),%xmm11
mov    0x10(%rsp),%rcx
movapd 0xd1b(%rip),%xmm10
xorpd  %xmm9,%xmm9
movsd  0x88(%rsp),%xmm8
mov    0x170(%rsp),%rdx
mov    0x78(%rsp),%r8
mov    0x148(%rsp),%rsi
mov    0x80(%rsp),%r9
mov    0x188(%rsp),%rbx
mov    0x20(%rsp),%r11
mov    0x48(%rsp),%r10
test   %r10d,%r10d
jle    24e0 <altmov_+0x13c0>
movapd %xmm0,%xmm1
xorpd  %xmm10,%xmm1
xorpd  %xmm2,%xmm2
xor    %eax,%eax
movapd %xmm11,%xmm3
jmp    239b <altmov_+0x127b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
subsd  %xmm4,%xmm6
movsd  %xmm6,(%r15,%rax,8)
mulsd  %xmm6,%xmm6
addsd  %xmm6,%xmm3
add    $0x1,%rax
cmp    %rax,%r12
je     23f0 <altmov_+0x12d0>
movsd  (%r15,%rax,8),%xmm4
ucomisd %xmm8,%xmm4
jne    2392 <altmov_+0x1272>
jp     2392 <altmov_+0x1272>
movsd  (%r9,%rax,8),%xmm4
movsd  (%rbx,%rax,8),%xmm5
movapd %xmm1,%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm4,%xmm7
movsd  (%rsi,%rax,8),%xmm6
ucomisd %xmm7,%xmm6
jae    2380 <altmov_+0x1260>
movsd  0x0(%rbp,%rax,8),%xmm6
ucomisd %xmm6,%xmm7
jae    2380 <altmov_+0x1260>
mulsd  %xmm5,%xmm5
addsd  %xmm5,%xmm2
jmp    2392 <altmov_+0x1272>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
ucomisd %xmm11,%xmm3
jbe    2420 <altmov_+0x1300>
ucomisd %xmm9,%xmm2
jbe    2420 <altmov_+0x1300>
movsd  0xc8(%rsp),%xmm1
mulsd  %xmm1,%xmm1
subsd  %xmm3,%xmm1
ucomisd %xmm9,%xmm1
movapd %xmm3,%xmm11
ja     22d0 <altmov_+0x11b0>
nop
test   %r10d,%r10d
jle    24e0 <altmov_+0x13c0>
movapd %xmm0,%xmm2
xorpd  %xmm10,%xmm2
xorpd  %xmm1,%xmm1
xor    %eax,%eax
jmp    246c <altmov_+0x134c>
nopw   0x0(%rax,%rax,1)
ucomisd %xmm9,%xmm3
jne    24bc <altmov_+0x139c>
jp     24bc <altmov_+0x139c>
movsd  (%r9,%rax,1),%xmm3
movsd  %xmm3,(%rdx,%rax,1)
movsd  (%rbx,%rax,1),%xmm3
mulsd  (%r15,%rax,1),%xmm3
addsd  %xmm3,%xmm1
add    $0x8,%rax
cmp    %rax,%rcx
je     24e4 <altmov_+0x13c4>
movsd  (%r15,%rax,1),%xmm3
ucomisd %xmm8,%xmm3
jne    2440 <altmov_+0x1320>
jp     2440 <altmov_+0x1320>
movsd  (%rbx,%rax,1),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,(%r15,%rax,1)
addsd  (%r9,%rax,1),%xmm3
movsd  %xmm3,(%rdx,%rax,1)
movsd  0x0(%rbp,%rax,1),%xmm4
ucomisd %xmm4,%xmm3
jbe    24aa <altmov_+0x138a>
movsd  %xmm4,(%rdx,%rax,1)
movapd %xmm4,%xmm3
movsd  (%rsi,%rax,1),%xmm4
ucomisd %xmm3,%xmm4
jbe    2454 <altmov_+0x1334>
movsd  %xmm4,(%rdx,%rax,1)
jmp    2454 <altmov_+0x1334>
movsd  (%rbx,%rax,1),%xmm3
ucomisd %xmm9,%xmm3
jbe    24cf <altmov_+0x13af>
movsd  (%rsi,%rax,1),%xmm3
jmp    244f <altmov_+0x132f>
movsd  0x0(%rbp,%rax,1),%xmm3
jmp    244f <altmov_+0x132f>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
cmpl   $0x0,0x90(%rsp)
jle    25e0 <altmov_+0x14c0>
xorpd  %xmm2,%xmm2
mov    $0x1,%eax
mov    0x38(%rsp),%rcx
mov    0x68(%rsp),%rdx
jmp    2541 <altmov_+0x1421>
nopw   0x0(%rax,%rax,1)
mov    0x190(%rsp),%rsi
movsd  -0x8(%rsi,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm4,%xmm2
add    $0x1,%rax
add    $0x8,%rdx
add    $0x8,%rcx
cmp    0x8(%rsp),%rax
je     25e4 <altmov_+0x14c4>
xorpd  %xmm3,%xmm3
test   %r10d,%r10d
jle    2510 <altmov_+0x13f0>
cmpl   $0x2,(%rsp)
jne    2560 <altmov_+0x1440>
xorpd  %xmm3,%xmm3
mov    $0x1,%esi
jmp    25a4 <altmov_+0x1484>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm3,%xmm3
mov    $0x1,%esi
mov    %r11,%rdi
nopl   0x0(%rax)
movsd  (%rdi,%rdx,1),%xmm4
mulsd  -0x8(%r15,%rsi,8),%xmm4
addsd  %xmm3,%xmm4
movsd  (%rdi,%rcx,1),%xmm3
mulsd  (%r15,%rsi,8),%xmm3
addsd  %xmm4,%xmm3
add    %r14,%rdi
lea    (%rsi,%r13,1),%rbp
add    $0x2,%rbp
add    $0x2,%rsi
cmp    $0x1,%rbp
jne    2570 <altmov_+0x1450>
test   $0x1,%r12b
mov    0x150(%rsp),%rbp
je     2510 <altmov_+0x13f0>
mov    %rsi,%rdi
imul   0x98(%rsp),%rdi
add    %rax,%rdi
movsd  (%r8,%rdi,8),%xmm4
mulsd  -0x8(%r15,%rsi,8),%xmm4
addsd  %xmm4,%xmm3
jmp    2510 <altmov_+0x13f0>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm2,%xmm2
testb  $0x1,0x40(%rsp)
mov    0x170(%rsp),%rdx
jne    2610 <altmov_+0x14f0>
mov    0x148(%rsp),%rsi
movapd 0xa2d(%rip),%xmm4
jmp    2624 <altmov_+0x1504>
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0xa18(%rip),%xmm4
xorpd  %xmm4,%xmm2
mov    0x148(%rsp),%rsi
mov    0x10(%rsp),%rcx
movapd %xmm1,%xmm3
xorpd  %xmm4,%xmm3
ucomisd %xmm3,%xmm2
movapd %xmm1,%xmm4
mulsd  0x9df(%rip),%xmm4
jbe    26b0 <altmov_+0x1590>
ucomisd %xmm2,%xmm4
jbe    26b0 <altmov_+0x1590>
divsd  %xmm2,%xmm3
test   %r10d,%r10d
jle    26d0 <altmov_+0x15b0>
xor    %eax,%eax
jmp    2669 <altmov_+0x1549>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rax,%r12
je     26d0 <altmov_+0x15b0>
movsd  (%r15,%rax,8),%xmm2
mulsd  %xmm3,%xmm2
addsd  (%r9,%rax,8),%xmm2
movsd  %xmm2,(%rdx,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm4
ucomisd %xmm4,%xmm2
jbe    2693 <altmov_+0x1573>
movsd  %xmm4,(%rdx,%rax,8)
movapd %xmm4,%xmm2
movsd  (%rsi,%rax,8),%xmm4
ucomisd %xmm2,%xmm4
jbe    2660 <altmov_+0x1540>
movsd  %xmm4,(%rdx,%rax,8)
jmp    2660 <altmov_+0x1540>
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  0x948(%rip),%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm2,%xmm2
movapd %xmm2,%xmm1
jmp    26e0 <altmov_+0x15c0>
cs nopw 0x0(%rax,%rax,1)
mulsd  0x928(%rip),%xmm1
mulsd  %xmm3,%xmm1
mulsd  %xmm1,%xmm1
movapd 0x948(%rip),%xmm3
mov    0x180(%rsp),%rax
movsd  %xmm1,(%rax)
testb  $0x1,0xa0(%rsp)
01
je     28e4 <altmov_+0x17c4>
test   %r10d,%r10d
jle    2211 <altmov_+0x10f1>
cmp    $0x4,%r12
setb   %al
or     0xc0(%rsp),%al
mov    $0x1,%ecx
mov    (%rsp),%rdi
jne    2829 <altmov_+0x1709>
cmpq   $0x4,0x28(%rsp)
jae    2737 <altmov_+0x1617>
xor    %eax,%eax
jmp    27c6 <altmov_+0x16a6>
mov    0xf8(%rsp),%rcx
xor    %eax,%eax
mov    0xd0(%rsp),%rdi
nopl   0x0(%rax)
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
xorpd  %xmm10,%xmm1
xorpd  %xmm10,%xmm2
movupd %xmm1,(%rbx,%rax,8)
movupd %xmm2,0x10(%rbx,%rax,8)
movups (%rdx,%rax,8),%xmm1
movups 0x10(%rdx,%rax,8),%xmm2
movups %xmm1,(%rdi,%rax,8)
movups %xmm2,0x10(%rdi,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm1
movupd 0x30(%rbx,%rax,8),%xmm2
xorpd  %xmm10,%xmm1
xorpd  %xmm10,%xmm2
movupd %xmm1,0x20(%rbx,%rax,8)
movupd %xmm2,0x30(%rbx,%rax,8)
movupd 0x20(%rdx,%rax,8),%xmm1
movupd 0x30(%rdx,%rax,8),%xmm2
movupd %xmm1,0x20(%rdi,%rax,8)
movupd %xmm2,0x30(%rdi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2750 <altmov_+0x1630>
testb  $0x1,0x58(%rsp)
je     2812 <altmov_+0x16f2>
or     $0x1,%rax
movupd -0x8(%rbx,%rax,8),%xmm1
movupd 0x8(%rbx,%rax,8),%xmm2
xorpd  %xmm10,%xmm1
xorpd  %xmm10,%xmm2
movupd %xmm1,-0x8(%rbx,%rax,8)
movupd %xmm2,0x8(%rbx,%rax,8)
movupd -0x8(%rdx,%rax,8),%xmm1
movupd 0x8(%rdx,%rax,8),%xmm2
add    0x60(%rsp),%rax
movupd %xmm1,-0x8(%r15,%rax,8)
movupd %xmm2,0x8(%r15,%rax,8)
mov    0x100(%rsp),%rcx
cmp    0x30(%rsp),%r12
mov    (%rsp),%rdi
je     2200 <altmov_+0x10e0>
mov    %rcx,%rax
test   $0x1,%dil
jne    285c <altmov_+0x173c>
movsd  -0x8(%rbx,%rcx,8),%xmm1
xorpd  %xmm10,%xmm1
movlpd %xmm1,-0x8(%rbx,%rcx,8)
movsd  -0x8(%rdx,%rcx,8),%xmm1
mov    0x60(%rsp),%rax
add    %rcx,%rax
movsd  %xmm1,-0x8(%r15,%rax,8)
lea    0x1(%rcx),%rax
not    %rcx
cmp    0xb8(%rsp),%rcx
mov    (%rsp),%rcx
mov    0xd0(%rsp),%rdi
je     2200 <altmov_+0x10e0>
nopl   0x0(%rax)
movsd  -0x8(%rbx,%rax,8),%xmm1
xorpd  %xmm3,%xmm1
movlpd %xmm1,-0x8(%rbx,%rax,8)
movsd  -0x8(%rdx,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rdi,%rax,8)
movsd  (%rbx,%rax,8),%xmm1
xorpd  %xmm3,%xmm1
movlpd %xmm1,(%rbx,%rax,8)
movsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    2880 <altmov_+0x1760>
jmp    2200 <altmov_+0x10e0>
xorpd  %xmm1,%xmm1
mov    0x180(%rsp),%rax
movsd  %xmm1,(%rax)
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsd  0x70(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jbe    28d2 <altmov_+0x17b2>
test   %r10d,%r10d
jle    2a57 <altmov_+0x1937>
mov    $0x1,%eax
cmp    $0x4,%r12
jb     29c3 <altmov_+0x18a3>
cmp    %rdx,0xf0(%rsp)
mov    0xd0(%rsp),%rsi
jbe    2928 <altmov_+0x1808>
cmp    0xe8(%rsp),%rsi
jb     29c3 <altmov_+0x18a3>
mov    $0x1,%eax
cmpq   $0x4,0x28(%rsp)
jb     2988 <altmov_+0x1868>
movabs $0x7ffffffffffffffe,%rcx
ff ff 7f
and    0x58(%rsp),%rcx
mov    $0x6,%eax
nopl   0x0(%rax)
movups -0x30(%rsi,%rax,8),%xmm0
movups -0x20(%rsi,%rax,8),%xmm1
movups %xmm0,-0x30(%rdx,%rax,8)
movups %xmm1,-0x20(%rdx,%rax,8)
movupd -0x10(%rsi,%rax,8),%xmm0
movupd (%rsi,%rax,8),%xmm1
movupd %xmm0,-0x10(%rdx,%rax,8)
movupd %xmm1,(%rdx,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    2950 <altmov_+0x1830>
add    $0xfffffffffffffffb,%rax
testb  $0x1,0x58(%rsp)
je     29b1 <altmov_+0x1891>
mov    0x60(%rsp),%rcx
add    %rax,%rcx
movupd -0x8(%r15,%rcx,8),%xmm0
movupd 0x8(%r15,%rcx,8),%xmm1
movupd %xmm0,-0x8(%rdx,%rax,8)
movupd %xmm1,0x8(%rdx,%rax,8)
mov    0x30(%rsp),%rax
cmp    %rax,%r12
je     2a57 <altmov_+0x1937>
or     $0x1,%rax
mov    (%rsp),%rbp
mov    %ebp,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %rbp,%rcx
and    $0x3,%rdx
je     2a05 <altmov_+0x18e5>
mov    0x60(%rsp),%rsi
lea    (%r15,%rsi,8),%rsi
add    $0xfffffffffffffff8,%rsi
mov    0x170(%rsp),%rdi
nop
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rdi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    29f0 <altmov_+0x18d0>
cmp    $0x3,%rcx
mov    0xd0(%rsp),%rdx
jb     2a57 <altmov_+0x1937>
mov    0x170(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  (%rdx,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x8(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
movsd  0x10(%rdx,%rax,8),%xmm0
movsd  %xmm0,0x10(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbp
jne    2a20 <altmov_+0x1900>
movapd %xmm2,%xmm1
jmp    28c6 <altmov_+0x17a6>

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

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