double linmin(double cp[], double xi[], int di, double ftol,
              double (*func)(void *fdata, double tp[]), void *fdata) {
  int i;
  double ax, xx, bx;
  double af, xf, bf;
  double *xt, XT[10];
  if (di <= 10)
    xt = XT;
  else
    xt = dvector(0, di - 1);
  ax = 0.0;
  for (i = 0; i < di; i++)
    xt[i] = cp[i] + ax * xi[i];
  af = (*func)(fdata, xt);
  xx = 1.0 / 1.618034;
  for (i = 0; i < di; i++)
    xt[i] = cp[i] + xx * xi[i];
  xf = (*func)(fdata, xt);
  if (xf > af) {
    double tt;
    tt = ax;
    ax = xx;
    xx = tt;
    tt = af;
    af = xf;
    xf = tt;
  }
  bx = xx + 1.618034 * (xx - ax);
  for (i = 0; i < di; i++)
    xt[i] = cp[i] + bx * xi[i];
  bf = (*func)(fdata, xt);
  while (xf > bf) {
    double ulim, ux, uf;
    double tt, r, q;

    q = (xx - bx) * (xf - af);
    r = (xx - ax) * (xf - bf);
    tt = q - r;
    if (tt >= 0.0 && tt < 1e-20)
      tt = 1e-20;
    else if (tt <= 0.0 && tt > -1e-20)
      tt = -1e-20;
    ux = xx - ((xx - bx) * q - (xx - ax) * r) / (2.0 * tt);
    ulim = xx + 100.0 * (bx - xx);
    if ((xx - ux) * (ux - bx) > 0.0) {
      for (i = 0; i < di; i++)
        xt[i] = cp[i] + ux * xi[i];
      uf = (*func)(fdata, xt);
      if (uf < bf) {
        ax = xx;
        af = xf;
        xx = ux;
        xf = uf;
        break;
      } else if (uf > xf) {
        bx = ux;
        bf = uf;
        break;
      }
      ux = bx + 1.618034 * (bx - xx);
    } else if ((bx - ux) * (ux - ulim) > 0.0) {
      for (i = 0; i < di; i++)
        xt[i] = cp[i] + ux * xi[i];
      uf = (*func)(fdata, xt);
      if (uf > bf) {
        ax = xx;
        af = xf;
        xx = bx;
        xf = bf;
        bx = ux;
        bf = uf;
        break;
      }
      xx = bx;
      xf = bf;
      bx = ux;
      bf = uf;
      ux = bx + 1.618034 * (bx - xx);
    } else if ((ux - ulim) * (ulim - bx) >= 0.0) {
      ux = ulim;
    } else {
      ux = bx + 1.618034 * (bx - xx);
    }
    for (i = 0; i < di; i++)
      xt[i] = cp[i] + ux * xi[i];
    uf = (*func)(fdata, xt);
    ax = xx;
    af = xf;
    xx = bx;
    xf = bf;
    bx = ux;
    bf = uf;
  }
  {
    double wx, vx, ux;
    double wf, vf = 0.0, uf;
    int iter;
    double de = 0.0;
    double e = 0.0;
    if (ax > bx) {
      double tt;
      tt = ax;
      ax = bx;
      bx = tt;
      tt = af;
      af = bf;
      bf = tt;
    }
    wx = vx = xx;
    wf = xf = xf;
    for (iter = 1; iter <= 100; iter++) {
      double mx = 0.5 * (ax + bx);
      double tol1 = ftol * fabs(xx) + 1e-10;
      double tol2 = 2.0 * tol1;

      if (fabs(xx - mx) <= (tol2 - 0.5 * (bx - ax))) {

        break;
      }
      if (fabs(e) > tol1) {
        double te, p, q, r;
        r = (xx - wx) * (xf - vf);
        q = (xx - vx) * (xf - wf);
        p = (xx - vx) * q - (xx - wx) * r;
        q = 2.0 * (q - r);
        if (q > 0.0)
          p = -p;
        else
          q = -q;
        te = e;
        e = de;

        if (fabs(p) >= fabs(0.5 * q * te) || p <= q * (ax - xx) ||
            p >= q * (bx - xx)) {
          e = ((xx >= mx) ? ax - xx : bx - xx);
          de = 0.3819660 * e;

        } else {
          de = p / q;
          ux = xx + de;
          if ((ux - ax) < tol2 || (bx - ux) < tol2) {
            if ((mx - xx) > 0.0)
              de = tol1;
            else
              de = -tol1;
          }
        }
      } else {
        e = ((xx >= mx) ? ax - xx : bx - xx);
        de = 0.3819660 * e;
      }
      if (fabs(de) >= tol1) {
        ux = xx + de;

      } else {
        if (de > 0.0) {
          ux = xx + tol1;

        } else {
          ux = xx - tol1;
        }
      }
      for (i = 0; i < di; i++)
        xt[i] = cp[i] + ux * xi[i];
      uf = (*func)(fdata, xt);
      if (uf <= xf) {
        if (ux >= xx) {
          ax = xx;
          af = xf;
        } else {
          bx = xx;
          bf = xf;
        }
        vx = wx;
        vf = wf;
        wx = xx;
        wf = xf;
        xx = ux;
        xf = uf;

      } else {
        if (ux < xx) {
          ax = ux;
          af = uf;
        } else {
          bx = ux;
          bf = uf;
        }
        if (uf <= wf || wx == xx) {
          vx = wx;
          vf = wf;
          wx = ux;
          wf = uf;
        } else if (uf <= vf || vx == xx || vx == wx) {
          vx = ux;
          vf = uf;
        }
      }
    }
    for (i = 0; i < di; i++)
      cp[i] += xx * xi[i];
  }
  if (xt != XT)
    free_dvector(xt, 0, di - 1);
  return xf;
}


x86 assembly (clang, -O0):
<linmin>:
push   %rbp
mov    %rsp,%rbp
sub    $0x190,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
cmpl   $0xa,-0x14(%rbp)
jg     115d <linmin+0x3d>
lea    -0xc0(%rbp),%rax
mov    %rax,-0x70(%rbp)
jmp    1172 <linmin+0x52>
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
mov    $0x0,%al
call   1030 <dvector@plt>
cltq
mov    %rax,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11cf <linmin+0xaf>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1181 <linmin+0x61>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0x58(%rbp)
movsd  0x1e16(%rip),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1244 <linmin+0x124>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11f6 <linmin+0xd6>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jbe    12af <linmin+0x18f>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  0x1d42(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1328 <linmin+0x208>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12da <linmin+0x1ba>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1871 <linmin+0x751>
movsd  -0x48(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
subsd  -0x58(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
subsd  -0x68(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     13e3 <linmin+0x2c3>
movsd  0x1c50(%rip),%xmm0
ucomisd -0xe8(%rbp),%xmm0
ff
jbe    13e3 <linmin+0x2c3>
movsd  0x1c3a(%rip),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    1423 <linmin+0x303>
xorps  %xmm0,%xmm0
ucomisd -0xe8(%rbp),%xmm0
ff
jb     141e <linmin+0x2fe>
movsd  -0xe8(%rbp),%xmm0
ff
movsd  0x1c14(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    141e <linmin+0x2fe>
movsd  0x1c02(%rip),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    1423 <linmin+0x303>
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
subsd  -0x50(%rbp),%xmm1
movsd  -0xf8(%rbp),%xmm3
ff
movsd  -0x48(%rbp),%xmm2
subsd  -0x40(%rbp),%xmm2
mulsd  -0xf0(%rbp),%xmm2
ff
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x1bb5(%rip),%xmm2
mulsd  -0xe8(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  0x1b7e(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
subsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    15f8 <linmin+0x4d8>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1535 <linmin+0x415>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14e4 <linmin+0x3c4>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1595 <linmin+0x475>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
jmp    1871 <linmin+0x751>
movsd  -0xe0(%rbp),%xmm0
ff
ucomisd -0x60(%rbp),%xmm0
jbe    15c7 <linmin+0x4a7>
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
jmp    1871 <linmin+0x751>
jmp    15cc <linmin+0x4ac>
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  0x1a25(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    17bc <linmin+0x69c>
movsd  -0x50(%rbp),%xmm0
subsd  -0xd8(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
subsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1748 <linmin+0x628>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    167e <linmin+0x55e>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    162d <linmin+0x50d>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
ucomisd -0x68(%rbp),%xmm0
jbe    16ee <linmin+0x5ce>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
jmp    1871 <linmin+0x751>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  0x18d5(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    17b7 <linmin+0x697>
movsd  -0xd8(%rbp),%xmm0
ff
subsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm1
ff
subsd  -0x50(%rbp),%xmm1
mulsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     178b <linmin+0x66b>
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    17b2 <linmin+0x692>
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  0x1866(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
jmp    17b7 <linmin+0x697>
jmp    17bc <linmin+0x69c>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1814 <linmin+0x6f4>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17c3 <linmin+0x6a3>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
jmp    133b <linmin+0x21b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    18ea <linmin+0x7ca>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x148(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  %xmm0,-0x118(%rbp)
ff
movl   $0x1,-0x12c(%rbp)
cmpl   $0x64,-0x12c(%rbp)
jg     206c <linmin+0xf4c>
movsd  -0x40(%rbp),%xmm1
addsd  -0x50(%rbp),%xmm1
movsd  0x1706(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0x20(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movaps 0x16f9(%rip),%xmm2
pand   %xmm2,%xmm1
mulsd  %xmm1,%xmm0
movsd  0x16d1(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
movsd  0x16ad(%rip),%xmm0
mulsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x48(%rbp),%xmm1
subsd  -0x150(%rbp),%xmm1
ff
movaps 0x16b1(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x160(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  0x1673(%rip),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     19d4 <linmin+0x8b4>
jmp    206c <linmin+0xf4c>
movsd  -0x140(%rbp),%xmm0
ff
movaps 0x166d(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x158(%rbp),%xmm0
ff
jbe    1d07 <linmin+0xbe7>
movsd  -0x48(%rbp),%xmm0
subsd  -0x100(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
subsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
subsd  -0x108(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm1
subsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
subsd  -0x108(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm2
ff
movsd  -0x48(%rbp),%xmm1
subsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x180(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x178(%rbp),%xmm1
ff
subsd  -0x180(%rbp),%xmm1
ff
movsd  0x157e(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1af7 <linmin+0x9d7>
movsd  -0x170(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x170(%rbp)
ff
jmp    1b1e <linmin+0x9fe>
movsd  -0x178(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
movaps 0x1503(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x14e7(%rip),%xmm1
mulsd  -0x178(%rbp),%xmm1
ff
mulsd  -0x168(%rbp),%xmm1
ff
movaps 0x14e0(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jae    1bce <linmin+0xaae>
movsd  -0x170(%rbp),%xmm1
ff
movsd  -0x178(%rbp),%xmm0
ff
movsd  -0x40(%rbp),%xmm2
subsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jae    1bce <linmin+0xaae>
movsd  -0x170(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm1
ff
movsd  -0x50(%rbp),%xmm2
subsd  -0x48(%rbp),%xmm2
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jb     1c37 <linmin+0xb17>
movsd  -0x48(%rbp),%xmm0
ucomisd -0x150(%rbp),%xmm0
ff
jb     1bf8 <linmin+0xad8>
movsd  -0x40(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
jmp    1c0a <linmin+0xaea>
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0x1426(%rip),%xmm0
mulsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
jmp    1d02 <linmin+0xbe2>
movsd  -0x170(%rbp),%xmm0
ff
divsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
addsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x110(%rbp),%xmm1
ff
subsd  -0x40(%rbp),%xmm1
movsd  -0x160(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
ja     1ca2 <linmin+0xb82>
movsd  -0x50(%rbp),%xmm1
subsd  -0x110(%rbp),%xmm1
ff
movsd  -0x160(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1cfd <linmin+0xbdd>
movsd  -0x150(%rbp),%xmm0
ff
subsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1cd1 <linmin+0xbb1>
movsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
jmp    1cf8 <linmin+0xbd8>
movsd  -0x158(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
jmp    1cfd <linmin+0xbdd>
jmp    1d02 <linmin+0xbe2>
jmp    1d6b <linmin+0xc4b>
movsd  -0x48(%rbp),%xmm0
ucomisd -0x150(%rbp),%xmm0
ff
jb     1d31 <linmin+0xc11>
movsd  -0x40(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
jmp    1d43 <linmin+0xc23>
movsd  -0x50(%rbp),%xmm0
subsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x190(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
movsd  0x12ed(%rip),%xmm0
mulsd  -0x140(%rbp),%xmm0
ff
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movaps 0x12d6(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x158(%rbp),%xmm0
ff
jb     1da6 <linmin+0xc86>
movsd  -0x48(%rbp),%xmm0
addsd  -0x138(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1def <linmin+0xccf>
movsd  -0x138(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1dd5 <linmin+0xcb5>
movsd  -0x48(%rbp),%xmm0
addsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1dea <linmin+0xcca>
movsd  -0x48(%rbp),%xmm0
subsd  -0x158(%rbp),%xmm0
ff
movsd  %xmm0,-0x110(%rbp)
ff
jmp    1def <linmin+0xccf>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e47 <linmin+0xd27>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x110(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1df6 <linmin+0xcd6>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1f0d <linmin+0xded>
movsd  -0x110(%rbp),%xmm0
ff
ucomisd -0x48(%rbp),%xmm0
jb     1ea0 <linmin+0xd80>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1eb4 <linmin+0xd94>
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x48(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
jmp    2053 <linmin+0xf33>
movsd  -0x110(%rbp),%xmm1
ff
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1f43 <linmin+0xe23>
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x40(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
jmp    1f5d <linmin+0xe3d>
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x118(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    1f90 <linmin+0xe70>
movsd  -0x100(%rbp),%xmm0
ff
ucomisd -0x48(%rbp),%xmm0
jne    1fd5 <linmin+0xeb5>
jp     1fd5 <linmin+0xeb5>
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
jmp    204e <linmin+0xf2e>
movsd  -0x128(%rbp),%xmm1
ff
movsd  -0x120(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    2029 <linmin+0xf09>
movsd  -0x108(%rbp),%xmm0
ff
ucomisd -0x48(%rbp),%xmm0
jne    200d <linmin+0xeed>
jp     200d <linmin+0xeed>
jmp    2029 <linmin+0xf09>
movsd  -0x108(%rbp),%xmm0
ff
ucomisd -0x100(%rbp),%xmm0
ff
jne    2049 <linmin+0xf29>
jp     2049 <linmin+0xf29>
movsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
jmp    204e <linmin+0xf2e>
jmp    2053 <linmin+0xf33>
jmp    2058 <linmin+0xf38>
mov    -0x12c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x12c(%rbp)
jmp    191b <linmin+0x7fb>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    20b9 <linmin+0xf99>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    2073 <linmin+0xf53>
mov    -0x70(%rbp),%rax
lea    -0xc0(%rbp),%rcx
cmp    %rcx,%rax
je     20e0 <linmin+0xfc0>
mov    -0x70(%rbp),%rdi
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
mov    $0x0,%al
call   1040 <free_dvector@plt>
movsd  -0x60(%rbp),%xmm0
add    $0x190,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<linmin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r8,0x18(%rsp)
mov    %rcx,0x10(%rsp)
movsd  %xmm0,0xf8(%rsp)
mov    %edx,%ebp
mov    %rsi,%r15
mov    %rdi,%rbx
movabs $0x7ffffffffffffffe,%r13
ff ff 7f
mov    %edx,%r14d
cmp    $0xb,%edx
jge    117a <linmin+0x5a>
lea    0x100(%rsp),%r12
test   %ebp,%ebp
jle    1501 <linmin+0x3e1>
cmp    $0x4,%ebp
jae    118e <linmin+0x6e>
xor    %eax,%eax
jmp    12ba <linmin+0x19a>
lea    -0x1(%rbp),%esi
xor    %edi,%edi
xor    %eax,%eax
call   1030 <dvector@plt>
movslq %eax,%r12
cmp    $0x4,%ebp
jb     1173 <linmin+0x53>
lea    (%r12,%r14,8),%rax
lea    (%rbx,%r14,8),%rcx
cmp    %rcx,%r12
setb   %dil
cmp    %rbx,%rax
seta   %dl
lea    (%r15,%r14,8),%rcx
cmp    %rcx,%r12
setb   %cl
cmp    %r15,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    12ba <linmin+0x19a>
and    %sil,%cl
jne    12ba <linmin+0x19a>
mov    %r14d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     288b <linmin+0x176b>
mov    %rdx,%rsi
and    %r13,%rsi
xor    %ecx,%ecx
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rcx,8)
movupd %xmm4,0x10(%r12,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movupd 0x20(%r15,%rcx,8),%xmm3
movupd 0x30(%r15,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rcx,8)
movupd %xmm4,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1200 <linmin+0xe0>
test   $0x1,%dl
je     12b5 <linmin+0x195>
movupd (%rbx,%rcx,8),%xmm0
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
xorpd  %xmm4,%xmm4
mulpd  %xmm4,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm4,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm3,0x10(%r12,%rcx,8)
cmp    %r14,%rax
je     1326 <linmin+0x206>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
je     12df <linmin+0x1bf>
xorpd  %xmm0,%xmm0
mulsd  (%r15,%rax,8),%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
or     $0x1,%rax
add    %r14,%rcx
je     1326 <linmin+0x206>
xorpd  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    12f0 <linmin+0x1d0>
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
cmp    $0x4,%ebp
movsd  %xmm0,0x20(%rsp)
jae    1344 <linmin+0x224>
xor    %eax,%eax
jmp    1478 <linmin+0x358>
lea    (%r12,%r14,8),%rax
lea    (%rbx,%r14,8),%rcx
cmp    %rcx,%r12
setb   %dil
cmp    %rbx,%rax
seta   %dl
lea    (%r15,%r14,8),%rcx
cmp    %rcx,%r12
setb   %cl
cmp    %r15,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    1478 <linmin+0x358>
and    %sil,%cl
jne    1478 <linmin+0x358>
mov    %r14d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     289b <linmin+0x177b>
mov    %rdx,%rsi
and    %r13,%rsi
xor    %ecx,%ecx
movapd 0x1c54(%rip),%xmm5
nopl   0x0(%rax)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rcx,8)
movupd %xmm4,0x10(%r12,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movupd 0x20(%r15,%rcx,8),%xmm3
movupd 0x30(%r15,%rcx,8),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rcx,8)
movupd %xmm4,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    13b0 <linmin+0x290>
test   $0x1,%dl
je     1469 <linmin+0x349>
movupd (%rbx,%rcx,8),%xmm5
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
movupd 0x10(%r15,%rcx,8),%xmm3
movapd 0x1bb4(%rip),%xmm4
mulpd  %xmm4,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm4,%xmm3
addpd  %xmm1,%xmm3
movupd %xmm2,(%r12,%rcx,8)
movupd %xmm3,0x10(%r12,%rcx,8)
mov    $0x1,%cl
mov    %ecx,0x4(%rsp)
cmp    %r14,%rax
je     151b <linmin+0x3fb>
mov    %rax,%rdx
not    %rdx
test   $0x1,%r14b
je     14a1 <linmin+0x381>
movsd  (%r15,%rax,8),%xmm1
mulsd  0x1b9e(%rip),%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
or     $0x1,%rax
mov    %r14,%rcx
neg    %rcx
mov    $0x1,%sil
mov    %esi,0x4(%rsp)
cmp    %rcx,%rdx
je     151b <linmin+0x3fb>
add    $0x1,%rax
movsd  0x1b71(%rip),%xmm0
nop
movsd  -0x8(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rax,8)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%r12,%rax,8)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
jne    14c0 <linmin+0x3a0>
jmp    151b <linmin+0x3fb>
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
movsd  %xmm0,0x20(%rsp)
movl   $0x0,0x4(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
movsd  0x20(%rsp),%xmm1
ucomisd %xmm1,%xmm0
jbe    1547 <linmin+0x427>
movsd  0x1af5(%rip),%xmm7
xorpd  %xmm5,%xmm5
movsd  %xmm0,0x20(%rsp)
jmp    1557 <linmin+0x437>
xorpd  %xmm7,%xmm7
movsd  0x1add(%rip),%xmm5
movapd %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
movapd %xmm5,%xmm6
subsd  %xmm7,%xmm6
mulsd  0x1acb(%rip),%xmm6
addsd  %xmm5,%xmm6
cmpb   $0x0,0x4(%rsp)
je     172a <linmin+0x60a>
cmp    $0x4,%ebp
jae    15fb <linmin+0x4db>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
je     15a8 <linmin+0x488>
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
or     $0x1,%rax
add    %r14,%rcx
je     172a <linmin+0x60a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm6,%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    15c0 <linmin+0x4a0>
jmp    172a <linmin+0x60a>
lea    (%r12,%r14,8),%rax
lea    (%rbx,%r14,8),%rcx
cmp    %rcx,%r12
setb   %dil
cmp    %rbx,%rax
seta   %dl
lea    (%r15,%r14,8),%rcx
cmp    %rcx,%r12
setb   %cl
cmp    %r15,%rax
seta   %sil
xor    %eax,%eax
test   %dl,%dil
jne    1583 <linmin+0x463>
and    %sil,%cl
jne    1583 <linmin+0x463>
mov    %r14d,%eax
and    $0xfffffffc,%eax
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     28d3 <linmin+0x17b3>
mov    %rdx,%rsi
and    %r13,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rcx,8)
movupd %xmm4,0x10(%r12,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movupd 0x20(%r15,%rcx,8),%xmm3
movupd 0x30(%r15,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rcx,8)
movupd %xmm4,0x30(%r12,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1670 <linmin+0x550>
test   $0x1,%dl
je     1721 <linmin+0x601>
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm3
movupd 0x10(%r15,%rcx,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rcx,8)
movupd %xmm4,0x10(%r12,%rcx,8)
cmp    %r14,%rax
jne    1583 <linmin+0x463>
mov    %rbp,0x78(%rsp)
movsd  %xmm7,0xa0(%rsp)
movapd %xmm6,0x50(%rsp)
movapd %xmm5,0x30(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
movapd %xmm0,%xmm8
movsd  0x8(%rsp),%xmm0
ucomisd %xmm8,%xmm0
jbe    1f5a <linmin+0xe3a>
lea    (%r12,%r14,8),%rdi
lea    (%rbx,%r14,8),%rcx
lea    (%r15,%r14,8),%rsi
mov    %r13,%r8
mov    %r14d,%ebp
and    $0xfffffffc,%ebp
lea    -0x4(%rbp),%rdx
mov    %rdx,0x68(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %rcx,%r12
setb   %cl
cmp    %rbx,%rdi
seta   %al
and    %cl,%al
cmp    %rsi,%r12
setb   %cl
cmp    %r15,%rdi
seta   %r13b
and    %cl,%r13b
or     %al,%r13b
mov    %rdx,%rax
mov    %rdx,0x80(%rsp)
and    %r8,%rdx
mov    %rdx,0x48(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0x70(%rsp)
xorpd  %xmm7,%xmm7
movapd 0x30(%rsp),%xmm9
movapd 0x50(%rsp),%xmm10
jmp    1823 <linmin+0x703>
nop
movsd  %xmm6,0xa0(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
movapd %xmm5,0x50(%rsp)
call   *0x10(%rsp)
movapd 0x50(%rsp),%xmm10
movapd %xmm0,%xmm8
movsd  0x8(%rsp),%xmm0
ucomisd %xmm8,%xmm0
movapd 0x30(%rsp),%xmm9
xorpd  %xmm7,%xmm7
jbe    1f68 <linmin+0xe48>
movapd %xmm0,%xmm11
movapd %xmm9,%xmm6
movapd %xmm9,%xmm0
subsd  %xmm10,%xmm0
movapd %xmm11,%xmm1
subsd  0x20(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm9,%xmm2
subsd  0xa0(%rsp),%xmm2
movapd %xmm11,%xmm3
subsd  %xmm8,%xmm3
mulsd  %xmm2,%xmm3
mulsd  %xmm1,%xmm0
subsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm3
subsd  %xmm3,%xmm0
movapd %xmm1,%xmm2
addsd  %xmm1,%xmm2
movsd  0x17be(%rip),%xmm3
cmpltsd %xmm1,%xmm3
movapd %xmm3,%xmm4
andnpd %xmm2,%xmm4
movsd  0x17b1(%rip),%xmm5
andpd  %xmm5,%xmm3
orpd   %xmm4,%xmm3
movapd %xmm1,%xmm4
cmplesd %xmm7,%xmm4
andpd  %xmm4,%xmm3
andnpd %xmm2,%xmm4
orpd   %xmm4,%xmm3
xorpd  %xmm2,%xmm2
cmplesd %xmm1,%xmm2
cmpltsd 0x178a(%rip),%xmm1
movapd %xmm1,%xmm4
andnpd %xmm3,%xmm4
movsd  0x1782(%rip),%xmm5
andpd  %xmm5,%xmm1
orpd   %xmm4,%xmm1
andpd  %xmm2,%xmm1
andnpd %xmm3,%xmm2
orpd   %xmm2,%xmm1
divsd  %xmm1,%xmm0
subsd  %xmm0,%xmm9
movapd %xmm10,%xmm12
subsd  %xmm6,%xmm12
movapd %xmm6,%xmm0
subsd  %xmm9,%xmm0
movapd %xmm9,%xmm2
subsd  %xmm10,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm7,%xmm0
movapd %xmm12,%xmm5
mulsd  0x173b(%rip),%xmm5
jbe    1970 <linmin+0x850>
movsd  %xmm11,0x20(%rsp)
movsd  %xmm6,0x90(%rsp)
movsd  %xmm10,0x50(%rsp)
movsd  %xmm8,0x8(%rsp)
cmpb   $0x0,0x4(%rsp)
je     1b70 <linmin+0xa50>
cmpl   $0x4,0x78(%rsp)
setb   %al
or     %r13b,%al
je     1a17 <linmin+0x8f7>
xor    %ecx,%ecx
jmp    1afe <linmin+0x9de>
nopl   0x0(%rax,%rax,1)
addsd  %xmm6,%xmm5
movapd %xmm10,%xmm1
subsd  %xmm9,%xmm1
movapd %xmm9,%xmm0
subsd  %xmm5,%xmm0
mulsd  %xmm0,%xmm1
ucomisd %xmm7,%xmm1
jbe    19e0 <linmin+0x8c0>
movapd %xmm2,0x20(%rsp)
movsd  %xmm6,0x90(%rsp)
movsd  %xmm10,0x50(%rsp)
movsd  %xmm8,0x8(%rsp)
cmpb   $0x0,0x4(%rsp)
je     1d40 <linmin+0xc20>
cmpl   $0x4,0x78(%rsp)
setb   %al
or     %r13b,%al
je     1be7 <linmin+0xac7>
xor    %ecx,%ecx
jmp    1cce <linmin+0xbae>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm5,%xmm1
subsd  %xmm10,%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm7,%xmm1
jae    1a06 <linmin+0x8e6>
mulsd  0x163c(%rip),%xmm12
addsd  %xmm10,%xmm12
movapd %xmm12,%xmm5
movsd  %xmm11,0x20(%rsp)
movapd %xmm10,%xmm1
jmp    1d8c <linmin+0xc6c>
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
cmpq   $0x0,0x68(%rsp)
je     1f30 <linmin+0xe10>
mov    0x48(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm1
movupd 0x30(%rbx,%rax,8),%xmm2
movupd 0x20(%r15,%rax,8),%xmm3
movupd 0x30(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rax,8)
movupd %xmm4,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1a40 <linmin+0x920>
testb  $0x1,0x80(%rsp)
01
je     1af6 <linmin+0x9d6>
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
mov    %rbp,%rcx
cmp    %r14,%rbp
je     1b70 <linmin+0xa50>
mov    %rcx,%rax
test   $0x1,%r14b
je     1b24 <linmin+0xa04>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x70(%rsp),%rcx
je     1b70 <linmin+0xa50>
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1b30 <linmin+0xa10>
nopl   0x0(%rax,%rax,1)
movsd  %xmm12,0xc0(%rsp)
movapd %xmm9,0x30(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
movsd  0x8(%rsp),%xmm8
ucomisd %xmm0,%xmm8
ja     2853 <linmin+0x1733>
movsd  0x20(%rsp),%xmm4
ucomisd %xmm4,%xmm0
movaps 0x30(%rsp),%xmm1
movsd  0x50(%rsp),%xmm3
movsd  0x90(%rsp),%xmm6
ja     2878 <linmin+0x1758>
movsd  0xc0(%rsp),%xmm5
mulsd  0x1464(%rip),%xmm5
addsd  %xmm3,%xmm5
movsd  %xmm4,0x20(%rsp)
movapd %xmm3,%xmm1
jmp    1d8c <linmin+0xc6c>
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
cmpq   $0x0,0x68(%rsp)
je     1f45 <linmin+0xe25>
mov    0x48(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm1
movupd 0x30(%rbx,%rax,8),%xmm2
movupd 0x20(%r15,%rax,8),%xmm3
movupd 0x30(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rax,8)
movupd %xmm4,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1c10 <linmin+0xaf0>
testb  $0x1,0x80(%rsp)
01
je     1cc6 <linmin+0xba6>
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
mov    %rbp,%rcx
cmp    %r14,%rbp
je     1d40 <linmin+0xc20>
mov    %rcx,%rax
test   $0x1,%r14b
je     1cf4 <linmin+0xbd4>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x70(%rsp),%rcx
je     1d40 <linmin+0xc20>
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1d00 <linmin+0xbe0>
nopl   0x0(%rax,%rax,1)
movapd %xmm9,0x30(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
movsd  0x8(%rsp),%xmm2
ucomisd %xmm2,%xmm0
ja     28ab <linmin+0x178b>
movapd %xmm0,%xmm8
movapd 0x20(%rsp),%xmm5
mulsd  0x12c2(%rip),%xmm5
movapd 0x30(%rsp),%xmm1
addsd  %xmm1,%xmm5
movsd  %xmm2,0x20(%rsp)
movsd  0x50(%rsp),%xmm6
movsd  %xmm8,0x8(%rsp)
movapd %xmm1,0x30(%rsp)
cmpb   $0x0,0x4(%rsp)
je     17e0 <linmin+0x6c0>
cmpl   $0x4,0x78(%rsp)
setb   %al
or     %r13b,%al
je     1dc0 <linmin+0xca0>
xor    %ecx,%ecx
jmp    1ea2 <linmin+0xd82>
nopl   0x0(%rax,%rax,1)
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
cmpq   $0x0,0x68(%rsp)
je     1f1b <linmin+0xdfb>
mov    0x48(%rsp),%rcx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm1
movupd 0x30(%rbx,%rax,8),%xmm2
movupd 0x20(%r15,%rax,8),%xmm3
movupd 0x30(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rax,8)
movupd %xmm4,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1de0 <linmin+0xcc0>
testb  $0x1,0x80(%rsp)
01
je     1e96 <linmin+0xd76>
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
mov    %rbp,%rcx
cmp    %r14,%rbp
je     17e0 <linmin+0x6c0>
mov    %rcx,%rax
test   $0x1,%r14b
je     1ec7 <linmin+0xda7>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x70(%rsp),%rcx
je     17e0 <linmin+0x6c0>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1ee0 <linmin+0xdc0>
jmp    17e0 <linmin+0x6c0>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    1e61 <linmin+0xd41>
jmp    1e96 <linmin+0xd76>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    1ac1 <linmin+0x9a1>
jmp    1af6 <linmin+0x9d6>
xor    %eax,%eax
testb  $0x1,0x80(%rsp)
01
jne    1c91 <linmin+0xb71>
jmp    1cc6 <linmin+0xba6>
movapd 0x30(%rsp),%xmm9
movapd 0x50(%rsp),%xmm10
movsd  0xa0(%rsp),%xmm1
movapd %xmm1,%xmm11
maxsd  %xmm10,%xmm11
minsd  %xmm1,%xmm10
lea    (%r12,%r14,8),%rax
lea    (%rbx,%r14,8),%rcx
mov    %r14d,%edx
and    $0xfffffffc,%edx
mov    %rdx,0xe8(%rsp)
lea    -0x4(%rdx),%rsi
mov    %rsi,0xb8(%rsp)
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %rcx,0xd0(%rsp)
cmp    %rcx,%r12
setb   %cl
cmp    %rbx,%rax
seta   %dl
lea    (%r15,%r14,8),%rdi
and    %cl,%dl
mov    %rdi,0xd8(%rsp)
cmp    %rdi,%r12
setb   %cl
cmp    %r15,%rax
seta   %r13b
and    %cl,%r13b
or     %dl,%r13b
mov    %rsi,%rax
mov    %rsi,0xb0(%rsp)
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rsi
mov    %rsi,0xe0(%rsp)
mov    %r14,%rax
neg    %rax
mov    %rax,0xf0(%rsp)
mov    $0x1,%ebp
movapd 0xff5(%rip),%xmm12
movapd 0xffc(%rip),%xmm13
xorpd  %xmm5,%xmm5
xorpd  %xmm8,%xmm8
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x48(%rsp)
movapd %xmm0,%xmm14
movapd %xmm9,%xmm6
movapd %xmm9,%xmm15
movapd %xmm9,%xmm7
jmp    20d2 <linmin+0xfb2>
movapd %xmm2,%xmm0
cmpnlesd %xmm7,%xmm0
movapd %xmm0,%xmm1
andpd  %xmm2,%xmm1
andnpd 0xc0(%rsp),%xmm0
orpd   %xmm1,%xmm0
movapd %xmm2,%xmm1
movapd %xmm8,%xmm2
movapd %xmm0,%xmm11
movapd %xmm3,%xmm0
movapd 0xf97(%rip),%xmm13
movsd  0x70(%rsp),%xmm5
movsd  0x68(%rsp),%xmm6
movapd 0x80(%rsp),%xmm8
add    $0x1,%ebp
movapd %xmm0,%xmm10
movapd %xmm7,%xmm9
movapd %xmm4,%xmm0
movsd  %xmm5,0x48(%rsp)
movapd %xmm2,%xmm14
movapd %xmm1,%xmm15
cmp    $0x65,%ebp
movapd 0xa0(%rsp),%xmm5
je     2685 <linmin+0x1565>
movsd  %xmm6,0x20(%rsp)
movapd %xmm11,%xmm1
addsd  %xmm10,%xmm1
mulsd  0xf7e(%rip),%xmm1
movapd 0xf1e(%rip),%xmm4
andpd  %xmm4,%xmm7
mulsd  0xf8(%rsp),%xmm7
addsd  0xf69(%rip),%xmm7
movapd %xmm7,%xmm2
addsd  %xmm7,%xmm2
movapd %xmm9,%xmm3
subsd  %xmm1,%xmm3
andpd  %xmm4,%xmm3
movapd %xmm11,%xmm4
subsd  %xmm10,%xmm4
mulsd  0xf4a(%rip),%xmm4
addsd  %xmm2,%xmm4
ucomisd %xmm3,%xmm4
jae    267c <linmin+0x155c>
movapd %xmm5,%xmm3
andpd  %xmm12,%xmm3
ucomisd %xmm7,%xmm3
movsd  %xmm14,0x70(%rsp)
jbe    21b0 <linmin+0x1090>
movapd %xmm5,%xmm12
movapd %xmm9,%xmm4
subsd  %xmm15,%xmm4
movapd %xmm0,%xmm6
subsd  0x48(%rsp),%xmm6
mulsd  %xmm4,%xmm6
movapd %xmm9,%xmm3
subsd  0x20(%rsp),%xmm3
movapd %xmm0,%xmm5
subsd  %xmm14,%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm6,%xmm4
mulsd  %xmm5,%xmm3
subsd  %xmm4,%xmm3
subsd  %xmm6,%xmm5
addsd  %xmm5,%xmm5
ucomisd 0xee5(%rip),%xmm5
ja     21f0 <linmin+0x10d0>
movapd %xmm3,%xmm14
jmp    21fa <linmin+0x10da>
nopl   0x0(%rax)
cmpnlesd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm11,%xmm2
andnpd %xmm10,%xmm1
orpd   %xmm2,%xmm1
subsd  %xmm9,%xmm1
movapd %xmm1,%xmm5
mulsd  0xea7(%rip),%xmm5
movapd %xmm1,%xmm8
jmp    22f7 <linmin+0x11d7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm3,%xmm14
xorpd  %xmm13,%xmm14
movapd %xmm5,%xmm6
xorpd  %xmm13,%xmm6
xorpd  %xmm4,%xmm4
cmpltsd %xmm5,%xmm4
andpd  %xmm4,%xmm5
andnpd %xmm6,%xmm4
orpd   %xmm5,%xmm4
movapd 0xdf0(%rip),%xmm6
andpd  %xmm6,%xmm3
movapd %xmm4,%xmm5
mulsd  0xe38(%rip),%xmm5
mulsd  %xmm5,%xmm12
andpd  %xmm6,%xmm12
ucomisd %xmm12,%xmm3
jae    22c0 <linmin+0x11a0>
movapd %xmm14,%xmm5
movapd %xmm10,%xmm3
subsd  %xmm9,%xmm3
mulsd  %xmm4,%xmm3
ucomisd %xmm14,%xmm3
jae    22c0 <linmin+0x11a0>
movapd %xmm11,%xmm3
subsd  %xmm9,%xmm3
mulsd  %xmm4,%xmm3
ucomisd %xmm3,%xmm5
jae    22c0 <linmin+0x11a0>
divsd  %xmm4,%xmm5
movapd %xmm9,%xmm3
addsd  %xmm5,%xmm3
movapd %xmm3,%xmm4
subsd  %xmm10,%xmm4
ucomisd %xmm4,%xmm2
ja     229a <linmin+0x117a>
movapd %xmm11,%xmm4
subsd  %xmm3,%xmm4
ucomisd %xmm4,%xmm2
jbe    22ee <linmin+0x11ce>
subsd  %xmm9,%xmm1
ucomisd 0xde1(%rip),%xmm1
jbe    266b <linmin+0x154b>
movapd %xmm7,%xmm5
jmp    22ee <linmin+0x11ce>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpnlesd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm11,%xmm2
andnpd %xmm10,%xmm1
orpd   %xmm2,%xmm1
subsd  %xmm9,%xmm1
movapd %xmm1,%xmm5
mulsd  0xd97(%rip),%xmm5
movapd %xmm1,%xmm8
movapd 0xd19(%rip),%xmm12
movapd %xmm5,%xmm1
andpd  %xmm12,%xmm1
ucomisd %xmm7,%xmm1
jae    2320 <linmin+0x1200>
ucomisd 0xd7a(%rip),%xmm5
jbe    2330 <linmin+0x1210>
addsd  %xmm9,%xmm7
jmp    233d <linmin+0x121d>
nopw   0x0(%rax,%rax,1)
movapd %xmm9,%xmm7
addsd  %xmm5,%xmm7
jmp    233d <linmin+0x121d>
nopl   0x0(%rax,%rax,1)
movapd %xmm9,%xmm1
subsd  %xmm7,%xmm1
movapd %xmm1,%xmm7
movsd  %xmm15,0x68(%rsp)
movapd %xmm11,0xc0(%rsp)
movapd %xmm10,0x50(%rsp)
movsd  %xmm0,0x8(%rsp)
movapd %xmm9,0x30(%rsp)
cmpb   $0x0,0x4(%rsp)
je     2500 <linmin+0x13e0>
cmpl   $0x4,0x78(%rsp)
setb   %al
or     %r13b,%al
je     2390 <linmin+0x1270>
xor    %ecx,%ecx
jmp    2486 <linmin+0x1366>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
cmpq   $0x0,0xb8(%rsp)
je     2656 <linmin+0x1536>
mov    0xe0(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm1
movupd 0x30(%rbx,%rax,8),%xmm2
movupd 0x20(%r15,%rax,8),%xmm3
movupd 0x30(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r12,%rax,8)
movupd %xmm4,0x30(%r12,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    23c0 <linmin+0x12a0>
testb  $0x1,0xb0(%rsp)
01
je     2476 <linmin+0x1356>
movupd (%rbx,%rax,8),%xmm1
movupd 0x10(%rbx,%rax,8),%xmm2
movupd (%r15,%rax,8),%xmm3
movupd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,(%r12,%rax,8)
movupd %xmm4,0x10(%r12,%rax,8)
mov    0xe8(%rsp),%rax
mov    %rax,%rcx
cmp    %r14,%rax
je     2500 <linmin+0x13e0>
mov    %rcx,%rax
test   $0x1,%r14b
je     24ab <linmin+0x138b>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xf0(%rsp),%rcx
je     2500 <linmin+0x13e0>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    24c0 <linmin+0x13a0>
cs nopw 0x0(%rax,%rax,1)
movapd %xmm5,0x80(%rsp)
movapd %xmm8,0xa0(%rsp)
movapd %xmm7,0x90(%rsp)
mov    0x18(%rsp),%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
movapd %xmm0,%xmm4
movsd  0x8(%rsp),%xmm8
ucomisd %xmm0,%xmm8
jae    2600 <linmin+0x14e0>
movapd 0x30(%rsp),%xmm3
movapd 0x90(%rsp),%xmm2
ucomisd %xmm2,%xmm3
movapd %xmm2,%xmm0
ja     255d <linmin+0x143d>
movapd 0x50(%rsp),%xmm0
movapd %xmm2,%xmm1
cmpltsd %xmm3,%xmm1
movapd 0xc0(%rsp),%xmm11
andpd  %xmm1,%xmm11
andnpd %xmm2,%xmm1
orpd   %xmm1,%xmm11
movsd  0x70(%rsp),%xmm5
ucomisd %xmm4,%xmm5
movapd 0xa7f(%rip),%xmm12
movapd 0xa86(%rip),%xmm13
movsd  0x68(%rsp),%xmm6
movsd  0x20(%rsp),%xmm7
jae    2640 <linmin+0x1520>
ucomisd %xmm3,%xmm6
jne    25b8 <linmin+0x1498>
jnp    2640 <linmin+0x1520>
movsd  0x48(%rsp),%xmm1
ucomisd %xmm4,%xmm1
setae  %al
ucomisd %xmm3,%xmm7
setnp  %cl
sete   %dl
and    %cl,%dl
or     %al,%dl
ucomisd %xmm6,%xmm7
setnp  %al
sete   %cl
and    %al,%cl
or     %dl,%cl
jne    25eb <linmin+0x14cb>
movapd %xmm7,%xmm2
movapd %xmm1,%xmm4
movapd %xmm6,%xmm1
movapd %xmm2,%xmm6
movapd %xmm5,%xmm2
movapd %xmm4,%xmm5
jmp    2648 <linmin+0x1528>
nopl   (%rax)
movapd 0x30(%rsp),%xmm2
movapd 0x90(%rsp),%xmm7
ucomisd %xmm2,%xmm7
movapd 0x50(%rsp),%xmm3
movapd 0x9ee(%rip),%xmm12
jb     2050 <linmin+0xf30>
movapd %xmm2,%xmm3
jmp    2050 <linmin+0xf30>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm2,%xmm1
movapd %xmm4,%xmm2
movapd %xmm8,%xmm4
movapd %xmm3,%xmm7
jmp    2095 <linmin+0xf75>
xor    %eax,%eax
testb  $0x1,0xb0(%rsp)
01
jne    2441 <linmin+0x1321>
jmp    2476 <linmin+0x1356>
movapd %xmm7,%xmm5
xorpd  0x9a9(%rip),%xmm5
jmp    22ee <linmin+0x11ce>
movapd %xmm0,%xmm4
movapd %xmm9,%xmm7
cmpb   $0x0,0x4(%rsp)
mov    0x78(%rsp),%rdx
movapd %xmm4,%xmm0
je     2819 <linmin+0x16f9>
cmp    $0x4,%edx
jb     26b6 <linmin+0x1596>
cmp    %rbx,0xd8(%rsp)
jbe    2729 <linmin+0x1609>
cmp    %r15,0xd0(%rsp)
jbe    2729 <linmin+0x1609>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
je     26dc <linmin+0x15bc>
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
or     $0x1,%rax
add    %r14,%rcx
je     2819 <linmin+0x16f9>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rbx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    26f0 <linmin+0x15d0>
jmp    2819 <linmin+0x16f9>
mov    %r14d,%eax
and    $0xfffffffc,%eax
movapd %xmm7,%xmm6
unpcklpd %xmm7,%xmm6
cmpq   $0x0,0xb8(%rsp)
je     28e3 <linmin+0x17c3>
movabs $0x7ffffffffffffffe,%rsi
ff ff 7f
and    0xb0(%rsp),%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%r15,%rcx,8),%xmm1
movupd 0x10(%r15,%rcx,8),%xmm2
mulpd  %xmm6,%xmm1
movupd (%rbx,%rcx,8),%xmm3
addpd  %xmm1,%xmm3
movupd 0x10(%rbx,%rcx,8),%xmm1
movupd 0x20(%rbx,%rcx,8),%xmm4
movupd 0x30(%rbx,%rcx,8),%xmm5
mulpd  %xmm6,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm3,(%rbx,%rcx,8)
movupd %xmm2,0x10(%rbx,%rcx,8)
movupd 0x20(%r15,%rcx,8),%xmm1
movupd 0x30(%r15,%rcx,8),%xmm2
mulpd  %xmm6,%xmm1
addpd  %xmm4,%xmm1
mulpd  %xmm6,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm1,0x20(%rbx,%rcx,8)
movupd %xmm2,0x30(%rbx,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    2760 <linmin+0x1640>
testb  $0x1,0xb0(%rsp)
01
je     2810 <linmin+0x16f0>
movupd (%r15,%rcx,8),%xmm1
movupd 0x10(%r15,%rcx,8),%xmm2
movupd (%rbx,%rcx,8),%xmm3
movupd 0x10(%rbx,%rcx,8),%xmm4
mulpd  %xmm6,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm6,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%rbx,%rcx,8)
movupd %xmm2,0x10(%rbx,%rcx,8)
cmp    %r14,%rax
jne    26b8 <linmin+0x1598>
lea    0x100(%rsp),%rax
cmp    %rax,%r12
je     2841 <linmin+0x1721>
add    $0xffffffff,%edx
mov    %r12,%rdi
xor    %esi,%esi
xor    %eax,%eax
movsd  %xmm0,0x30(%rsp)
call   1040 <free_dvector@plt>
movsd  0x30(%rsp),%xmm0
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsd  0x50(%rsp),%xmm10
movsd  0x90(%rsp),%xmm1
movsd  %xmm1,0xa0(%rsp)
movapd 0x30(%rsp),%xmm9
jmp    1f68 <linmin+0xe48>
movapd %xmm4,%xmm0
movapd %xmm1,%xmm10
movapd %xmm6,%xmm9
jmp    1f68 <linmin+0xe48>
xor    %ecx,%ecx
test   $0x1,%dl
jne    127c <linmin+0x15c>
jmp    12b5 <linmin+0x195>
xor    %ecx,%ecx
test   $0x1,%dl
jne    142c <linmin+0x30c>
jmp    1469 <linmin+0x349>
movapd %xmm2,%xmm0
movaps 0x30(%rsp),%xmm10
movsd  0x50(%rsp),%xmm9
movsd  0x90(%rsp),%xmm1
movsd  %xmm1,0xa0(%rsp)
jmp    1f68 <linmin+0xe48>
xor    %ecx,%ecx
test   $0x1,%dl
jne    16ec <linmin+0x5cc>
jmp    1721 <linmin+0x601>
xor    %ecx,%ecx
testb  $0x1,0xb0(%rsp)
01
jne    27dd <linmin+0x16bd>
jmp    2810 <linmin+0x16f0>

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

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