int conmin(int n, double *x, double *fval, double *g, int *ifun, int *iter,
           double eps, int mxfun, double *w, int mdim, double acc, int nmeth,
           double (*calcfg)(int, const double *, double *, void *),
           void *param) {
  int i, j, ii, ij, ng, nx, nrd, nry, rsw, ngpi, ngpj, nxpi, nrst;
  double u1, u2, u3, u4, dg, ap, dp, at, fp, dg1, dal, gsq, xsq, funmin, step,
      rtst, alpha;
  int nrdpi, ncons, nrypi, ncons1, ncons2, ncalls;
  *iter = *ifun = 0;
  nx = n;
  ng = nx + n;
  if (nmeth == 0) {
    nry = ng + n;
    nrd = nry + n;
    ncons = n * 5;
    ncons1 = ncons + 0;
    ncons2 = ncons + 1;
  } else
    ncons = n * 3;
L20:
  fval[0] = calcfg(n, x, g, param);
  (*ifun)++;
  nrst = n;
  rsw = 1;
  dg1 = xsq = 0.0;
  for (i = 0; i < n; i++) {
    w[i] = -g[i];
    xsq += x[i] * x[i];
    dg1 -= g[i] * g[i];
  }
  gsq = -dg1;
  dg = dg1;
  if (gsq <= eps * eps * fmax(1.0, xsq))
    return 0;
  for (;;) {
    funmin = fval[0];
    ncalls = *ifun;
    alpha = alpha * dg / dg1;
    if (nrst == 1 || nmeth == 1)
      alpha = 1.0;
    if (rsw == 1)
      alpha = 1.0 / sqrt(gsq);
    ap = 0.0;
    fp = funmin;
    dp = dg1;
    dg = dg1;
    *iter++;
    step = 0.0;
    for (i = 0; i < n; i++) {
      step += w[i] * w[i];
      nxpi = nx + i;
      ngpi = ng + i;
      w[nxpi] = x[i];
      w[ngpi] = g[i];
    }
    step = sqrt(step);
    for (;;) {
      if (alpha * step <= acc) {
        if (rsw == 0)
          goto L20;
        return 2;
      }
      for (i = 0; i < n; i++) {
        nxpi = nx + i;
        x[i] = w[nxpi] + alpha * w[i];
      }
      fval[0] = calcfg(n, x, g, param);
      (*ifun)++;
      if (*ifun > mxfun)
        return 1;
      dal = 0.0;
      for (i = 0; i < n; i++)
        dal += g[i] * w[i];
      if (fval[0] > funmin && dal < 0.0) {
        alpha /= 3.0;
        ap = 0.0;
        fp = funmin;
        dp = dg;
      } else {
        if (!(fval[0] > funmin + alpha * 0.0001 * dg || fabs(dal / dg) > 0.9)) {
          if (!(*ifun - ncalls <= 1 && fabs(dal / dg) > eps && nmeth == 0))
            break;
        }
        u1 = dp + dal - (fp - fval[0]) * 3.0 / (ap - alpha);
        u2 = u1 * u1 - dp * dal;
        if (u2 < 0.0)
          u2 = 0.0;
        u2 = sqrt(u2);
        at = alpha - (alpha - ap) * (dal + u2 - u1) / (dal - dp + u2 * 2.0);
        if (dal / dp > 0.0) {
          if (!(dal > 0.0 && 0.0 < at && at < fmin(ap, alpha) * .99)) {
            if (!(dal <= 0.0 && at > fmax(ap, alpha) * 1.01)) {
              if (dal <= 0.0)
                at = fmax(ap, alpha) * 2.0;
              if (dal > 0.0)
                at = fmin(ap, alpha) / 2.0;
            }
          }
        } else {
          if (at < fmin(alpha, ap) * 1.01 || at > fmax(alpha, ap) * 0.99)
            at = (alpha + ap) / 2.0;
        }
        ap = alpha;
        fp = fval[0];
        dp = dal;
        alpha = at;
      }
    }
    gsq = xsq = 0.0;
    for (i = 0; i < n; i++) {
      gsq += g[i] * g[i];
      xsq += x[i] * x[i];
    }
    if (gsq <= eps * eps * fmax(1.0, xsq))
      return 0;
    for (i = 0; i < n; i++)
      w[i] = alpha * w[i];
    if (nmeth == 0) {
      rtst = 0.0;
      for (i = 0; i < n; i++) {
        ngpi = ng + i;
        rtst += g[i] * w[ngpi];
      }
      if (fabs(rtst / gsq) > 0.2)
        nrst = n;
      if (nrst == n) {
        w[ncons1] = 0.0;
        w[ncons2] = 0.0;
        for (i = 0; i < n; i++) {
          nrdpi = nrd + i;
          nrypi = nry + i;
          ngpi = ng + i;
          w[nrypi] = g[i] - w[ngpi];
          w[nrdpi] = w[i];
          w[ncons1] += w[nrypi] * w[nrypi];
          w[ncons2] += w[i] * w[nrypi];
        }
      }
      u1 = u2 = 0.0;
      for (i = 0; i < n; i++) {
        nrdpi = nrd + i;
        nrypi = nry + i;
        u1 -= w[nrdpi] * g[i] / w[ncons1];
        u2 += w[nrdpi] * g[i] * 2.0 / w[ncons2] - w[nrypi] * g[i] / w[ncons1];
      }
      u3 = w[ncons2] / w[ncons1];
      for (i = 0; i < n; i++) {
        nxpi = nx + i;
        nrdpi = nrd + i;
        nrypi = nry + i;
        w[nxpi] = -u3 * g[i] - u1 * w[nrypi] - u2 * w[nrdpi];
      }
      if (nrst != n) {
        u1 = u2 = u3 = u4 = 0.0;
        for (i = 0; i < n; i++) {
          ngpi = ng + i;
          nrdpi = nrd + i;
          nrypi = nry + i;
          u1 -= (g[i] - w[ngpi]) * w[nrdpi] / w[ncons1];
          u2 -= (g[i] - w[ngpi]) * w[nrypi] / w[ncons1] +
                w[nrdpi] * 2.0 * (g[i] - w[ngpi]) / w[ncons2];
          u3 += w[i] * (g[i] - w[ngpi]);
        }
        step = 0.0;
        for (i = 0; i < n; i++) {
          ngpi = ng + i;
          nrdpi = nrd + i;
          nrypi = nry + i;
          step = w[ncons2] / w[ncons1] * (g[i] - w[ngpi]) + u1 * w[nrypi] +
                 u2 * w[nrdpi];
          u4 += step * (g[i] - w[ngpi]);
          w[ngpi] = step;
        }
        u1 = u2 = 0.0;
        for (i = 0; i < n; i++) {
          u1 -= w[i] * g[i] / u3;
          ngpi = ng + i;
          u2 += (u4 / u3 + 1.0) * w[i] * g[i] / u3 - w[ngpi] * g[i] / u3;
        }
        for (i = 0; i < n; i++) {
          ngpi = ng + i;
          nxpi = nx + i;
          w[nxpi] -= (u1 * w[ngpi] + u2 * w[i]);
        }
      }
      dg1 = 0.0;
      for (i = 0; i < n; i++) {
        nxpi = nx + i;
        w[i] = w[nxpi];
        dg1 += w[i] * g[i];
      }
      if (dg1 > 0.0)
        return 3;
      if (nrst == n)
        nrst = 0;
      ++nrst;
    } else {
      u1 = 0.0;
      for (i = 0; i < n; i++) {
        ngpi = ng + i;
        w[ngpi] = g[i] - w[ngpi];
        u1 += w[i] * w[ngpi];
      }
      if (rsw == 1) {
        u2 = 0.0;
        for (i = 0; i < n; i++) {
          ngpi = ng + i;
          u2 += w[ngpi] * w[ngpi];
        }
        ij = 0;
        u3 = u1 / u2;
        for (i = 0; i < n; i++) {
          for (j = i; j < n; j++) {
            ncons1 = ncons + ij;
            w[ncons1] = 0.0;
            if (i == j)
              w[ncons1] = u3;
            ++ij;
          }
          nxpi = nx + i;
          ngpi = ng + i;
          w[nxpi] = u3 * w[ngpi];
        }
        u2 *= u3;
      } else {
        u2 = 0.0;
        for (i = 0; i < n; i++) {
          u3 = 0.0;
          ij = i;
          if (i != 0) {
            for (j = 0; j < i; j++) {
              ngpj = ng + j;
              ncons1 = ncons + ij;
              u3 += w[ncons1] * w[ngpj];
              ij += (n - j - 1);
            }
          }
          for (j = i; j < n; j++) {
            ncons1 = ncons + ij;
            ngpj = ng + j;
            u3 += w[ncons1] * w[ngpj];
            ++ij;
          }
          ngpi = ng + i;
          u2 += (u3 * w[ngpi]);
          nxpi = nx + i;
          w[nxpi] = u3;
        }
      }
      u4 = u2 / u1 + 1.0;
      for (i = 0; i < n; i++) {
        nxpi = nx + i;
        ngpi = ng + i;
        w[ngpi] = u4 * w[i] - w[nxpi];
      }
      ij = 0;
      for (i = 0; i < n; i++) {
        nxpi = nx + i;
        u3 = w[i] / u1;
        u4 = w[nxpi] / u1;
        for (j = i; j < n; j++) {
          ncons1 = ncons + ij;
          ngpj = ng + j;
          w[ncons1] = w[ncons1] + u3 * w[ngpj] - u4 * w[j];
          ++ij;
        }
      }
      dg1 = 0.0;
      for (i = 0; i < n; i++) {
        u3 = 0.0;
        ij = i;
        if (i != 0) {
          for (j = 0; j < i; j++) {
            ncons1 = ncons + ij;
            u3 -= w[ncons1] * g[j];
            ij += (n - j - 1);
          }
        }
        for (j = i; j < n; j++) {
          ncons1 = ncons + ij;
          u3 -= w[ncons1] * g[j];
          ++ij;
        }
        dg1 += u3 * g[i];
        w[i] = u3;
      }
      if (dg1 > 0.0)
        return 3;
    }
    rsw = 0;
  }
}


x86 assembly (clang, -O0):
<conmin>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movsd  %xmm0,-0x38(%rbp)
movsd  %xmm1,-0x40(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x8(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x54(%rbp)
cmpl   $0x0,0x28(%rbp)
jne    11bd <conmin+0xad>
mov    -0x54(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x5c(%rbp)
imul   $0x5,-0x8(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x108(%rbp),%eax
add    $0x0,%eax
mov    %eax,-0x110(%rbp)
mov    -0x108(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x114(%rbp)
jmp    11c7 <conmin+0xb7>
imul   $0x3,-0x8(%rbp),%eax
mov    %eax,-0x108(%rbp)
jmp    11cc <conmin+0xbc>
mov    0x30(%rbp),%rax
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    0x38(%rbp),%rcx
call   *%rax
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x8(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x1,-0x64(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12e4 <conmin+0x1d4>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    121e <conmin+0x10e>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  0x1cc3(%rip),%xmm3
maxsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     135b <conmin+0x24b>
movl   $0x0,-0x4(%rbp)
jmp    2c10 <conmin+0x1b00>
jmp    1360 <conmin+0x250>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x118(%rbp)
movsd  -0x100(%rbp),%xmm0
ff
mulsd  -0xa0(%rbp),%xmm0
ff
divsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
cmpl   $0x1,-0x74(%rbp)
je     13b0 <conmin+0x2a0>
cmpl   $0x1,0x28(%rbp)
jne    13c0 <conmin+0x2b0>
movsd  0x1c48(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
cmpl   $0x1,-0x64(%rbp)
jne    13ee <conmin+0x2de>
movsd  -0xd8(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0x1c1e(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    14d9 <conmin+0x3c9>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1447 <conmin+0x337>
movsd  -0xf0(%rbp),%xmm0
ff
call   1030 <sqrt@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1528 <conmin+0x418>
cmpl   $0x0,-0x64(%rbp)
jne    151c <conmin+0x40c>
jmp    11cc <conmin+0xbc>
movl   $0x2,-0x4(%rbp)
jmp    2c10 <conmin+0x1b00>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1589 <conmin+0x479>
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x100(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    152f <conmin+0x41f>
mov    0x30(%rbp),%rax
mov    -0x8(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x20(%rbp),%rdx
mov    0x38(%rbp),%rcx
call   *%rax
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
cmp    0x10(%rbp),%eax
jle    15cc <conmin+0x4bc>
movl   $0x1,-0x4(%rbp)
jmp    2c10 <conmin+0x1b00>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    162a <conmin+0x51a>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    15de <conmin+0x4ce>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd -0xe8(%rbp),%xmm0
ff
jbe    169d <conmin+0x58d>
xorps  %xmm0,%xmm0
ucomisd -0xd0(%rbp),%xmm0
ff
jbe    169d <conmin+0x58d>
movsd  -0x100(%rbp),%xmm0
ff
movsd  0x19c7(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1b19 <conmin+0xa09>
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0xe8(%rbp),%xmm2
ff
movsd  0x1953(%rip),%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
ja     1753 <conmin+0x643>
movsd  -0xd0(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
movaps 0x1952(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1916(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1753 <conmin+0x643>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
sub    -0x118(%rbp),%eax
cmp    $0x1,%eax
jg     1749 <conmin+0x639>
movsd  -0xd0(%rbp),%xmm0
ff
divsd  -0xa0(%rbp),%xmm0
ff
movaps 0x1910(%rip),%xmm1
pand   %xmm1,%xmm0
ucomisd -0x38(%rbp),%xmm0
jbe    1749 <conmin+0x639>
cmpl   $0x0,0x28(%rbp)
je     174e <conmin+0x63e>
jmp    1b1e <conmin+0xa0e>
jmp    1753 <conmin+0x643>
movsd  -0xb0(%rbp),%xmm0
ff
addsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm1
movsd  0x18ad(%rip),%xmm2
mulsd  %xmm2,%xmm1
movsd  -0xa8(%rbp),%xmm2
ff
subsd  -0x100(%rbp),%xmm2
ff
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0xd0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    17f9 <conmin+0x6e9>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm1
ff
subsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xd0(%rbp),%xmm2
ff
addsd  -0x88(%rbp),%xmm2
ff
subsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm1
movsd  -0xd0(%rbp),%xmm3
ff
subsd  -0xb0(%rbp),%xmm3
ff
movsd  -0x88(%rbp),%xmm2
ff
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a18 <conmin+0x908>
movsd  -0xd0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1902 <conmin+0x7f2>
movsd  -0xb8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1902 <conmin+0x7f2>
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0x100(%rbp),%xmm3
ff
movaps %xmm3,%xmm5
movaps %xmm4,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm2
pand   %xmm5,%xmm2
minsd  %xmm4,%xmm3
pandn  %xmm3,%xmm0
por    %xmm2,%xmm0
movsd  0x1744(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
ja     1a13 <conmin+0x903>
xorps  %xmm0,%xmm0
ucomisd -0xd0(%rbp),%xmm0
ff
jb     195f <conmin+0x84f>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm4
ff
movsd  -0x100(%rbp),%xmm3
ff
movaps %xmm3,%xmm5
movaps %xmm4,%xmm1
cmpunordsd %xmm1,%xmm1
movaps %xmm1,%xmm2
pand   %xmm5,%xmm2
maxsd  %xmm4,%xmm3
pandn  %xmm3,%xmm1
por    %xmm2,%xmm1
movsd  0x16df(%rip),%xmm2
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
ja     1a0e <conmin+0x8fe>
xorps  %xmm0,%xmm0
ucomisd -0xd0(%rbp),%xmm0
ff
jb     19b2 <conmin+0x8a2>
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0x100(%rbp),%xmm2
ff
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  0x167a(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1a09 <conmin+0x8f9>
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0x100(%rbp),%xmm2
ff
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  0x1623(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1a0e <conmin+0x8fe>
jmp    1a13 <conmin+0x903>
jmp    1ad9 <conmin+0x9c9>
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm4
ff
movsd  -0xa8(%rbp),%xmm3
ff
movaps %xmm3,%xmm5
movaps %xmm4,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm2
pand   %xmm5,%xmm2
minsd  %xmm4,%xmm3
pandn  %xmm3,%xmm0
por    %xmm2,%xmm0
movsd  0x15da(%rip),%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
ja     1ab0 <conmin+0x9a0>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  -0x100(%rbp),%xmm4
ff
movsd  -0xa8(%rbp),%xmm3
ff
movaps %xmm3,%xmm5
movaps %xmm4,%xmm1
cmpunordsd %xmm1,%xmm1
movaps %xmm1,%xmm2
pand   %xmm5,%xmm2
maxsd  %xmm4,%xmm3
pandn  %xmm3,%xmm1
por    %xmm2,%xmm1
movsd  0x1596(%rip),%xmm2
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ad4 <conmin+0x9c4>
movsd  -0x100(%rbp),%xmm0
ff
addsd  -0xa8(%rbp),%xmm0
ff
movsd  0x1558(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
jmp    1ad9 <conmin+0x9c9>
movsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
jmp    14ee <conmin+0x3de>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1bb9 <conmin+0xaa9>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1b3b <conmin+0xa2b>
movsd  -0xd8(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
movsd  -0xe0(%rbp),%xmm2
ff
movsd  0x1425(%rip),%xmm3
maxsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1bf9 <conmin+0xae9>
movl   $0x0,-0x4(%rbp)
jmp    2c10 <conmin+0x1b00>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1c3c <conmin+0xb2c>
movsd  -0x100(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1c00 <conmin+0xaf0>
cmpl   $0x0,0x28(%rbp)
jne    24f8 <conmin+0x13e8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1cad <conmin+0xb9d>
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1c58 <conmin+0xb48>
movsd  -0xf8(%rbp),%xmm0
ff
divsd  -0xd8(%rbp),%xmm0
ff
movaps 0x137c(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x1348(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1ce0 <conmin+0xbd0>
mov    -0x8(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    1e17 <conmin+0xd07>
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1e12 <conmin+0xd02>
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x60(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1d19 <conmin+0xc09>
jmp    1e17 <conmin+0xd07>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1f18 <conmin+0xe08>
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x60(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x18(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x116b(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1e31 <conmin+0xd21>
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2026 <conmin+0xf16>
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x60(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x10c(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1f47 <conmin+0xe37>
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
je     2435 <conmin+0x1325>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    21bc <conmin+0x10ac>
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x60(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x104(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  0xefc(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2062 <conmin+0xf52>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    22d7 <conmin+0x11c7>
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x60(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x114(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x10c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x104(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
movsd  -0x98(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    21ce <conmin+0x10be>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    23b8 <conmin+0x12a8>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x90(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
movsd  0xcb2(%rip),%xmm1
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
divsd  -0x90(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    22f1 <conmin+0x11e1>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2430 <conmin+0x1320>
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    23bf <conmin+0x12af>
jmp    2435 <conmin+0x1325>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    24b6 <conmin+0x13a6>
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2447 <conmin+0x1337>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    24d7 <conmin+0x13c7>
movl   $0x3,-0x4(%rbp)
jmp    2c10 <conmin+0x1b00>
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jne    24ea <conmin+0x13da>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    2c04 <conmin+0x1af4>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    257d <conmin+0x146d>
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2507 <conmin+0x13f7>
cmpl   $0x1,-0x64(%rbp)
jne    26eb <conmin+0x15db>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    25ee <conmin+0x14de>
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2599 <conmin+0x1489>
movl   $0x0,-0x50(%rbp)
movsd  -0x80(%rbp),%xmm0
divsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    26ce <conmin+0x15be>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    268c <conmin+0x157c>
mov    -0x108(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jne    2675 <conmin+0x1565>
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    2623 <conmin+0x1513>
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2611 <conmin+0x1501>
movsd  -0x90(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
jmp    2883 <conmin+0x1773>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    287e <conmin+0x176e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     27a6 <conmin+0x1696>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    27a1 <conmin+0x1691>
mov    -0x54(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x108(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%eax
sub    -0x48(%rbp),%eax
sub    $0x1,%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    272b <conmin+0x161b>
jmp    27a6 <conmin+0x1696>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    281c <conmin+0x170c>
mov    -0x108(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x54(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    27ac <conmin+0x169c>
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    26fd <conmin+0x15ed>
jmp    2883 <conmin+0x1773>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0x80(%rbp),%xmm0
movsd  0x768(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2925 <conmin+0x1815>
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x54(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x68(%rbp)
movsd  -0x98(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    28ab <conmin+0x179b>
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2a41 <conmin+0x1931>
mov    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2a2e <conmin+0x191e>
mov    -0x108(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x54(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm1
ff
mov    0x18(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    2982 <conmin+0x1872>
jmp    2a33 <conmin+0x1923>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2933 <conmin+0x1823>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2bde <conmin+0x1ace>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     2b0a <conmin+0x19fa>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    2b05 <conmin+0x19f5>
mov    -0x108(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x8(%rbp),%eax
sub    -0x48(%rbp),%eax
sub    $0x1,%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    2a81 <conmin+0x1971>
jmp    2b0a <conmin+0x19fa>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    2b8e <conmin+0x1a7e>
mov    -0x108(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    0x18(%rbp),%rax
movslq -0x110(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    2b10 <conmin+0x1a00>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    2a53 <conmin+0x1943>
movsd  -0xc8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    2bff <conmin+0x1aef>
movl   $0x3,-0x4(%rbp)
jmp    2c10 <conmin+0x1b00>
jmp    2c04 <conmin+0x1af4>
movl   $0x0,-0x64(%rbp)
jmp    1360 <conmin+0x250>
mov    -0x4(%rbp),%eax
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<conmin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
movsd  %xmm1,0x1a0(%rsp)
movsd  %xmm0,0x180(%rsp)
mov    %rcx,%rbx
mov    %rdx,0xf8(%rsp)
mov    %rsi,%r12
mov    0x208(%rsp),%rbp
mov    %r8,0x1a8(%rsp)
movl   $0x0,(%r8)
movl   $0x0,(%r9)
lea    (%rdi,%rdi,1),%r8d
lea    (%rdi,%rdi,2),%edx
cmpl   $0x0,0x218(%rsp)
je     118e <conmin+0x7e>
xor    %r9d,%r9d
xor    %ecx,%ecx
mov    %rax,0x28(%rsp)
xor    %eax,%eax
mov    %rax,0x158(%rsp)
mov    %rdx,0xa8(%rsp)
jmp    11bf <conmin+0xaf>
lea    0x0(,%rdi,4),%eax
lea    (%rdi,%rdi,4),%esi
lea    (%rdi,%rdi,4),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rcx,0x158(%rsp)
movslq %eax,%r9
movslq %edx,%rcx
mov    %rsi,%rax
mov    %rsi,0x28(%rsp)
mov    %rsi,0xa8(%rsp)
movslq %edi,%rdx
movslq %r8d,%r11
mov    %edi,%r15d
lea    0x0(,%r15,8),%r8
add    %rbp,%r8
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
mov    %rax,0x130(%rsp)
add    %r15,%rcx
mov    %rcx,0x8(%rsp)
lea    0x0(,%r9,8),%rax
add    %rbp,%rax
mov    %rax,0x80(%rsp)
add    %r15,%r9
mov    %r9,0xd0(%rsp)
mov    %r11,%rax
or     $0x1,%rax
mov    %rax,0x170(%rsp)
mov    %r15d,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x190(%rsp)
mov    %rax,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x18(%rsp)
cmp    %r12,%r8
seta   %al
lea    (%r12,%r15,8),%r9
cmp    %rbp,%r9
seta   %cl
and    %al,%cl
mov    %rdx,0x50(%rsp)
lea    (%rdx,%r15,1),%rax
lea    0x0(,%rax,8),%r14
add    %rbp,%r14
cmp    %r12,%r14
seta   %r10b
lea    0x0(,%rdx,8),%r13
add    %rbp,%r13
cmp    %r9,%r13
setb   %al
and    %r10b,%al
or     %cl,%al
mov    %al,0x27(%rsp)
lea    (%r11,%r15,1),%rax
lea    0x0(,%rax,8),%rcx
add    %rbp,%rcx
mov    %rsi,%rax
mov    %rsi,0x188(%rsp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,0x178(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0xe8(%rsp)
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,0x198(%rsp)
mov    %edi,%eax
neg    %eax
mov    %eax,0x13c(%rsp)
lea    0x0(,%r11,8),%rsi
add    %rbp,%rsi
cmp    %r8,%rsi
setb   %r9b
cmp    %rbp,%rcx
seta   %al
and    %r9b,%al
mov    %rsi,0xb8(%rsp)
cmp    %r14,%rsi
setb   %sil
mov    %rcx,0x1b8(%rsp)
cmp    %rcx,%r13
setb   %r9b
and    %sil,%r9b
or     %r9b,%al
mov    %al,0x25(%rsp)
lea    (%rbx,%r15,8),%rcx
cmp    %rcx,%r13
setb   %al
cmp    %rbx,%r14
seta   %cl
and    %al,%cl
mov    0x8(%rsp),%rax
lea    0x0(,%rax,8),%rsi
add    %rbp,%rsi
cmp    %rsi,%r13
setb   %sil
cmp    %r14,0x130(%rsp)
setb   %al
and    %sil,%al
mov    0xd0(%rsp),%rdx
lea    0x0(,%rdx,8),%rsi
add    %rbp,%rsi
mov    0x80(%rsp),%r10
cmp    %rsi,%r13
setb   %sil
cmp    %r14,%r10
setb   %dl
and    %sil,%dl
or     %al,%dl
or     %cl,%dl
mov    %dl,0x24(%rsp)
mov    %r8,0x1c0(%rsp)
cmp    %r8,%r13
setb   %al
cmp    %rbp,%r14
seta   %cl
and    %al,%cl
or     %r9b,%cl
mov    %cl,0x23(%rsp)
movsd  0x180(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  %xmm0,0x120(%rsp)
lea    0x0(,%r15,8),%rcx
and    $0xffffffffffffffe0,%rcx
mov    0x228(%rsp),%r8
mov    0x220(%rsp),%r9
mov    0xa8(%rsp),%rax
movslq %eax,%rdx
lea    0x8(%rbp),%rax
mov    %rax,0x118(%rsp)
mov    %r15,0xb0(%rsp)
lea    -0x1(%r15),%rax
mov    %rax,0x68(%rsp)
mov    0x50(%rsp),%rsi
lea    0x8(%rbp,%rsi,8),%r15
lea    0x8(%rbp,%r11,8),%rax
mov    %rax,0xc0(%rsp)
lea    -0x1(%rdx),%eax
mov    %eax,0xcc(%rsp)
lea    0x18(%rbp,%r11,8),%rax
mov    %rax,0x110(%rsp)
mov    %rdx,%rax
mov    %rdx,0x60(%rsp)
lea    -0x1(%rdx),%rax
mov    %rax,0x168(%rsp)
lea    0x10(%rbp,%rsi,8),%rax
mov    %rax,0x100(%rsp)
mov    %r11,0x30(%rsp)
lea    0x10(%rbp,%r11,8),%rax
mov    %rax,0x150(%rsp)
lea    0x18(%rbp),%rax
mov    %rax,0x160(%rsp)
mov    0x170(%rsp),%rax
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
mov    %rax,0x1b0(%rsp)
mov    %rdi,0x58(%rsp)
mov    %rcx,0x108(%rsp)
mov    %r12,%rsi
mov    %rbx,%rdx
mov    %r8,%rcx
call   *%r9
mov    0x58(%rsp),%rdi
mov    0xf8(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x1a8(%rsp),%rcx
mov    (%rcx),%r9d
add    $0x1,%r9d
mov    %r9d,(%rcx)
test   %edi,%edi
jle    1540 <conmin+0x430>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    0xb0(%rsp),%r14
mov    0x38(%rsp),%r11
mov    0x18(%rsp),%r8
movapd 0x2b18(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
movapd %xmm1,%xmm0
movsd  (%rbx,%rcx,8),%xmm1
xorpd  %xmm3,%xmm1
movlpd %xmm1,0x0(%rbp,%rcx,8)
movsd  (%rbx,%rcx,8),%xmm6
movapd %xmm6,%xmm1
xorpd  %xmm3,%xmm1
movsd  (%r12,%rcx,8),%xmm2
unpcklpd %xmm2,%xmm1
unpcklpd %xmm2,%xmm6
mulpd  %xmm1,%xmm6
movapd %xmm6,%xmm1
addpd  %xmm0,%xmm1
add    $0x1,%rcx
cmp    %rcx,%r14
jne    14f0 <conmin+0x3e0>
addpd  %xmm0,%xmm6
jmp    1556 <conmin+0x446>
nopl   0x0(%rax)
xorpd  %xmm6,%xmm6
mov    0xb0(%rsp),%r14
mov    0x38(%rsp),%r11
mov    0x18(%rsp),%r8
xorpd  %xmm13,%xmm13
movapd %xmm6,%xmm0
xorpd  0x2a99(%rip),%xmm0
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
maxsd  0x2ab9(%rip),%xmm1
mulsd  0x120(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    3242 <conmin+0x2132>
mov    $0x1,%al
mov    %eax,0x14(%rsp)
movl   $0x0,0x44(%rsp)
mov    %edi,%eax
movapd %xmm6,%xmm9
cmpl   $0x1,0x218(%rsp)
01
sete   %cl
cmp    $0x1,%eax
sete   %dl
or     %cl,%dl
mov    %dl,0x26(%rsp)
mov    %rax,0x48(%rsp)
mov    %r9d,0x8c(%rsp)
movapd %xmm6,%xmm3
movsd  0x2a61(%rip),%xmm1
cmpb   $0x0,0x26(%rsp)
jne    15e8 <conmin+0x4d8>
mulsd  0xd0(%rsp),%xmm3
divsd  %xmm9,%xmm3
movapd %xmm3,%xmm1
movapd %xmm9,0x90(%rsp)
mov    0xf8(%rsp),%rax
movsd  (%rax),%xmm2
movsd  %xmm2,0x70(%rsp)
movapd %xmm1,%xmm7
testb  $0x1,0x14(%rsp)
mov    0xc0(%rsp),%rcx
je     165d <conmin+0x54d>
ucomisd %xmm13,%xmm0
jb     1630 <conmin+0x520>
sqrtsd %xmm0,%xmm0
jmp    1651 <conmin+0x541>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1030 <sqrt@plt>
mov    0xc0(%rsp),%rcx
xorpd  %xmm13,%xmm13
mov    0x18(%rsp),%r8
mov    0x38(%rsp),%r11
mov    0x58(%rsp),%rdi
movsd  0x29d7(%rip),%xmm7
divsd  %xmm0,%xmm7
test   %edi,%edi
jle    16d0 <conmin+0x5c0>
cmpq   $0x0,0x68(%rsp)
je     16e0 <conmin+0x5d0>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
nop
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r15,%rax,8)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x8(%r12,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
movsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    1670 <conmin+0x560>
test   $0x1,%r14b
jne    16ec <conmin+0x5dc>
jmp    1721 <conmin+0x611>
nopl   (%rax)
xorpd  %xmm0,%xmm0
jmp    1721 <conmin+0x611>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %eax,%eax
test   $0x1,%r14b
je     1721 <conmin+0x611>
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
mov    0x50(%rsp),%rcx
add    %rax,%rcx
mov    0x30(%rsp),%rdx
add    %rax,%rdx
movsd  (%r12,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rdx,8)
ucomisd %xmm13,%xmm0
jb     1740 <conmin+0x630>
xorps  %xmm6,%xmm6
sqrtsd %xmm0,%xmm6
jmp    1765 <conmin+0x655>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm7,0xd0(%rsp)
call   1030 <sqrt@plt>
movapd 0xd0(%rsp),%xmm7
mov    0x38(%rsp),%r11
mov    0x58(%rsp),%rdi
movapd %xmm0,%xmm6
mov    0x228(%rsp),%r8
mov    0x220(%rsp),%r9
movapd %xmm6,%xmm0
mulsd  %xmm7,%xmm0
movsd  0x1a0(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jae    3200 <conmin+0x20f0>
xorpd  %xmm8,%xmm8
movsd  0x70(%rsp),%xmm0
movsd  %xmm0,0x8(%rsp)
movapd 0x90(%rsp),%xmm0
movsd  %xmm0,0x78(%rsp)
movsd  %xmm6,0xf0(%rsp)
jmp    180d <conmin+0x6fd>
nopl   0x0(%rax,%rax,1)
addsd  %xmm8,%xmm6
mulsd  0x289b(%rip),%xmm6
movapd %xmm6,%xmm0
mov    0xf8(%rsp),%rax
movsd  (%rax),%xmm1
movsd  %xmm1,0x8(%rsp)
movsd  0xf0(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x1a0(%rsp),%xmm2
ucomisd %xmm1,%xmm2
movapd %xmm0,%xmm7
movsd  %xmm5,0x78(%rsp)
jae    3210 <conmin+0x2100>
test   %edi,%edi
jle    19a7 <conmin+0x897>
cmp    $0x4,%edi
setb   %al
or     0x27(%rsp),%al
je     1830 <conmin+0x720>
xor    %ecx,%ecx
jmp    1928 <conmin+0x818>
nopl   0x0(%rax,%rax,1)
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
cmpq   $0x0,0x190(%rsp)
je     1e02 <conmin+0xcf2>
mov    0x178(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x0(%r13,%rax,8),%xmm1
movupd 0x10(%r13,%rax,8),%xmm2
movupd 0x0(%rbp,%rax,8),%xmm3
movupd 0x10(%rbp,%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(%r13,%rax,8),%xmm1
movupd 0x30(%r13,%rax,8),%xmm2
movupd 0x20(%rbp,%rax,8),%xmm3
movupd 0x30(%rbp,%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    1860 <conmin+0x750>
testb  $0x1,0x188(%rsp)
01
je     1920 <conmin+0x810>
mov    0x50(%rsp),%rcx
add    %rax,%rcx
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd 0x10(%rbp,%rcx,8),%xmm2
movupd 0x0(%rbp,%rax,8),%xmm3
movupd 0x10(%rbp,%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    %r11,%rcx
cmp    %r14,%r11
je     19a7 <conmin+0x897>
mov    %rcx,%rax
test   $0x1,%r14b
je     1956 <conmin+0x846>
mov    0x50(%rsp),%rax
add    %rcx,%rax
movsd  0x0(%rbp,%rcx,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  0x0(%rbp,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0xe8(%rsp),%rcx
je     19a7 <conmin+0x897>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  0x0(%rbp,%rax,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  -0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
movsd  0x8(%rbp,%rax,8),%xmm0
mulsd  %xmm7,%xmm0
addsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1970 <conmin+0x860>
movapd %xmm8,0x140(%rsp)
movapd %xmm7,0xd0(%rsp)
mov    %r12,%rsi
mov    %rbx,%rdx
mov    %r8,%rcx
mov    %rdi,%r14
call   *%r9
mov    0xf8(%rsp),%rax
movsd  %xmm0,(%rax)
mov    0x1a8(%rsp),%rdx
mov    (%rdx),%ecx
lea    0x1(%rcx),%r9d
mov    %r9d,(%rdx)
cmp    0x200(%rsp),%ecx
jge    322b <conmin+0x211b>
test   %r14d,%r14d
mov    %r14,%rdi
jle    1a50 <conmin+0x940>
cmpq   $0x3,0x68(%rsp)
mov    0xb0(%rsp),%r14
mov    0x130(%rsp),%r8
mov    0x198(%rsp),%rax
movapd 0x25df(%rip),%xmm7
xorpd  %xmm13,%xmm13
movapd 0xd0(%rsp),%xmm8
movapd 0x90(%rsp),%xmm6
xorpd  %xmm5,%xmm5
jae    1aa0 <conmin+0x990>
xor    %ecx,%ecx
mov    0x38(%rsp),%r11
jmp    1af8 <conmin+0x9e8>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm5,%xmm5
mov    0xb0(%rsp),%r14
mov    0x130(%rsp),%r8
mov    0x38(%rsp),%r11
mov    0x198(%rsp),%rax
movapd 0x2587(%rip),%xmm7
xorpd  %xmm13,%xmm13
movapd 0xd0(%rsp),%xmm8
movapd 0x90(%rsp),%xmm6
jmp    1b70 <conmin+0xa60>
cs nopw 0x0(%rax,%rax,1)
xor    %ecx,%ecx
mov    0x38(%rsp),%r11
nopw   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,8),%xmm1
movsd  0x8(%rbx,%rcx,8),%xmm2
mulsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  0x8(%rbp,%rcx,8),%xmm2
addsd  %xmm5,%xmm1
movsd  0x10(%rbx,%rcx,8),%xmm3
mulsd  0x10(%rbp,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rbx,%rcx,8),%xmm5
mulsd  0x18(%rbp,%rcx,8),%xmm5
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm5
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1ab0 <conmin+0x9a0>
test   %rax,%rax
je     1b27 <conmin+0xa17>
lea    0x0(,%rcx,8),%rdx
add    %rbp,%rdx
lea    (%rbx,%rcx,8),%rcx
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rcx,%rsi,8),%xmm1
mulsd  (%rdx,%rsi,8),%xmm1
addsd  %xmm1,%xmm5
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1b10 <conmin+0xa00>
ucomisd 0x70(%rsp),%xmm0
jbe    1b70 <conmin+0xa60>
ucomisd %xmm5,%xmm13
jbe    1b70 <conmin+0xa60>
movapd %xmm8,%xmm0
divsd  0x252d(%rip),%xmm0
xorpd  %xmm8,%xmm8
movapd %xmm6,%xmm5
movsd  0x70(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
mov    0x228(%rsp),%r8
mov    0x220(%rsp),%r9
jmp    17e3 <conmin+0x6d3>
nopl   (%rax)
movapd %xmm8,%xmm1
mulsd  0x24bb(%rip),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x70(%rsp),%xmm1
ucomisd %xmm1,%xmm0
ja     1bd7 <conmin+0xac7>
movapd %xmm5,%xmm1
divsd  %xmm6,%xmm1
andpd  0x2473(%rip),%xmm1
ucomisd 0x249b(%rip),%xmm1
ja     1bd7 <conmin+0xac7>
mov    %r9d,%ecx
sub    0x8c(%rsp),%ecx
cmp    $0x1,%ecx
jg     1e17 <conmin+0xd07>
cmpl   $0x0,0x218(%rsp)
jne    1e17 <conmin+0xd07>
ucomisd 0x180(%rsp),%xmm1
jbe    1e17 <conmin+0xd07>
movsd  0x78(%rsp),%xmm2
movapd %xmm2,%xmm1
addsd  %xmm5,%xmm1
movsd  0x8(%rsp),%xmm3
subsd  %xmm0,%xmm3
mulsd  0x2459(%rip),%xmm3
movapd 0x140(%rsp),%xmm6
movapd %xmm6,%xmm0
subsd  %xmm8,%xmm0
divsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movapd %xmm5,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
subsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
maxsd  %xmm1,%xmm0
ucomisd %xmm13,%xmm0
jb     1c40 <conmin+0xb30>
sqrtsd %xmm0,%xmm0
jmp    1c85 <conmin+0xb75>
nopw   0x0(%rax,%rax,1)
movsd  %xmm3,0x8(%rsp)
movsd  %xmm5,0x128(%rsp)
call   1030 <sqrt@plt>
movsd  0x128(%rsp),%xmm5
movsd  0x8(%rsp),%xmm3
movapd 0x140(%rsp),%xmm6
movapd 0xd0(%rsp),%xmm8
xorpd  %xmm13,%xmm13
mov    0x38(%rsp),%r11
mov    0x58(%rsp),%rdi
mov    0x228(%rsp),%r8
mov    0x220(%rsp),%r9
movapd %xmm8,%xmm1
subsd  %xmm6,%xmm1
movapd %xmm5,%xmm2
addsd  %xmm0,%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm5,%xmm1
movsd  0x78(%rsp),%xmm3
subsd  %xmm3,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
divsd  %xmm0,%xmm2
movapd %xmm8,%xmm0
subsd  %xmm2,%xmm0
movapd %xmm5,%xmm1
divsd  %xmm3,%xmm1
ucomisd %xmm13,%xmm1
jbe    1da0 <conmin+0xc90>
ucomisd %xmm13,%xmm5
jbe    1d27 <conmin+0xc17>
ucomisd %xmm13,%xmm0
jbe    1d27 <conmin+0xc17>
movapd %xmm6,%xmm1
cmpunordsd %xmm6,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm8,%xmm2
movapd %xmm8,%xmm3
minsd  %xmm6,%xmm3
andnpd %xmm3,%xmm1
orpd   %xmm2,%xmm1
mulsd  0x2343(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     17d1 <conmin+0x6c1>
ucomisd %xmm5,%xmm13
jb     1d6f <conmin+0xc5f>
movapd %xmm6,%xmm1
cmpunordsd %xmm6,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm8,%xmm2
movapd %xmm8,%xmm3
maxsd  %xmm6,%xmm3
andnpd %xmm3,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm1,%xmm2
mulsd  0x22fb(%rip),%xmm2
ucomisd %xmm2,%xmm0
ja     17d1 <conmin+0x6c1>
addsd  %xmm1,%xmm1
movapd %xmm1,%xmm0
ucomisd %xmm13,%xmm5
jbe    17d1 <conmin+0x6c1>
movapd %xmm8,%xmm0
minsd  %xmm6,%xmm0
cmpunordsd %xmm6,%xmm6
movapd %xmm6,%xmm1
andpd  %xmm8,%xmm1
andnpd %xmm0,%xmm6
orpd   %xmm1,%xmm6
jmp    17c5 <conmin+0x6b5>
xchg   %ax,%ax
movapd %xmm8,%xmm1
cmpunordsd %xmm8,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm6,%xmm2
movapd %xmm6,%xmm3
minsd  %xmm8,%xmm3
movapd %xmm1,%xmm4
andnpd %xmm3,%xmm4
orpd   %xmm2,%xmm4
mulsd  0x2288(%rip),%xmm4
ucomisd %xmm0,%xmm4
ja     17c0 <conmin+0x6b0>
movapd %xmm6,%xmm3
maxsd  %xmm8,%xmm3
andnpd %xmm3,%xmm1
orpd   %xmm2,%xmm1
mulsd  0x226d(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     17c0 <conmin+0x6b0>
jmp    17d1 <conmin+0x6c1>
xor    %eax,%eax
testb  $0x1,0x188(%rsp)
01
jne    18e3 <conmin+0x7d3>
jmp    1920 <conmin+0x810>
test   %edi,%edi
jle    1e2e <conmin+0xd1e>
cmpq   $0x3,0x68(%rsp)
jae    1e4a <conmin+0xd3a>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
jmp    1eaf <conmin+0xd9f>
xorpd  %xmm0,%xmm0
movsd  0x120(%rsp),%xmm1
ucomisd %xmm0,%xmm1
jb     1fea <conmin+0xeda>
jmp    3242 <conmin+0x2132>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
movsd  (%r12,%rcx,8),%xmm2
movsd  0x8(%r12,%rcx,8),%xmm3
movsd  0x10(%r12,%rcx,8),%xmm4
movsd  0x18(%r12,%rcx,8),%xmm0
movhpd (%rbx,%rcx,8),%xmm2
mulpd  %xmm2,%xmm2
addpd  %xmm1,%xmm2
movhpd 0x8(%rbx,%rcx,8),%xmm3
mulpd  %xmm3,%xmm3
addpd  %xmm2,%xmm3
movhpd 0x10(%rbx,%rcx,8),%xmm4
mulpd  %xmm4,%xmm4
addpd  %xmm3,%xmm4
movhpd 0x18(%rbx,%rcx,8),%xmm0
mulpd  %xmm0,%xmm0
addpd  %xmm4,%xmm0
add    $0x4,%rcx
movapd %xmm0,%xmm1
cmp    %rcx,%r11
jne    1e50 <conmin+0xd40>
test   $0x3,%r14b
je     1edb <conmin+0xdcb>
lea    (%r12,%rcx,8),%rdx
lea    (%rbx,%rcx,8),%rcx
xor    %esi,%esi
nop
movsd  (%rdx,%rsi,8),%xmm1
movhpd (%rcx,%rsi,8),%xmm1
mulpd  %xmm1,%xmm1
addpd  %xmm1,%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1ec0 <conmin+0xdb0>
movapd %xmm0,%xmm1
maxsd  0x2149(%rip),%xmm1
mulsd  0x120(%rsp),%xmm1
unpckhpd %xmm0,%xmm0
ucomisd %xmm0,%xmm1
jae    3242 <conmin+0x2132>
test   %edi,%edi
jle    1fea <conmin+0xeda>
cmp    $0x4,%edi
jae    1f12 <conmin+0xe02>
xor    %ecx,%ecx
jmp    1fd0 <conmin+0xec0>
movapd %xmm8,%xmm1
unpcklpd %xmm8,%xmm1
cmpq   $0x0,0x190(%rsp)
je     1f8c <conmin+0xe7c>
mov    0x178(%rsp),%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rcx,8),%xmm2
movupd 0x10(%rbp,%rcx,8),%xmm3
movupd 0x20(%rbp,%rcx,8),%xmm4
movupd 0x30(%rbp,%rcx,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm3,0x10(%rbp,%rcx,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x20(%rbp,%rcx,8)
movupd %xmm5,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rdx
jne    1f40 <conmin+0xe30>
jmp    1f8e <conmin+0xe7e>
xor    %ecx,%ecx
testb  $0x1,0x188(%rsp)
01
je     1fb8 <conmin+0xea8>
movupd 0x0(%rbp,%rcx,8),%xmm2
movupd 0x10(%rbp,%rcx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm3,0x10(%rbp,%rcx,8)
mov    %r11,%rcx
cmp    %r14,%r11
movapd 0x90(%rsp),%xmm6
je     1fea <conmin+0xeda>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  %xmm8,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1fd0 <conmin+0xec0>
cmpl   $0x0,0x218(%rsp)
je     2aa9 <conmin+0x1999>
test   %edi,%edi
jle    20b7 <conmin+0xfa7>
cmpq   $0x0,0x68(%rsp)
mov    0x18(%rsp),%r8
xorpd  %xmm1,%xmm1
je     20eb <conmin+0xfdb>
xor    %ecx,%ecx
mov    0xc0(%rsp),%rdx
nop
movsd  (%rbx,%rcx,8),%xmm2
subsd  -0x8(%rdx,%rcx,8),%xmm2
movsd  %xmm2,-0x8(%rdx,%rcx,8)
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  0x8(%rbx,%rcx,8),%xmm1
subsd  (%rdx,%rcx,8),%xmm1
movsd  %xmm1,(%rdx,%rcx,8)
mulsd  0x8(%rbp,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
add    $0x2,%rcx
cmp    %rcx,%r8
jne    2020 <conmin+0xf10>
test   $0x1,%r14b
je     2087 <conmin+0xf77>
mov    0x30(%rsp),%rdx
add    %rcx,%rdx
movsd  (%rbx,%rcx,8),%xmm2
subsd  0x0(%rbp,%rdx,8),%xmm2
movsd  %xmm2,0x0(%rbp,%rdx,8)
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
testb  $0x1,0x14(%rsp)
jne    20f9 <conmin+0xfe9>
xorpd  %xmm9,%xmm9
mov    $0x1,%al
mov    %eax,0x44(%rsp)
movl   $0x0,0x14(%rsp)
mov    %r9d,0x8c(%rsp)
movapd %xmm6,%xmm3
test   %edi,%edi
jle    15c7 <conmin+0x4b7>
jmp    2118 <conmin+0x1008>
mov    $0x1,%al
mov    %eax,0x44(%rsp)
xorpd  %xmm9,%xmm9
mov    %r9d,0x8c(%rsp)
movapd %xmm6,%xmm3
testb  $0x1,0x14(%rsp)
movl   $0x0,0x14(%rsp)
mov    0x18(%rsp),%r8
je     15c7 <conmin+0x4b7>
jmp    22b2 <conmin+0x11a2>
xor    %ecx,%ecx
test   $0x1,%r14b
jne    2064 <conmin+0xf54>
jmp    2087 <conmin+0xf77>
test   %edi,%edi
jle    22ad <conmin+0x119d>
cmpq   $0x3,0x68(%rsp)
jae    22c9 <conmin+0x11b9>
xorpd  %xmm4,%xmm4
xor    %ecx,%ecx
jmp    2317 <conmin+0x1207>
xorpd  %xmm3,%xmm3
mov    %r14,%r10
mov    0xb8(%rsp),%r11
xor    %edx,%edx
test   %rdx,%rdx
mov    %rdx,0x78(%rsp)
je     2146 <conmin+0x1036>
cmp    $0x1,%rdx
jne    2151 <conmin+0x1041>
xorpd  %xmm2,%xmm2
xor    %esi,%esi
mov    %edx,%edi
jmp    21cb <conmin+0x10bb>
xor    %edi,%edi
xorpd  %xmm2,%xmm2
jmp    220e <conmin+0x10fe>
mov    %rdx,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x8(%rsp)
xorpd  %xmm2,%xmm2
mov    $0xfffffffe,%ecx
xor    %esi,%esi
mov    %edx,%edi
mov    0x58(%rsp),%r8
mov    0xa8(%rsp),%r14
mov    0xc0(%rsp),%rax
nop
lea    (%rdi,%r14,1),%edx
movslq %edx,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm4
mulsd  -0x8(%rax,%rsi,8),%xmm4
addsd  %xmm2,%xmm4
add    %r8d,%edi
add    %ecx,%edi
lea    (%r14,%rdi,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  (%rax,%rsi,8),%xmm2
addsd  %xmm4,%xmm2
add    %r8d,%edi
add    $0x1,%edi
add    %ecx,%edi
add    $0x2,%rsi
add    $0xfffffffe,%ecx
cmp    %rsi,0x8(%rsp)
jne    2180 <conmin+0x1070>
testb  $0x1,0x78(%rsp)
mov    0xb0(%rsp),%r14
mov    0x18(%rsp),%r8
je     220e <conmin+0x10fe>
mov    0x30(%rsp),%rcx
add    %rsi,%rcx
mov    0xa8(%rsp),%rdx
add    %edi,%edx
movslq %edx,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm4
mulsd  0x0(%rbp,%rcx,8),%xmm4
addsd  %xmm4,%xmm2
add    0x58(%rsp),%edi
not    %esi
add    %edi,%esi
mov    %esi,%edi
movslq %edi,%rcx
add    0x60(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rdx,8),%xmm4
mulsd  (%r11,%rdx,8),%xmm4
addsd  %xmm4,%xmm2
add    $0x1,%rdx
cmp    %rdx,%r10
jne    2230 <conmin+0x1120>
mov    %rdx,0x28(%rsp)
mov    0x30(%rsp),%rcx
mov    0x78(%rsp),%rdx
add    %rdx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm4,%xmm3
mov    0x50(%rsp),%rcx
add    %rdx,%rcx
movsd  %xmm2,0x0(%rbp,%rcx,8)
add    $0x1,%rdx
add    $0x8,%r11
add    $0xffffffffffffffff,%r10
cmp    %r14,%rdx
jne    2129 <conmin+0x1019>
add    0xcc(%rsp),%edi
mov    0x28(%rsp),%rcx
add    %edi,%ecx
mov    %rcx,0x28(%rsp)
mov    0x58(%rsp),%rdi
mov    0x38(%rsp),%r11
jmp    2464 <conmin+0x1354>
movapd %xmm1,%xmm9
xorpd  %xmm4,%xmm4
movapd %xmm9,%xmm3
divsd  %xmm4,%xmm3
movapd %xmm9,%xmm1
jmp    2460 <conmin+0x1350>
xorpd  %xmm4,%xmm4
xor    %ecx,%ecx
mov    0x110(%rsp),%rdx
movsd  -0x18(%rdx,%rcx,8),%xmm2
movsd  -0x10(%rdx,%rcx,8),%xmm3
mulsd  %xmm2,%xmm2
addsd  %xmm4,%xmm2
mulsd  %xmm3,%xmm3
addsd  %xmm2,%xmm3
movsd  -0x8(%rdx,%rcx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
movsd  (%rdx,%rcx,8),%xmm4
mulsd  %xmm4,%xmm4
addsd  %xmm2,%xmm4
add    $0x4,%rcx
cmp    %rcx,%r11
jne    22d7 <conmin+0x11c7>
test   $0x3,%r14b
je     2345 <conmin+0x1235>
add    0x30(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %edx,%edx
movsd  (%rcx,%rdx,8),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm4
add    $0x1,%rdx
cmp    %rdx,%rax
jne    232f <conmin+0x121f>
movapd %xmm1,%xmm3
divsd  %xmm4,%xmm3
test   %edi,%edi
jle    245b <conmin+0x134b>
xor    %eax,%eax
xor    %r8d,%r8d
jmp    23a9 <conmin+0x1299>
mov    0x168(%rsp),%rcx
add    %r8,%rcx
add    %rdx,%r8
add    %rdx,%rcx
mov    %rcx,0x28(%rsp)
mov    0x58(%rsp),%rdi
mov    0x38(%rsp),%r11
mov    0x50(%rsp),%rcx
add    %rax,%rcx
mov    0x30(%rsp),%rdx
add    %rax,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  %xmm3,%xmm2
movsd  %xmm2,0x0(%rbp,%rcx,8)
add    $0x1,%rax
cmp    %r14,%rax
je     245b <conmin+0x134b>
mov    %edi,%ecx
sub    %eax,%ecx
movslq %r8d,%r8
test   $0x1,%cl
jne    23b9 <conmin+0x12a9>
mov    %eax,%ecx
jmp    23e9 <conmin+0x12d9>
mov    0x60(%rsp),%rcx
add    %r8,%rcx
mov    %rcx,0x28(%rsp)
mov    %rax,%rcx
shr    $0x20,%rcx
movapd %xmm3,%xmm2
je     23d7 <conmin+0x12c7>
xorpd  %xmm2,%xmm2
mov    0x28(%rsp),%rcx
movsd  %xmm2,0x0(%rbp,%rcx,8)
add    $0x1,%r8
lea    0x1(%rax),%ecx
mov    %eax,%edx
not    %edx
cmp    0x13c(%rsp),%edx
je     237c <conmin+0x126c>
mov    0x60(%rsp),%rdx
add    %r8,%rdx
mov    0x118(%rsp),%rsi
lea    (%rsi,%rdx,8),%rsi
mov    %edi,%r10d
sub    %ecx,%r10d
mov    %ecx,%r11d
mov    %rax,%rdi
sub    %r11,%rdi
xor    %edx,%edx
jmp    2432 <conmin+0x1322>
nopl   (%rax)
movsd  %xmm2,(%rsi,%rdx,8)
add    $0x2,%rdx
cmp    %edx,%r10d
je     235c <conmin+0x124c>
movapd %xmm3,%xmm2
cmp    %rdx,%rdi
je     243f <conmin+0x132f>
xorpd  %xmm2,%xmm2
movsd  %xmm2,-0x8(%rsi,%rdx,8)
lea    (%r11,%rdx,1),%ecx
add    $0x1,%ecx
movapd %xmm3,%xmm2
cmp    %rcx,%rax
je     2420 <conmin+0x1310>
xorpd  %xmm2,%xmm2
jmp    2420 <conmin+0x1310>
mov    0x18(%rsp),%r8
mulsd  %xmm4,%xmm3
movl   $0x0,0x14(%rsp)
divsd  %xmm1,%xmm3
addsd  0x1bb8(%rip),%xmm3
xorpd  %xmm9,%xmm9
mov    $0x1,%cl
mov    %ecx,0x44(%rsp)
test   %edi,%edi
jle    15bb <conmin+0x4ab>
cmp    $0x4,%edi
setb   %cl
or     0x25(%rsp),%cl
je     249b <conmin+0x138b>
xor    %edx,%edx
jmp    2511 <conmin+0x1401>
movapd %xmm3,%xmm8
unpcklpd %xmm3,%xmm8
xor    %ecx,%ecx
mov    0x108(%rsp),%rax
mov    0x100(%rsp),%rdx
mov    0x150(%rsp),%rsi
movupd 0x0(%rbp,%rcx,1),%xmm5
movupd 0x10(%rbp,%rcx,1),%xmm6
movupd -0x10(%rdx,%rcx,1),%xmm7
movupd (%rdx,%rcx,1),%xmm4
mulpd  %xmm8,%xmm5
subpd  %xmm7,%xmm5
mulpd  %xmm8,%xmm6
subpd  %xmm4,%xmm6
movupd %xmm5,-0x10(%rsi,%rcx,1)
movupd %xmm6,(%rsi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rax
jne    24bf <conmin+0x13af>
mov    %r11,%rdx
cmp    %r14,%r11
movapd 0x90(%rsp),%xmm6
je     2591 <conmin+0x1481>
mov    %rdx,%rcx
test   $0x1,%r14b
je     2547 <conmin+0x1437>
mov    0x50(%rsp),%rcx
add    %rdx,%rcx
mov    0x30(%rsp),%rsi
add    %rdx,%rsi
movsd  0x0(%rbp,%rdx,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  0x0(%rbp,%rcx,8),%xmm4
movsd  %xmm4,0x0(%rbp,%rsi,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xe8(%rsp),%rdx
mov    0xc0(%rsp),%rax
je     2591 <conmin+0x1481>
movsd  0x0(%rbp,%rcx,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  -0x8(%r15,%rcx,8),%xmm4
movsd  %xmm4,-0x8(%rax,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  (%r15,%rcx,8),%xmm4
movsd  %xmm4,(%rax,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    255c <conmin+0x144c>
movl   $0x0,0x14(%rsp)
test   %edi,%edi
jle    15bb <conmin+0x4ab>
mov    0x110(%rsp),%r10
mov    0x160(%rsp),%r11
mov    0x68(%rsp),%rax
mov    %rax,0xf0(%rsp)
xor    %edx,%edx
xor    %edi,%edi
jmp    25ef <conmin+0x14df>
mov    0x8(%rsp),%rdi
mov    %rcx,%rsi
mov    0x78(%rsp),%rdx
add    $0x1,%rdx
addq   $0xffffffffffffffff,0xf0(%rsp)
add    $0x8,%r11
add    $0x8,%r10
cmp    %r14,%rdx
je     2917 <conmin+0x1807>
lea    0x1(%rdx),%rsi
movsd  0x0(%rbp,%rdx,8),%xmm5
movapd %xmm5,%xmm8
divsd  %xmm1,%xmm8
mov    0x50(%rsp),%rcx
add    %rdx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm10
xorpd  0x19e5(%rip),%xmm10
divsd  %xmm1,%xmm10
movslq %edi,%rdi
mov    0x60(%rsp),%rax
lea    (%rdi,%rax,1),%rax
mov    0x30(%rsp),%rcx
lea    (%rdx,%rcx,1),%rcx
movsd  0x0(%rbp,%rcx,8),%xmm6
mulsd  %xmm8,%xmm6
addsd  0x0(%rbp,%rax,8),%xmm6
mulsd  %xmm10,%xmm5
addsd  %xmm6,%xmm5
mov    %rax,%rcx
movsd  %xmm5,0x0(%rbp,%rax,8)
mov    %rdi,0x70(%rsp)
lea    0x1(%rdi),%rax
mov    %rax,0x8(%rsp)
mov    %rsi,0x140(%rsp)
cmp    %r14,%rsi
mov    %rdx,0x78(%rsp)
je     25c4 <conmin+0x14b4>
mov    %rdx,%rdi
not    %rdi
add    %r14,%rdi
cmp    $0x4,%rdi
jb     27ef <conmin+0x16df>
mov    %r14,%rcx
sub    %rdx,%rcx
lea    0x0(,%rcx,8),%r8
add    %rbp,%r8
lea    0x8(%rbp,%rdx,8),%rax
mov    %rdx,%rcx
mov    0x170(%rsp),%rdx
add    %rcx,%rdx
lea    0x0(,%rdx,8),%rcx
add    %rbp,%rcx
mov    %rcx,0x128(%rsp)
mov    0x70(%rsp),%rsi
add    0x60(%rsp),%rsi
mov    0x118(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
lea    (%r8,%rsi,8),%rcx
cmp    0x1c0(%rsp),%rdx
setb   %r8b
cmp    %rcx,%rax
setb   %al
cmp    0x1b8(%rsp),%rdx
setb   %dl
cmp    %rcx,0x128(%rsp)
setb   %cl
test   %al,%r8b
jne    27ea <conmin+0x16da>
and    %cl,%dl
jne    27ea <conmin+0x16da>
mov    0xf0(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rdi,%rcx
and    $0xfffffffffffffffc,%rcx
add    %rcx,0x140(%rsp)
mov    %rcx,0x70(%rsp)
add    %rcx,0x8(%rsp)
movapd %xmm8,%xmm11
unpcklpd %xmm8,%xmm11
movapd %xmm10,%xmm12
unpcklpd %xmm10,%xmm12
mov    0x160(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x10(%r11,%r8,8),%xmm7
movupd (%r11,%r8,8),%xmm2
movupd -0x10(%rcx,%r8,8),%xmm3
movupd (%rcx,%r8,8),%xmm4
movupd -0x10(%r10,%r8,8),%xmm5
movupd (%r10,%r8,8),%xmm6
mulpd  %xmm11,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm11,%xmm6
addpd  %xmm4,%xmm6
mulpd  %xmm12,%xmm7
addpd  %xmm5,%xmm7
mulpd  %xmm12,%xmm2
addpd  %xmm6,%xmm2
movupd %xmm7,-0x10(%rcx,%r8,8)
movupd %xmm2,(%rcx,%r8,8)
add    $0x4,%r8
cmp    %r8,%rax
jne    2770 <conmin+0x1660>
cmp    0x70(%rsp),%rdi
jne    27ea <conmin+0x16da>
add    %r8,%rsi
mov    0x18(%rsp),%r8
mov    0x8(%rsp),%rdi
jmp    25cc <conmin+0x14bc>
mov    0x18(%rsp),%r8
mov    %r14d,%ecx
mov    0x140(%rsp),%rdx
sub    %edx,%ecx
test   $0x1,%cl
mov    0x8(%rsp),%rdi
jne    280b <conmin+0x16fb>
mov    %rdx,%rcx
jmp    284d <conmin+0x173d>
mov    0x60(%rsp),%rax
lea    (%rdi,%rax,1),%rsi
mov    0x30(%rsp),%rcx
add    %rdx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  0x0(%rbp,%rsi,8),%xmm2
movsd  0x0(%rbp,%rdx,8),%xmm3
mulsd  %xmm10,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,0x0(%rbp,%rsi,8)
add    $0x1,%rdi
mov    %rdx,%rcx
add    $0x1,%rdx
not    %rcx
cmp    0xe8(%rsp),%rcx
je     25cc <conmin+0x14bc>
mov    %r14,%r8
sub    %rdx,%r8
mov    0x30(%rsp),%rcx
add    %rdx,%rcx
mov    %rdi,%rsi
mov    0x118(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
lea    (%rdi,%rdx,8),%rdx
mov    0x60(%rsp),%rax
mov    %rsi,0x8(%rsp)
add    %rax,%rsi
lea    (%rdi,%rsi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rdi,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  -0x8(%rsi,%rdi,8),%xmm2
movsd  -0x8(%rdx,%rdi,8),%xmm3
mulsd  %xmm10,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rsi,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  (%rsi,%rdi,8),%xmm2
movsd  (%rdx,%rdi,8),%xmm3
mulsd  %xmm10,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r8
jne    28a0 <conmin+0x1790>
mov    0x168(%rsp),%rax
mov    0x8(%rsp),%rcx
add    %rcx,%rax
add    %rdi,%rcx
add    %rdi,%rax
mov    %rcx,%rdi
mov    %rax,%rsi
mov    0x18(%rsp),%r8
jmp    25cc <conmin+0x14bc>
mov    %rsi,0x28(%rsp)
movl   $0x0,0x14(%rsp)
mov    0x58(%rsp),%rdi
test   %edi,%edi
mov    0x38(%rsp),%r11
movapd 0x90(%rsp),%xmm6
jle    15bb <conmin+0x4ab>
xorpd  %xmm9,%xmm9
mov    %r14,%r10
mov    %rbx,%r11
xor    %r8d,%r8d
test   %r8,%r8
mov    %r8,0x8(%rsp)
je     2965 <conmin+0x1855>
cmp    $0x1,%r8
jne    2971 <conmin+0x1861>
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    29dc <conmin+0x18cc>
xor    %r8d,%r8d
xorpd  %xmm1,%xmm1
jmp    2a13 <conmin+0x1903>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xorpd  %xmm1,%xmm1
mov    $0xfffffffe,%esi
xor    %edx,%edx
mov    0xa8(%rsp),%r14
nopl   0x0(%rax,%rax,1)
lea    (%r8,%r14,1),%ecx
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  (%rbx,%rdx,8),%xmm2
subsd  %xmm2,%xmm1
add    %edi,%r8d
add    %esi,%r8d
lea    (%r14,%r8,1),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  0x8(%rbx,%rdx,8),%xmm2
subsd  %xmm2,%xmm1
add    %edi,%r8d
add    $0x1,%r8d
add    %esi,%r8d
add    $0x2,%rdx
add    $0xfffffffe,%esi
cmp    %rdx,%rax
jne    2990 <conmin+0x1880>
testb  $0x1,0x8(%rsp)
mov    0xb0(%rsp),%r14
je     2a13 <conmin+0x1903>
mov    0xa8(%rsp),%rcx
add    %r8d,%ecx
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  (%rbx,%rdx,8),%xmm2
subsd  %xmm2,%xmm1
add    %edi,%r8d
not    %edx
add    %r8d,%edx
mov    %edx,%r8d
mov    %r8,%rdx
movslq %r8d,%rcx
add    0x60(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rsi,8),%xmm2
mulsd  (%r11,%rsi,8),%xmm2
subsd  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %rsi,%r10
jne    2a30 <conmin+0x1920>
mov    0x8(%rsp),%r8
movsd  (%rbx,%r8,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm9
movsd  %xmm1,0x0(%rbp,%r8,8)
add    $0x1,%r8
add    $0x8,%r11
add    $0xffffffffffffffff,%r10
cmp    %r14,%r8
jne    294d <conmin+0x183d>
ucomisd %xmm13,%xmm9
ja     3246 <conmin+0x2136>
add    0xcc(%rsp),%edx
add    %rsi,%rdx
mov    %rdx,0x28(%rsp)
movl   $0x0,0x14(%rsp)
mov    0x38(%rsp),%r11
mov    0x18(%rsp),%r8
jmp    15bb <conmin+0x4ab>
test   %edi,%edi
jle    2abd <conmin+0x19ad>
cmpq   $0x3,0x68(%rsp)
jae    2ac6 <conmin+0x19b6>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
jmp    2b1b <conmin+0x1a0b>
xorpd  %xmm1,%xmm1
jmp    2b4e <conmin+0x1a3e>
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
mov    0x110(%rsp),%rdx
movsd  (%rbx,%rcx,8),%xmm2
movsd  0x8(%rbx,%rcx,8),%xmm3
mulsd  -0x18(%rdx,%rcx,8),%xmm2
mulsd  -0x10(%rdx,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x10(%rbx,%rcx,8),%xmm4
mulsd  -0x8(%rdx,%rcx,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x18(%rbx,%rcx,8),%xmm1
mulsd  (%rdx,%rcx,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rcx
cmp    %rcx,%r11
jne    2ad4 <conmin+0x19c4>
test   $0x3,%r14b
je     2b4e <conmin+0x1a3e>
lea    (%rbx,%rcx,8),%rdx
add    0x30(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %esi,%esi
movsd  (%rdx,%rsi,8),%xmm2
mulsd  (%rcx,%rsi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %rsi,%rax
jne    2b37 <conmin+0x1a27>
divsd  %xmm0,%xmm1
andpd  0x14b6(%rip),%xmm1
ucomisd 0x14e6(%rip),%xmm1
mov    0x48(%rsp),%rax
cmova  %edi,%eax
mov    %rax,0x48(%rsp)
cmp    %edi,%eax
mov    0x158(%rsp),%r10
jne    2c04 <conmin+0x1af4>
movslq 0x28(%rsp),%rcx
movq   $0x0,0x0(%rbp,%rcx,8)
movq   $0x0,0x0(%rbp,%r10,8)
test   %edi,%edi
jle    2cd2 <conmin+0x1bc2>
xor    %edx,%edx
mov    0x80(%rsp),%rsi
mov    0xb8(%rsp),%rax
movsd  (%rbx,%rdx,8),%xmm1
subsd  (%rax,%rdx,8),%xmm1
movsd  %xmm1,(%r8,%rdx,8)
movsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,(%rsi,%rdx,8)
movsd  (%r8,%rdx,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  (%r8,%rdx,8),%xmm1
addsd  0x0(%rbp,%r10,8),%xmm1
movsd  %xmm1,0x0(%rbp,%r10,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    2bb0 <conmin+0x1aa0>
test   %edi,%edi
jle    2cd2 <conmin+0x1bc2>
movslq 0x28(%rsp),%rax
movsd  0x0(%rbp,%rax,8),%xmm8
movsd  0x0(%rbp,%r10,8),%xmm9
unpcklpd %xmm8,%xmm9
xorpd  %xmm1,%xmm1
xor    %edx,%edx
xorpd  %xmm2,%xmm2
mov    0x80(%rsp),%rcx
movapd 0x13e2(%rip),%xmm4
movsd  (%rbx,%rdx,8),%xmm5
movsd  (%rcx,%rdx,8),%xmm6
mulsd  %xmm5,%xmm6
movapd %xmm6,%xmm3
unpcklpd %xmm5,%xmm6
movapd %xmm4,%xmm5
movhpd (%r8,%rdx,8),%xmm5
divsd  %xmm8,%xmm3
mulpd  %xmm6,%xmm5
divpd  %xmm9,%xmm5
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
subsd  %xmm3,%xmm2
subsd  %xmm6,%xmm5
addsd  %xmm5,%xmm1
add    $0x1,%rdx
cmp    %rdx,%r14
jne    2c3e <conmin+0x1b2e>
lea    0x0(,%rax,8),%rax
add    %rbp,%rax
test   %edi,%edi
mov    %rax,0x8(%rsp)
jle    2cec <conmin+0x1bdc>
cmp    $0x4,%edi
movsd  0x0(%rbp,%r10,8),%xmm8
xorpd  %xmm7,%xmm8
divsd  (%rax),%xmm8
setb   %dl
xorpd  %xmm7,%xmm2
xorpd  %xmm7,%xmm1
or     0x24(%rsp),%dl
je     2cfa <conmin+0x1bea>
xor    %edx,%edx
movapd 0x90(%rsp),%xmm6
jmp    2dab <conmin+0x1c9b>
movslq 0x28(%rsp),%rcx
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
mov    %rax,0x8(%rsp)
jmp    2da4 <conmin+0x1c94>
movapd 0x90(%rsp),%xmm6
jmp    2da4 <conmin+0x1c94>
movapd %xmm2,%xmm9
unpcklpd %xmm2,%xmm9
movapd %xmm8,%xmm10
unpcklpd %xmm8,%xmm10
movapd %xmm1,%xmm6
unpcklpd %xmm1,%xmm6
xor    %edx,%edx
mov    0x80(%rsp),%rcx
mov    0x108(%rsp),%rsi
mov    0x100(%rsp),%rax
movupd (%rbx,%rdx,1),%xmm7
movupd 0x10(%rbx,%rdx,1),%xmm3
movupd (%r8,%rdx,1),%xmm4
movupd 0x10(%r8,%rdx,1),%xmm5
mulpd  %xmm9,%xmm4
mulpd  %xmm9,%xmm5
mulpd  %xmm10,%xmm7
addpd  %xmm4,%xmm7
mulpd  %xmm10,%xmm3
addpd  %xmm5,%xmm3
movupd (%rcx,%rdx,1),%xmm4
movupd 0x10(%rcx,%rdx,1),%xmm5
mulpd  %xmm6,%xmm4
addpd  %xmm7,%xmm4
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%rax,%rdx,1)
movupd %xmm5,(%rax,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rsi
jne    2d30 <conmin+0x1c20>
mov    %r11,%rdx
cmp    %r14,%r11
movapd 0x90(%rsp),%xmm6
jne    2dab <conmin+0x1c9b>
mov    0x48(%rsp),%rax
jmp    2ded <conmin+0x1cdd>
mov    0x80(%rsp),%rcx
mov    0x48(%rsp),%rax
movsd  (%r8,%rdx,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  (%rbx,%rdx,8),%xmm4
mulsd  %xmm8,%xmm4
addsd  %xmm3,%xmm4
movsd  (%rcx,%rdx,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,0x0(%r13,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    2db8 <conmin+0x1ca8>
cmp    %edi,%eax
jne    2e4f <conmin+0x1d3f>
test   %edi,%edi
jle    3004 <conmin+0x1ef4>
cmpq   $0x0,0x68(%rsp)
mov    0x18(%rsp),%r8
xorpd  %xmm9,%xmm9
je     3010 <conmin+0x1f00>
xor    %ecx,%ecx
movsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
mulsd  (%rbx,%rcx,8),%xmm1
addsd  %xmm9,%xmm1
movsd  (%r15,%rcx,8),%xmm9
movsd  %xmm9,0x8(%rbp,%rcx,8)
mulsd  0x8(%rbx,%rcx,8),%xmm9
addsd  %xmm1,%xmm9
add    $0x2,%rcx
cmp    %rcx,%r8
jne    2e11 <conmin+0x1d01>
jmp    3012 <conmin+0x1f02>
test   %edi,%edi
jle    3004 <conmin+0x1ef4>
mov    0x8(%rsp),%rcx
movsd  (%rcx),%xmm8
movapd %xmm8,%xmm9
movhpd 0x0(%rbp,%r10,8),%xmm9
xorpd  %xmm3,%xmm3
xor    %edx,%edx
xorpd  %xmm1,%xmm1
xorpd  %xmm2,%xmm2
mov    0x80(%rsp),%rcx
mov    0xb8(%rsp),%rsi
movsd  (%rbx,%rdx,8),%xmm4
subsd  (%rsi,%rdx,8),%xmm4
movsd  (%rcx,%rdx,8),%xmm7
movapd %xmm4,%xmm6
mulsd  %xmm7,%xmm6
divsd  %xmm8,%xmm6
subsd  %xmm6,%xmm2
addsd  %xmm7,%xmm7
movapd %xmm4,%xmm6
unpcklpd %xmm4,%xmm6
movsd  (%r8,%rdx,8),%xmm5
unpcklpd %xmm7,%xmm5
mulpd  %xmm6,%xmm5
divpd  %xmm9,%xmm5
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
addsd  %xmm5,%xmm6
mulsd  0x0(%rbp,%rdx,8),%xmm4
subsd  %xmm6,%xmm1
addsd  %xmm4,%xmm3
add    $0x1,%rdx
cmp    %rdx,%r14
jne    2e8b <conmin+0x1d7b>
test   %edi,%edi
jle    3042 <conmin+0x1f32>
xorpd  %xmm8,%xmm8
xor    %edx,%edx
mov    0x80(%rsp),%rcx
mov    0xb8(%rsp),%rsi
mov    0x8(%rsp),%rax
movsd  0x0(%rbp,%r10,8),%xmm5
divsd  (%rax),%xmm5
movsd  (%rbx,%rdx,8),%xmm6
subsd  (%rsi,%rdx,8),%xmm6
movsd  (%r8,%rdx,8),%xmm7
mulsd  %xmm2,%xmm7
mulsd  %xmm6,%xmm5
addsd  %xmm7,%xmm5
movsd  (%rcx,%rdx,8),%xmm7
mulsd  %xmm1,%xmm7
addsd  %xmm5,%xmm7
mulsd  %xmm7,%xmm6
addsd  %xmm6,%xmm8
movsd  %xmm7,(%rsi,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r14
jne    2f11 <conmin+0x1e01>
test   %edi,%edi
mov    0x18(%rsp),%r8
jle    3057 <conmin+0x1f47>
divsd  %xmm3,%xmm8
addsd  0x10b9(%rip),%xmm8
movapd %xmm3,%xmm5
unpcklpd %xmm3,%xmm5
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
xorpd  %xmm2,%xmm2
mov    0xb8(%rsp),%rax
movsd  0x0(%rbp,%rcx,8),%xmm6
movsd  (%rbx,%rcx,8),%xmm7
movapd %xmm8,%xmm4
mulsd  %xmm6,%xmm4
mulsd  %xmm7,%xmm6
divsd  %xmm3,%xmm6
subsd  %xmm6,%xmm2
movhpd (%rax,%rcx,8),%xmm4
unpcklpd %xmm7,%xmm7
mulpd  %xmm4,%xmm7
divpd  %xmm5,%xmm7
movapd %xmm7,%xmm4
unpckhpd %xmm7,%xmm4
subsd  %xmm4,%xmm7
addsd  %xmm7,%xmm1
add    $0x1,%rcx
cmp    %rcx,%r14
jne    2f91 <conmin+0x1e81>
test   %edi,%edi
movapd 0x90(%rsp),%xmm6
mov    0x48(%rsp),%rax
jle    306c <conmin+0x1f5c>
cmp    $0x4,%edi
setb   %cl
or     0x23(%rsp),%cl
je     3093 <conmin+0x1f83>
xor    %edx,%edx
jmp    3131 <conmin+0x2021>
xorpd  %xmm9,%xmm9
mov    0x18(%rsp),%r8
jmp    3071 <conmin+0x1f61>
xor    %ecx,%ecx
test   $0x1,%r14b
je     3036 <conmin+0x1f26>
mov    0x50(%rsp),%rdx
add    %rcx,%rdx
movsd  0x0(%rbp,%rdx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
mulsd  (%rbx,%rcx,8),%xmm1
addsd  %xmm1,%xmm9
ucomisd %xmm13,%xmm9
jbe    3071 <conmin+0x1f61>
jmp    3246 <conmin+0x2136>
xorpd  %xmm9,%xmm9
mov    0x18(%rsp),%r8
movapd 0x90(%rsp),%xmm6
jmp    3071 <conmin+0x1f61>
xorpd  %xmm9,%xmm9
movapd 0x90(%rsp),%xmm6
mov    0x48(%rsp),%rax
jmp    3071 <conmin+0x1f61>
xorpd  %xmm9,%xmm9
cmp    %edi,%eax
lea    0x1(%rax),%ecx
mov    $0x1,%eax
cmove  %eax,%ecx
mov    $0x1,%al
mov    %eax,0x44(%rsp)
movl   $0x0,0x14(%rsp)
mov    %ecx,%eax
jmp    159f <conmin+0x48f>
movapd %xmm1,%xmm8
unpcklpd %xmm1,%xmm8
movapd %xmm2,%xmm4
unpcklpd %xmm2,%xmm4
xor    %ecx,%ecx
mov    0x108(%rsp),%rax
mov    0x100(%rsp),%rdx
mov    0x150(%rsp),%rsi
movupd -0x10(%rsi,%rcx,1),%xmm5
movupd (%rsi,%rcx,1),%xmm6
movupd 0x0(%rbp,%rcx,1),%xmm7
movupd 0x10(%rbp,%rcx,1),%xmm3
mulpd  %xmm8,%xmm7
mulpd  %xmm8,%xmm3
mulpd  %xmm4,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm4,%xmm6
addpd  %xmm3,%xmm6
movupd -0x10(%rdx,%rcx,1),%xmm3
subpd  %xmm5,%xmm3
movupd (%rdx,%rcx,1),%xmm5
subpd  %xmm6,%xmm5
movupd %xmm3,-0x10(%rdx,%rcx,1)
movupd %xmm5,(%rdx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rax
jne    30bf <conmin+0x1faf>
mov    %r11,%rdx
cmp    %r14,%r11
movapd 0x90(%rsp),%xmm6
mov    0x48(%rsp),%rax
je     2df1 <conmin+0x1ce1>
mov    %rdx,%rcx
test   $0x1,%r14b
je     317a <conmin+0x206a>
mov    0x30(%rsp),%rcx
add    %rdx,%rcx
mov    0x50(%rsp),%rsi
lea    (%rdx,%rsi,1),%rsi
movsd  0x0(%rbp,%rdx,8),%xmm3
mulsd  %xmm1,%xmm3
movsd  0x0(%rbp,%rcx,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  0x0(%rbp,%rsi,8),%xmm3
subsd  %xmm4,%xmm3
movsd  %xmm3,0x0(%rbp,%rsi,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0xe8(%rsp),%rdx
je     2df1 <conmin+0x1ce1>
movsd  0x0(%rbp,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
mov    0x1b0(%rsp),%rax
movsd  -0x8(%rax,%rcx,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  -0x8(%r15,%rcx,8),%xmm3
subsd  %xmm4,%xmm3
movsd  (%r15,%rcx,8),%xmm4
movsd  %xmm3,-0x8(%r15,%rcx,8)
movsd  0x8(%rbp,%rcx,8),%xmm3
mulsd  %xmm1,%xmm3
movsd  (%rax,%rcx,8),%xmm5
mov    0x48(%rsp),%rax
mulsd  %xmm2,%xmm5
addsd  %xmm3,%xmm5
subsd  %xmm5,%xmm4
movapd 0x90(%rsp),%xmm6
movsd  %xmm4,(%r15,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r14
jne    318b <conmin+0x207b>
jmp    2df1 <conmin+0x1ce1>
movapd %xmm7,%xmm0
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm0,0xd0(%rsp)
testb  $0x1,0x44(%rsp)
jne    1495 <conmin+0x385>
mov    $0x2,%eax
jmp    3230 <conmin+0x2120>
mov    $0x1,%eax
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
jmp    3230 <conmin+0x2120>
mov    $0x3,%eax
jmp    3230 <conmin+0x2120>

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

LLVM IR (-O2):
define i32 @conmin(i32 %0, double* %1, double* nocapture %2, double* %3, i32* nocapture %4, i32* nocapture writeonly %5, double %6, i32 %7, double* %8, i32 %9, double %10, i32 %11, double (i32, double*, double*, i8*)* nocapture %12, i8* %13) {
store i32 0, i32* %4
store i32 0, i32* %5
%15 = shl i32 %0, 1
%16 = icmp eq i32 %11, 0
%17 = mul nsw i32 %0, 3
br i1 %16, label %18, label %25
18: ; preds = %14
%19 = shl nsw i32 %0, 2
%20 = mul nsw i32 %0, 5
%21 = add nsw i32 %20, 1
%22 = sext i32 %21 to i64
%23 = sext i32 %19 to i64
%24 = sext i32 %17 to i64
br label %25
25: ; preds = %14, %18
%26 = phi i64 [ %23, %18 ], [ 0, %14 ]
%27 = phi i64 [ %24, %18 ], [ 0, %14 ]
%28 = phi i32 [ %20, %18 ], [ %17, %14 ]
%29 = phi i32 [ %20, %18 ], [ undef, %14 ]
%30 = phi i64 [ %22, %18 ], [ 0, %14 ]
%31 = icmp sgt i32 %0, 0
%32 = fmul double %6, %6
%33 = icmp eq i32 %11, 1
%34 = getelementptr inbounds double, double* %8, i64 %30
%35 = sext i32 %0 to i64
%36 = sext i32 %15 to i64
%37 = sext i32 %28 to i64
%38 = zext i32 %0 to i64
%39 = zext i32 %0 to i64
%40 = fcmp ult double %32, 0.000000e+00
%41 = zext i32 %0 to i64
%42 = zext i32 %0 to i64
%43 = zext i32 %0 to i64
%44 = zext i32 %0 to i64
%45 = zext i32 %0 to i64
%46 = zext i32 %0 to i64
%47 = zext i32 %0 to i64
%48 = zext i32 %0 to i64
%49 = zext i32 %0 to i64
%50 = zext i32 %0 to i64
%51 = zext i32 %0 to i64
%52 = zext i32 %0 to i64
%53 = zext i32 %0 to i64
%54 = getelementptr double, double* %8, i64 %35
%55 = add nsw i64 %35, %38
%56 = getelementptr double, double* %8, i64 %55
%57 = getelementptr double, double* %8, i64 %36
%58 = add nsw i64 %36, %38
%59 = getelementptr double, double* %8, i64 %58
%60 = getelementptr double, double* %8, i64 %38
%61 = getelementptr double, double* %8, i64 %35
%62 = add nsw i64 %35, %38
%63 = getelementptr double, double* %8, i64 %62
%64 = getelementptr double, double* %3, i64 %38
%65 = getelementptr double, double* %8, i64 %27
%66 = add nsw i64 %27, %38
%67 = getelementptr double, double* %8, i64 %66
%68 = getelementptr double, double* %8, i64 %26
%69 = add nsw i64 %26, %38
%70 = getelementptr double, double* %8, i64 %69
%71 = getelementptr double, double* %8, i64 1
%72 = getelementptr double, double* %8, i64 %38
%73 = or i64 %36, 1
%74 = add nsw i64 %36, %38
%75 = getelementptr double, double* %8, i64 %74
%76 = getelementptr double, double* %8, i64 %36
%77 = getelementptr double, double* %8, i64 %74
%78 = getelementptr double, double* %8, i64 %38
%79 = getelementptr double, double* %8, i64 %35
%80 = add nsw i64 %35, %38
%81 = getelementptr double, double* %8, i64 %80
%82 = getelementptr double, double* %1, i64 %38
%83 = getelementptr double, double* %8, i64 %38
%84 = getelementptr double, double* %8, i64 %35
%85 = add nsw i64 %35, %38
%86 = getelementptr double, double* %8, i64 %85
%87 = add nsw i64 %38, -1
%88 = and i64 %38, 4294967292
%89 = add nsw i64 %88, -4
%90 = lshr exact i64 %89, 2
%91 = add nuw nsw i64 %90, 1
%92 = and i64 %38, 1
%93 = icmp eq i64 %87, 0
%94 = and i64 %38, 4294967294
%95 = icmp eq i64 %92, 0
%96 = icmp ult i32 %0, 4
%97 = icmp ugt double* %83, %1
%98 = icmp ugt double* %82, %8
%99 = and i1 %97, %98
%100 = icmp ugt double* %86, %1
%101 = icmp ult double* %84, %82
%102 = and i1 %100, %101
%103 = or i1 %99, %102
%104 = and i64 %38, 4294967292
%105 = and i64 %91, 1
%106 = icmp eq i64 %89, 0
%107 = and i64 %91, 9223372036854775806
%108 = icmp eq i64 %105, 0
%109 = icmp eq i64 %104, %38
%110 = and i64 %38, 1
%111 = icmp eq i64 %110, 0
%112 = sub nsw i64 0, %38
%113 = and i64 %38, 3
%114 = icmp ult i64 %87, 3
%115 = and i64 %38, 4294967292
%116 = icmp eq i64 %113, 0
%117 = and i64 %38, 3
%118 = icmp ult i64 %87, 3
%119 = and i64 %38, 4294967292
%120 = icmp eq i64 %117, 0
%121 = icmp ult i32 %0, 4
%122 = and i64 %38, 4294967292
%123 = and i64 %91, 1
%124 = icmp eq i64 %89, 0
%125 = and i64 %91, 9223372036854775806
%126 = icmp eq i64 %123, 0
%127 = icmp eq i64 %122, %38
%128 = and i64 %38, 1
%129 = icmp eq i64 %87, 0
%130 = and i64 %38, 4294967294
%131 = icmp eq i64 %128, 0
%132 = and i64 %38, 3
%133 = icmp ult i64 %87, 3
%134 = and i64 %38, 4294967292
%135 = icmp eq i64 %132, 0
%136 = sub i32 0, %0
%137 = icmp ult i32 %0, 4
%138 = icmp ult double* %76, %78
%139 = icmp ugt double* %77, %8
%140 = and i1 %138, %139
%141 = icmp ult double* %76, %81
%142 = icmp ult double* %79, %77
%143 = and i1 %141, %142
%144 = or i1 %140, %143
%145 = and i64 %38, 4294967292
%146 = icmp eq i64 %145, %38
%147 = and i64 %38, 1
%148 = icmp eq i64 %147, 0
%149 = sub nsw i64 0, %38
%150 = sub nsw i64 0, %38
%151 = and i64 %38, 3
%152 = icmp ult i64 %87, 3
%153 = and i64 %38, 4294967292
%154 = icmp eq i64 %151, 0
%155 = icmp ult i32 %0, 4
%156 = icmp ult double* %61, %64
%157 = icmp ugt double* %63, %3
%158 = and i1 %156, %157
%159 = icmp ult double* %61, %67
%160 = icmp ult double* %65, %63
%161 = and i1 %159, %160
%162 = or i1 %158, %161
%163 = icmp ult double* %61, %70
%164 = icmp ult double* %68, %63
%165 = and i1 %163, %164
%166 = or i1 %162, %165
%167 = and i64 %38, 4294967292
%168 = icmp eq i64 %167, %38
%169 = icmp ult i32 %0, 4
%170 = icmp ult double* %54, %59
%171 = icmp ult double* %57, %56
%172 = and i1 %170, %171
%173 = icmp ult double* %54, %60
%174 = icmp ugt double* %56, %8
%175 = and i1 %173, %174
%176 = or i1 %172, %175
%177 = and i64 %38, 4294967292
%178 = icmp eq i64 %177, %38
%179 = and i64 %38, 1
%180 = icmp eq i64 %179, 0
%181 = sub nsw i64 0, %38
%182 = and i64 %38, 1
%183 = icmp eq i64 %87, 0
%184 = and i64 %38, 4294967294
%185 = icmp eq i64 %182, 0
br label %186
186: ; preds = %405, %25
%187 = phi double [ undef, %25 ], [ %406, %405 ]
%188 = phi i32 [ %29, %25 ], [ %240, %405 ]
%189 = tail call double %12(i32 %0, double* %1, double* %3, i8* %13)
store double %189, double* %2
%190 = load i32, i32* %4
%191 = add nsw i32 %190, 1
store i32 %191, i32* %4
br i1 %31, label %192, label %212
192: ; preds = %186, %192
%193 = phi i64 [ %208, %192 ], [ 0, %186 ]
%194 = phi <2 x double> [ %207, %192 ], [ zeroinitializer, %186 ]
%195 = getelementptr inbounds double, double* %3, i64 %193
%196 = load double, double* %195
%197 = fneg double %196
%198 = getelementptr inbounds double, double* %8, i64 %193
store double %197, double* %198
%199 = getelementptr inbounds double, double* %1, i64 %193
%200 = load double, double* %199
%201 = load double, double* %195
%202 = fneg double %201
%203 = insertelement <2 x double> poison, double %202, i64 0
%204 = insertelement <2 x double> %203, double %200, i64 1
%205 = insertelement <2 x double> poison, double %201, i64 0
%206 = insertelement <2 x double> %205, double %200, i64 1
%207 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %204, <2 x double> %206, <2 x double> %194)
%208 = add nuw nsw i64 %193, 1
%209 = icmp eq i64 %208, %38
br i1 %209, label %210, label %192
210: ; preds = %192
%211 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %204, <2 x double> %206, <2 x double> %194)
br label %212
212: ; preds = %210, %186
%213 = phi <2 x double> [ zeroinitializer, %186 ], [ %211, %210 ]
%214 = extractelement <2 x double> %213, i64 0
%215 = fneg double %214
%216 = extractelement <2 x double> %213, i64 1
%217 = tail call double @llvm.maxnum.f64(double %216, double 1.000000e+00)
%218 = fmul double %32, %217
%219 = fcmp ult double %218, %215
br i1 %219, label %220, label %1707
220: ; preds = %212, %1126
%221 = phi i32 [ %429, %1126 ], [ %191, %212 ]
%222 = phi i1 [ false, %1126 ], [ true, %212 ]
%223 = phi i1 [ true, %1126 ], [ false, %212 ]
%224 = phi i32 [ %1129, %1126 ], [ %0, %212 ]
%225 = phi double [ %246, %1126 ], [ %214, %212 ]
%226 = phi double [ %1127, %1126 ], [ %214, %212 ]
%227 = phi double [ %690, %1126 ], [ %215, %212 ]
%228 = phi double [ %311, %1126 ], [ %187, %212 ]
%229 = phi i32 [ %240, %1126 ], [ %188, %212 ]
%230 = icmp eq i32 %224, 1
%231 = or i1 %33, %230
br label %232
232: ; preds = %1384, %220
%233 = phi i32 [ %221, %220 ], [ %429, %1384 ]
%234 = phi i1 [ %222, %220 ], [ false, %1384 ]
%235 = phi i1 [ %223, %220 ], [ true, %1384 ]
%236 = phi double [ %225, %220 ], [ %246, %1384 ]
%237 = phi double [ %226, %220 ], [ %1385, %1384 ]
%238 = phi double [ %227, %220 ], [ %690, %1384 ]
%239 = phi double [ %228, %220 ], [ %311, %1384 ]
%240 = phi i32 [ %229, %220 ], [ %1386, %1384 ]
br label %241
241: ; preds = %1173, %232
%242 = phi i32 [ %233, %232 ], [ %429, %1173 ]
%243 = phi i1 [ %234, %232 ], [ false, %1173 ]
%244 = phi i1 [ %235, %232 ], [ true, %1173 ]
%245 = phi double [ %236, %232 ], [ %246, %1173 ]
%246 = phi double [ %237, %232 ], [ 0.000000e+00, %1173 ]
%247 = phi double [ %238, %232 ], [ %690, %1173 ]
%248 = phi double [ %239, %232 ], [ %311, %1173 ]
%249 = load double, double* %2
%250 = fmul double %245, %248
%251 = fdiv double %250, %246
%252 = select i1 %231, double 1.000000e+00, double %251
br i1 %243, label %253, label %256
253: ; preds = %241
%254 = tail call double @sqrt(double %247)
%255 = fdiv double 1.000000e+00, %254
br label %256
256: ; preds = %253, %241
%257 = phi double [ %255, %253 ], [ %252, %241 ]
br i1 %31, label %258, label %305
258: ; preds = %256
br i1 %93, label %289, label %259
259: ; preds = %258, %259
%260 = phi i64 [ %286, %259 ], [ 0, %258 ]
%261 = phi double [ %277, %259 ], [ 0.000000e+00, %258 ]
%262 = phi i64 [ %287, %259 ], [ 0, %258 ]
%263 = getelementptr inbounds double, double* %8, i64 %260
%264 = load double, double* %263
%265 = tail call double @llvm.fmuladd.f64(double %264, double %264, double %261)
%266 = add nsw i64 %260, %35
%267 = add nsw i64 %260, %36
%268 = getelementptr inbounds double, double* %1, i64 %260
%269 = load double, double* %268
%270 = getelementptr inbounds double, double* %8, i64 %266
store double %269, double* %270
%271 = getelementptr inbounds double, double* %3, i64 %260
%272 = load double, double* %271
%273 = getelementptr inbounds double, double* %8, i64 %267
store double %272, double* %273
%274 = or i64 %260, 1
%275 = getelementptr inbounds double, double* %8, i64 %274
%276 = load double, double* %275
%277 = tail call double @llvm.fmuladd.f64(double %276, double %276, double %265)
%278 = add nsw i64 %274, %35
%279 = add nsw i64 %274, %36
%280 = getelementptr inbounds double, double* %1, i64 %274
%281 = load double, double* %280
%282 = getelementptr inbounds double, double* %8, i64 %278
store double %281, double* %282
%283 = getelementptr inbounds double, double* %3, i64 %274
%284 = load double, double* %283
%285 = getelementptr inbounds double, double* %8, i64 %279
store double %284, double* %285
%286 = add nuw nsw i64 %260, 2
%287 = add i64 %262, 2
%288 = icmp eq i64 %287, %94
br i1 %288, label %289, label %259
289: ; preds = %259, %258
%290 = phi double [ undef, %258 ], [ %277, %259 ]
%291 = phi i64 [ 0, %258 ], [ %286, %259 ]
%292 = phi double [ 0.000000e+00, %258 ], [ %277, %259 ]
br i1 %95, label %305, label %293
293: ; preds = %289
%294 = getelementptr inbounds double, double* %8, i64 %291
%295 = load double, double* %294
%296 = tail call double @llvm.fmuladd.f64(double %295, double %295, double %292)
%297 = add nsw i64 %291, %35
%298 = add nsw i64 %291, %36
%299 = getelementptr inbounds double, double* %1, i64 %291
%300 = load double, double* %299
%301 = getelementptr inbounds double, double* %8, i64 %297
store double %300, double* %301
%302 = getelementptr inbounds double, double* %3, i64 %291
%303 = load double, double* %302
%304 = getelementptr inbounds double, double* %8, i64 %298
store double %303, double* %304
br label %305
305: ; preds = %293, %289, %256
%306 = phi double [ 0.000000e+00, %256 ], [ %290, %289 ], [ %296, %293 ]
%307 = tail call double @sqrt(double %306)
%308 = fmul double %307, %257
%309 = fcmp ugt double %308, %10
br i1 %309, label %310, label %405
310: ; preds = %305, %561
%311 = phi double [ %565, %561 ], [ %257, %305 ]
%312 = phi double [ %564, %561 ], [ %249, %305 ]
%313 = phi double [ %563, %561 ], [ %246, %305 ]
%314 = phi double [ %562, %561 ], [ 0.000000e+00, %305 ]
br i1 %31, label %315, label %426
315: ; preds = %310
%316 = select i1 %96, i1 true, i1 %103
br i1 %316, label %390, label %317
317: ; preds = %315
%318 = insertelement <2 x double> poison, double %311, i64 0
%319 = shufflevector <2 x double> %318, <2 x double> poison, <2 x i32> zeroinitializer
%320 = insertelement <2 x double> poison, double %311, i64 0
%321 = shufflevector <2 x double> %320, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %106, label %367, label %322
322: ; preds = %317, %322
%323 = phi i64 [ %364, %322 ], [ 0, %317 ]
%324 = phi i64 [ %365, %322 ], [ 0, %317 ]
%325 = add nsw i64 %323, %35
%326 = getelementptr inbounds double, double* %8, i64 %325
%327 = bitcast double* %326 to <2 x double>*
%328 = load <2 x double>, <2 x double>* %327
%329 = getelementptr inbounds double, double* %326, i64 2
%330 = bitcast double* %329 to <2 x double>*
%331 = load <2 x double>, <2 x double>* %330
%332 = getelementptr inbounds double, double* %8, i64 %323
%333 = bitcast double* %332 to <2 x double>*
%334 = load <2 x double>, <2 x double>* %333
%335 = getelementptr inbounds double, double* %332, i64 2
%336 = bitcast double* %335 to <2 x double>*
%337 = load <2 x double>, <2 x double>* %336
%338 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %319, <2 x double> %334, <2 x double> %328)
%339 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %321, <2 x double> %337, <2 x double> %331)
%340 = getelementptr inbounds double, double* %1, i64 %323
%341 = bitcast double* %340 to <2 x double>*
store <2 x double> %338, <2 x double>* %341
%342 = getelementptr inbounds double, double* %340, i64 2
%343 = bitcast double* %342 to <2 x double>*
store <2 x double> %339, <2 x double>* %343
%344 = or i64 %323, 4
%345 = add nsw i64 %344, %35
%346 = getelementptr inbounds double, double* %8, i64 %345
%347 = bitcast double* %346 to <2 x double>*
%348 = load <2 x double>, <2 x double>* %347
%349 = getelementptr inbounds double, double* %346, i64 2
%350 = bitcast double* %349 to <2 x double>*
%351 = load <2 x double>, <2 x double>* %350
%352 = getelementptr inbounds double, double* %8, i64 %344
%353 = bitcast double* %352 to <2 x double>*
%354 = load <2 x double>, <2 x double>* %353
%355 = getelementptr inbounds double, double* %352, i64 2
%356 = bitcast double* %355 to <2 x double>*
%357 = load <2 x double>, <2 x double>* %356
%358 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %319, <2 x double> %354, <2 x double> %348)
%359 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %321, <2 x double> %357, <2 x double> %351)
%360 = getelementptr inbounds double, double* %1, i64 %344
%361 = bitcast double* %360 to <2 x double>*
store <2 x double> %358, <2 x double>* %361
%362 = getelementptr inbounds double, double* %360, i64 2
%363 = bitcast double* %362 to <2 x double>*
store <2 x double> %359, <2 x double>* %363
%364 = add nuw i64 %323, 8
%365 = add i64 %324, 2
%366 = icmp eq i64 %365, %107
br i1 %366, label %367, label %322
367: ; preds = %322, %317
%368 = phi i64 [ 0, %317 ], [ %364, %322 ]
br i1 %108, label %389, label %369
369: ; preds = %367
%370 = add nsw i64 %368, %35
%371 = getelementptr inbounds double, double* %8, i64 %370
%372 = bitcast double* %371 to <2 x double>*
%373 = load <2 x double>, <2 x double>* %372
%374 = getelementptr inbounds double, double* %371, i64 2
%375 = bitcast double* %374 to <2 x double>*
%376 = load <2 x double>, <2 x double>* %375
%377 = getelementptr inbounds double, double* %8, i64 %368
%378 = bitcast double* %377 to <2 x double>*
%379 = load <2 x double>, <2 x double>* %378
%380 = getelementptr inbounds double, double* %377, i64 2
%381 = bitcast double* %380 to <2 x double>*
%382 = load <2 x double>, <2 x double>* %381
%383 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %319, <2 x double> %379, <2 x double> %373)
%384 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %321, <2 x double> %382, <2 x double> %376)
%385 = getelementptr inbounds double, double* %1, i64 %368
%386 = bitcast double* %385 to <2 x double>*
store <2 x double> %383, <2 x double>* %386
%387 = getelementptr inbounds double, double* %385, i64 2
%388 = bitcast double* %387 to <2 x double>*
store <2 x double> %384, <2 x double>* %388
br label %389
389: ; preds = %367, %369
br i1 %109, label %426, label %390
390: ; preds = %315, %389
%391 = phi i64 [ 0, %315 ], [ %104, %389 ]
%392 = xor i64 %391, -1
br i1 %111, label %402, label %393
393: ; preds = %390
%394 = add nsw i64 %391, %35
%395 = getelementptr inbounds double, double* %8, i64 %394
%396 = load double, double* %395
%397 = getelementptr inbounds double, double* %8, i64 %391
%398 = load double, double* %397
%399 = tail call double @llvm.fmuladd.f64(double %311, double %398, double %396)
%400 = getelementptr inbounds double, double* %1, i64 %391
store double %399, double* %400
%401 = or i64 %391, 1
br label %402
402: ; preds = %393, %390
%403 = phi i64 [ %391, %390 ], [ %401, %393 ]
%404 = icmp eq i64 %392, %112
br i1 %404, label %426, label %407
405: ; preds = %305, %561
%406 = phi double [ %565, %561 ], [ %257, %305 ]
br i1 %244, label %186, label %1707
407: ; preds = %402, %407
%408 = phi i64 [ %424, %407 ], [ %403, %402 ]
%409 = add nsw i64 %408, %35
%410 = getelementptr inbounds double, double* %8, i64 %409
%411 = load double, double* %410
%412 = getelementptr inbounds double, double* %8, i64 %408
%413 = load double, double* %412
%414 = tail call double @llvm.fmuladd.f64(double %311, double %413, double %411)
%415 = getelementptr inbounds double, double* %1, i64 %408
store double %414, double* %415
%416 = add nuw nsw i64 %408, 1
%417 = add nsw i64 %416, %35
%418 = getelementptr inbounds double, double* %8, i64 %417
%419 = load double, double* %418
%420 = getelementptr inbounds double, double* %8, i64 %416
%421 = load double, double* %420
%422 = tail call double @llvm.fmuladd.f64(double %311, double %421, double %419)
%423 = getelementptr inbounds double, double* %1, i64 %416
store double %422, double* %423
%424 = add nuw nsw i64 %408, 2
%425 = icmp eq i64 %424, %39
br i1 %425, label %426, label %407
426: ; preds = %402, %407, %389, %310
%427 = tail call double %12(i32 %0, double* %1, double* %3, i8* %13)
store double %427, double* %2
%428 = load i32, i32* %4
%429 = add nsw i32 %428, 1
store i32 %429, i32* %4
%430 = icmp slt i32 %428, %7
br i1 %430, label %431, label %1707
431: ; preds = %426
br i1 %31, label %432, label %486
432: ; preds = %431
br i1 %114, label %463, label %433
433: ; preds = %432, %433
%434 = phi i64 [ %460, %433 ], [ 0, %432 ]
%435 = phi double [ %459, %433 ], [ 0.000000e+00, %432 ]
%436 = phi i64 [ %461, %433 ], [ 0, %432 ]
%437 = getelementptr inbounds double, double* %3, i64 %434
%438 = load double, double* %437
%439 = getelementptr inbounds double, double* %8, i64 %434
%440 = load double, double* %439
%441 = tail call double @llvm.fmuladd.f64(double %438, double %440, double %435)
%442 = or i64 %434, 1
%443 = getelementptr inbounds double, double* %3, i64 %442
%444 = load double, double* %443
%445 = getelementptr inbounds double, double* %8, i64 %442
%446 = load double, double* %445
%447 = tail call double @llvm.fmuladd.f64(double %444, double %446, double %441)
%448 = or i64 %434, 2
%449 = getelementptr inbounds double, double* %3, i64 %448
%450 = load double, double* %449
%451 = getelementptr inbounds double, double* %8, i64 %448
%452 = load double, double* %451
%453 = tail call double @llvm.fmuladd.f64(double %450, double %452, double %447)
%454 = or i64 %434, 3
%455 = getelementptr inbounds double, double* %3, i64 %454
%456 = load double, double* %455
%457 = getelementptr inbounds double, double* %8, i64 %454
%458 = load double, double* %457
%459 = tail call double @llvm.fmuladd.f64(double %456, double %458, double %453)
%460 = add nuw nsw i64 %434, 4
%461 = add i64 %436, 4
%462 = icmp eq i64 %461, %115
br i1 %462, label %463, label %433
463: ; preds = %433, %432
%464 = phi double [ undef, %432 ], [ %459, %433 ]
%465 = phi i64 [ 0, %432 ], [ %460, %433 ]
%466 = phi double [ 0.000000e+00, %432 ], [ %459, %433 ]
br i1 %116, label %479, label %467
467: ; preds = %463, %467
%468 = phi i64 [ %476, %467 ], [ %465, %463 ]
%469 = phi double [ %475, %467 ], [ %466, %463 ]
%470 = phi i64 [ %477, %467 ], [ 0, %463 ]
%471 = getelementptr inbounds double, double* %3, i64 %468
%472 = load double, double* %471
%473 = getelementptr inbounds double, double* %8, i64 %468
%474 = load double, double* %473
%475 = tail call double @llvm.fmuladd.f64(double %472, double %474, double %469)
%476 = add nuw nsw i64 %468, 1
%477 = add i64 %470, 1
%478 = icmp eq i64 %477, %113
br i1 %478, label %479, label %467
479: ; preds = %467, %463
%480 = phi double [ %464, %463 ], [ %475, %467 ]
%481 = fcmp ogt double %427, %249
%482 = fcmp olt double %480, 0.000000e+00
%483 = select i1 %481, i1 %482, i1 false
br i1 %483, label %484, label %486
484: ; preds = %479
%485 = fdiv double %311, 3.000000e+00
br label %561
486: ; preds = %431, %479
%487 = phi double [ %480, %479 ], [ 0.000000e+00, %431 ]
%488 = fmul double %311, 1.000000e-04
%489 = tail call double @llvm.fmuladd.f64(double %488, double %246, double %249)
%490 = fcmp ogt double %427, %489
br i1 %490, label %503, label %491
491: ; preds = %486
%492 = fdiv double %487, %246
%493 = tail call double @llvm.fabs.f64(double %492)
%494 = fcmp ogt double %493, 9.000000e-01
br i1 %494, label %503, label %495
495: ; preds = %491
%496 = sub nsw i32 %429, %242
%497 = icmp slt i32 %496, 2
%498 = fcmp ogt double %493, %6
%499 = and i1 %16, %498
%500 = select i1 %497, i1 %499, i1 false
br i1 %500, label %503, label %501
501: ; preds = %495
br i1 %31, label %502, label %631
502: ; preds = %501
br i1 %118, label %606, label %568
503: ; preds = %495, %491, %486
%504 = fadd double %313, %487
%505 = fsub double %312, %427
%506 = fmul double %505, 3.000000e+00
%507 = fsub double %314, %311
%508 = fdiv double %506, %507
%509 = fsub double %504, %508
%510 = fneg double %313
%511 = fmul double %487, %510
%512 = tail call double @llvm.fmuladd.f64(double %509, double %509, double %511)
%513 = fcmp olt double %512, 0.000000e+00
%514 = select i1 %513, double 0.000000e+00, double %512
%515 = tail call double @sqrt(double %514)
%516 = fsub double %311, %314
%517 = fadd double %487, %515
%518 = fsub double %517, %509
%519 = fmul double %516, %518
%520 = fsub double %487, %313
%521 = tail call double @llvm.fmuladd.f64(double %515, double 2.000000e+00, double %520)
%522 = fdiv double %519, %521
%523 = fsub double %311, %522
%524 = fdiv double %487, %313
%525 = fcmp ogt double %524, 0.000000e+00
br i1 %525, label %526, label %547
526: ; preds = %503
%527 = fcmp ogt double %487, 0.000000e+00
%528 = fcmp ogt double %523, 0.000000e+00
%529 = select i1 %527, i1 %528, i1 false
br i1 %529, label %530, label %534
530: ; preds = %526
%531 = tail call double @llvm.minnum.f64(double %314, double %311)
%532 = fmul double %531, 0x3FEFAE147AE147AE
%533 = fcmp olt double %523, %532
br i1 %533, label %558, label %534
534: ; preds = %530, %526
%535 = fcmp ugt double %487, 0.000000e+00
br i1 %535, label %542, label %536
536: ; preds = %534
%537 = tail call double @llvm.maxnum.f64(double %314, double %311)
%538 = fmul double %537, 1.010000e+00
%539 = fcmp ogt double %523, %538
br i1 %539, label %558, label %540
540: ; preds = %536
%541 = fmul double %537, 2.000000e+00
br label %542
542: ; preds = %534, %540
%543 = phi double [ %541, %540 ], [ %523, %534 ]
br i1 %527, label %544, label %558
544: ; preds = %542
%545 = tail call double @llvm.minnum.f64(double %314, double %311)
%546 = fmul double %545, 5.000000e-01
br label %558
547: ; preds = %503
%548 = tail call double @llvm.minnum.f64(double %311, double %314)
%549 = fmul double %548, 1.010000e+00
%550 = fcmp olt double %523, %549
br i1 %550, label %555, label %551
551: ; preds = %547
%552 = tail call double @llvm.maxnum.f64(double %311, double %314)
%553 = fmul double %552, 0x3FEFAE147AE147AE
%554 = fcmp ogt double %523, %553
br i1 %554, label %555, label %558
555: ; preds = %551, %547
%556 = fadd double %314, %311
%557 = fmul double %556, 5.000000e-01
br label %558
558: ; preds = %551, %555, %530, %542, %544, %536
%559 = phi double [ %523, %530 ], [ %523, %536 ], [ %546, %544 ], [ %543, %542 ], [ %557, %555 ], [ %523, %551 ]
%560 = load double, double* %2
br label %561
561: ; preds = %558, %484
%562 = phi double [ 0.000000e+00, %484 ], [ %311, %558 ]
%563 = phi double [ %246, %484 ], [ %487, %558 ]
%564 = phi double [ %249, %484 ], [ %560, %558 ]
%565 = phi double [ %485, %484 ], [ %559, %558 ]
%566 = fmul double %307, %565
%567 = fcmp ugt double %566, %10
br i1 %567, label %310, label %405
568: ; preds = %502, %568
%569 = phi i64 [ %603, %568 ], [ 0, %502 ]
%570 = phi <2 x double> [ %602, %568 ], [ zeroinitializer, %502 ]
%571 = phi i64 [ %604, %568 ], [ 0, %502 ]
%572 = getelementptr inbounds double, double* %3, i64 %569
%573 = load double, double* %572
%574 = getelementptr inbounds double, double* %1, i64 %569
%575 = load double, double* %574
%576 = insertelement <2 x double> poison, double %575, i64 0
%577 = insertelement <2 x double> %576, double %573, i64 1
%578 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %577, <2 x double> %577, <2 x double> %570)
%579 = or i64 %569, 1
%580 = getelementptr inbounds double, double* %3, i64 %579
%581 = load double, double* %580
%582 = getelementptr inbounds double, double* %1, i64 %579
%583 = load double, double* %582
%584 = insertelement <2 x double> poison, double %583, i64 0
%585 = insertelement <2 x double> %584, double %581, i64 1
%586 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %585, <2 x double> %585, <2 x double> %578)
%587 = or i64 %569, 2
%588 = getelementptr inbounds double, double* %3, i64 %587
%589 = load double, double* %588
%590 = getelementptr inbounds double, double* %1, i64 %587
%591 = load double, double* %590
%592 = insertelement <2 x double> poison, double %591, i64 0
%593 = insertelement <2 x double> %592, double %589, i64 1
%594 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %593, <2 x double> %593, <2 x double> %586)
%595 = or i64 %569, 3
%596 = getelementptr inbounds double, double* %3, i64 %595
%597 = load double, double* %596
%598 = getelementptr inbounds double, double* %1, i64 %595
%599 = load double, double* %598
%600 = insertelement <2 x double> poison, double %599, i64 0
%601 = insertelement <2 x double> %600, double %597, i64 1
%602 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %601, <2 x double> %601, <2 x double> %594)
%603 = add nuw nsw i64 %569, 4
%604 = add i64 %571, 4
%605 = icmp eq i64 %604, %119
br i1 %605, label %606, label %568
606: ; preds = %568, %502
%607 = phi <2 x double> [ undef, %502 ], [ %602, %568 ]
%608 = phi i64 [ 0, %502 ], [ %603, %568 ]
%609 = phi <2 x double> [ zeroinitializer, %502 ], [ %602, %568 ]
br i1 %120, label %624, label %610
610: ; preds = %606, %610
%611 = phi i64 [ %621, %610 ], [ %608, %606 ]
%612 = phi <2 x double> [ %620, %610 ], [ %609, %606 ]
%613 = phi i64 [ %622, %610 ], [ 0, %606 ]
%614 = getelementptr inbounds double, double* %3, i64 %611
%615 = load double, double* %614
%616 = getelementptr inbounds double, double* %1, i64 %611
%617 = load double, double* %616
%618 = insertelement <2 x double> poison, double %617, i64 0
%619 = insertelement <2 x double> %618, double %615, i64 1
%620 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %619, <2 x double> %619, <2 x double> %612)
%621 = add nuw nsw i64 %611, 1
%622 = add i64 %613, 1
%623 = icmp eq i64 %622, %117
br i1 %623, label %624, label %610
624: ; preds = %610, %606
%625 = phi <2 x double> [ %607, %606 ], [ %620, %610 ]
%626 = extractelement <2 x double> %625, i64 0
%627 = tail call double @llvm.maxnum.f64(double %626, double 1.000000e+00)
%628 = fmul double %32, %627
%629 = extractelement <2 x double> %625, i64 1
%630 = fcmp ugt double %629, %628
br i1 %630, label %632, label %1707
631: ; preds = %501
br i1 %40, label %689, label %1707
632: ; preds = %624
br i1 %31, label %633, label %689
633: ; preds = %632
br i1 %121, label %680, label %634
634: ; preds = %633
%635 = insertelement <2 x double> poison, double %311, i64 0
%636 = shufflevector <2 x double> %635, <2 x double> poison, <2 x i32> zeroinitializer
%637 = insertelement <2 x double> poison, double %311, i64 0
%638 = shufflevector <2 x double> %637, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %124, label %666, label %639
639: ; preds = %634, %639
%640 = phi i64 [ %663, %639 ], [ 0, %634 ]
%641 = phi i64 [ %664, %639 ], [ 0, %634 ]
%642 = getelementptr inbounds double, double* %8, i64 %640
%643 = bitcast double* %642 to <2 x double>*
%644 = load <2 x double>, <2 x double>* %643
%645 = getelementptr inbounds double, double* %642, i64 2
%646 = bitcast double* %645 to <2 x double>*
%647 = load <2 x double>, <2 x double>* %646
%648 = fmul <2 x double> %636, %644
%649 = fmul <2 x double> %638, %647
%650 = bitcast double* %642 to <2 x double>*
store <2 x double> %648, <2 x double>* %650
%651 = bitcast double* %645 to <2 x double>*
store <2 x double> %649, <2 x double>* %651
%652 = or i64 %640, 4
%653 = getelementptr inbounds double, double* %8, i64 %652
%654 = bitcast double* %653 to <2 x double>*
%655 = load <2 x double>, <2 x double>* %654
%656 = getelementptr inbounds double, double* %653, i64 2
%657 = bitcast double* %656 to <2 x double>*
%658 = load <2 x double>, <2 x double>* %657
%659 = fmul <2 x double> %636, %655
%660 = fmul <2 x double> %638, %658
%661 = bitcast double* %653 to <2 x double>*
store <2 x double> %659, <2 x double>* %661
%662 = bitcast double* %656 to <2 x double>*
store <2 x double> %660, <2 x double>* %662
%663 = add nuw i64 %640, 8
%664 = add i64 %641, 2
%665 = icmp eq i64 %664, %125
br i1 %665, label %666, label %639
666: ; preds = %639, %634
%667 = phi i64 [ 0, %634 ], [ %663, %639 ]
br i1 %126, label %679, label %668
668: ; preds = %666
%669 = getelementptr inbounds double, double* %8, i64 %667
%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 = fmul <2 x double> %636, %671
%676 = fmul <2 x double> %638, %674
%677 = bitcast double* %669 to <2 x double>*
store <2 x double> %675, <2 x double>* %677
%678 = bitcast double* %672 to <2 x double>*
store <2 x double> %676, <2 x double>* %678
br label %679
679: ; preds = %666, %668
br i1 %127, label %689, label %680
680: ; preds = %633, %679
%681 = phi i64 [ 0, %633 ], [ %122, %679 ]
br label %682
682: ; preds = %680, %682
%683 = phi i64 [ %687, %682 ], [ %681, %680 ]
%684 = getelementptr inbounds double, double* %8, i64 %683
%685 = load double, double* %684
%686 = fmul double %311, %685
store double %686, double* %684
%687 = add nuw nsw i64 %683, 1
%688 = icmp eq i64 %687, %41
br i1 %688, label %689, label %682
689: ; preds = %682, %679, %631, %632
%690 = phi double [ %629, %632 ], [ 0.000000e+00, %631 ], [ %629, %679 ], [ %629, %682 ]
br i1 %16, label %693, label %691
691: ; preds = %689
br i1 %31, label %692, label %1172
692: ; preds = %691
br i1 %129, label %1156, label %1130
693: ; preds = %689
br i1 %31, label %694, label %746
694: ; preds = %693
br i1 %152, label %729, label %695
695: ; preds = %694, %695
%696 = phi i64 [ %726, %695 ], [ 0, %694 ]
%697 = phi double [ %725, %695 ], [ 0.000000e+00, %694 ]
%698 = phi i64 [ %727, %695 ], [ 0, %694 ]
%699 = add nsw i64 %696, %36
%700 = getelementptr inbounds double, double* %3, i64 %696
%701 = load double, double* %700
%702 = getelementptr inbounds double, double* %8, i64 %699
%703 = load double, double* %702
%704 = tail call double @llvm.fmuladd.f64(double %701, double %703, double %697)
%705 = or i64 %696, 1
%706 = add nsw i64 %705, %36
%707 = getelementptr inbounds double, double* %3, i64 %705
%708 = load double, double* %707
%709 = getelementptr inbounds double, double* %8, i64 %706
%710 = load double, double* %709
%711 = tail call double @llvm.fmuladd.f64(double %708, double %710, double %704)
%712 = or i64 %696, 2
%713 = add nsw i64 %712, %36
%714 = getelementptr inbounds double, double* %3, i64 %712
%715 = load double, double* %714
%716 = getelementptr inbounds double, double* %8, i64 %713
%717 = load double, double* %716
%718 = tail call double @llvm.fmuladd.f64(double %715, double %717, double %711)
%719 = or i64 %696, 3
%720 = add nsw i64 %719, %36
%721 = getelementptr inbounds double, double* %3, i64 %719
%722 = load double, double* %721
%723 = getelementptr inbounds double, double* %8, i64 %720
%724 = load double, double* %723
%725 = tail call double @llvm.fmuladd.f64(double %722, double %724, double %718)
%726 = add nuw nsw i64 %696, 4
%727 = add i64 %698, 4
%728 = icmp eq i64 %727, %153
br i1 %728, label %729, label %695
729: ; preds = %695, %694
%730 = phi double [ undef, %694 ], [ %725, %695 ]
%731 = phi i64 [ 0, %694 ], [ %726, %695 ]
%732 = phi double [ 0.000000e+00, %694 ], [ %725, %695 ]
br i1 %154, label %746, label %733
733: ; preds = %729, %733
%734 = phi i64 [ %743, %733 ], [ %731, %729 ]
%735 = phi double [ %742, %733 ], [ %732, %729 ]
%736 = phi i64 [ %744, %733 ], [ 0, %729 ]
%737 = add nsw i64 %734, %36
%738 = getelementptr inbounds double, double* %3, i64 %734
%739 = load double, double* %738
%740 = getelementptr inbounds double, double* %8, i64 %737
%741 = load double, double* %740
%742 = tail call double @llvm.fmuladd.f64(double %739, double %741, double %735)
%743 = add nuw nsw i64 %734, 1
%744 = add i64 %736, 1
%745 = icmp eq i64 %744, %151
br i1 %745, label %746, label %733
746: ; preds = %729, %733, %693
%747 = phi double [ 0.000000e+00, %693 ], [ %730, %729 ], [ %742, %733 ]
%748 = fdiv double %747, %690
%749 = tail call double @llvm.fabs.f64(double %748)
%750 = fcmp ogt double %749, 2.000000e-01
%751 = select i1 %750, i32 %0, i32 %224
%752 = icmp eq i32 %751, %0
br i1 %752, label %753, label %779
753: ; preds = %746
%754 = sext i32 %240 to i64
%755 = getelementptr inbounds double, double* %8, i64 %754
store double 0.000000e+00, double* %755
store double 0.000000e+00, double* %34
br i1 %31, label %756, label %780
756: ; preds = %753, %756
%757 = phi i64 [ %777, %756 ], [ 0, %753 ]
%758 = add nsw i64 %757, %26
%759 = add nsw i64 %757, %27
%760 = add nsw i64 %757, %36
%761 = getelementptr inbounds double, double* %3, i64 %757
%762 = load double, double* %761
%763 = getelementptr inbounds double, double* %8, i64 %760
%764 = load double, double* %763
%765 = fsub double %762, %764
%766 = getelementptr inbounds double, double* %8, i64 %759
store double %765, double* %766
%767 = getelementptr inbounds double, double* %8, i64 %757
%768 = load double, double* %767
%769 = getelementptr inbounds double, double* %8, i64 %758
store double %768, double* %769
%770 = load double, double* %766
%771 = load double, double* %755
%772 = tail call double @llvm.fmuladd.f64(double %770, double %770, double %771)
store double %772, double* %755
%773 = load double, double* %767
%774 = load double, double* %766
%775 = load double, double* %34
%776 = tail call double @llvm.fmuladd.f64(double %773, double %774, double %775)
store double %776, double* %34
%777 = add nuw nsw i64 %757, 1
%778 = icmp eq i64 %777, %47
br i1 %778, label %779, label %756
779: ; preds = %756, %746
br i1 %31, label %783, label %780
780: ; preds = %779, %753
%781 = sext i32 %240 to i64
%782 = getelementptr inbounds double, double* %8, i64 %781
br label %894
783: ; preds = %779
%784 = sext i32 %240 to i64
%785 = getelementptr inbounds double, double* %8, i64 %784
%786 = load double, double* %785
%787 = load double, double* %34
%788 = insertelement <2 x double> poison, double %787, i64 0
%789 = insertelement <2 x double> %788, double %786, i64 1
br label %790
790: ; preds = %783, %790
%791 = phi i64 [ 0, %783 ], [ %814, %790 ]
%792 = phi double [ 0.000000e+00, %783 ], [ %813, %790 ]
%793 = phi double [ 0.000000e+00, %783 ], [ %802, %790 ]
%794 = add nsw i64 %791, %26
%795 = add nsw i64 %791, %27
%796 = getelementptr inbounds double, double* %8, i64 %794
%797 = load double, double* %796
%798 = getelementptr inbounds double, double* %3, i64 %791
%799 = load double, double* %798
%800 = fmul double %797, %799
%801 = fdiv double %800, %786
%802 = fsub double %793, %801
%803 = getelementptr inbounds double, double* %8, i64 %795
%804 = load double, double* %803
%805 = insertelement <2 x double> poison, double %800, i64 0
%806 = insertelement <2 x double> %805, double %799, i64 1
%807 = insertelement <2 x double> <double 2.000000e+00, double poison>, double %804, i64 1
%808 = fmul <2 x double> %806, %807
%809 = fdiv <2 x double> %808, %789
%810 = shufflevector <2 x double> %809, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%811 = fsub <2 x double> %809, %810
%812 = extractelement <2 x double> %811, i64 0
%813 = fadd double %792, %812
%814 = add nuw nsw i64 %791, 1
%815 = icmp eq i64 %814, %48
br i1 %815, label %816, label %790
816: ; preds = %790
%817 = getelementptr inbounds double, double* %8, i64 %784
br i1 %31, label %818, label %894
818: ; preds = %816
%819 = load double, double* %817
%820 = load double, double* %34
%821 = fneg double %820
%822 = fdiv double %821, %819
%823 = fneg double %802
%824 = fneg double %813
%825 = select i1 %155, i1 true, i1 %166
br i1 %825, label %875, label %826
826: ; preds = %818
%827 = insertelement <2 x double> poison, double %823, i64 0
%828 = shufflevector <2 x double> %827, <2 x double> poison, <2 x i32> zeroinitializer
%829 = insertelement <2 x double> poison, double %823, i64 0
%830 = shufflevector <2 x double> %829, <2 x double> poison, <2 x i32> zeroinitializer
%831 = insertelement <2 x double> poison, double %822, i64 0
%832 = shufflevector <2 x double> %831, <2 x double> poison, <2 x i32> zeroinitializer
%833 = insertelement <2 x double> poison, double %822, i64 0
%834 = shufflevector <2 x double> %833, <2 x double> poison, <2 x i32> zeroinitializer
%835 = insertelement <2 x double> poison, double %824, i64 0
%836 = shufflevector <2 x double> %835, <2 x double> poison, <2 x i32> zeroinitializer
%837 = insertelement <2 x double> poison, double %824, i64 0
%838 = shufflevector <2 x double> %837, <2 x double> poison, <2 x i32> zeroinitializer
br label %839
839: ; preds = %839, %826
%840 = phi i64 [ 0, %826 ], [ %872, %839 ]
%841 = add nsw i64 %840, %35
%842 = add nsw i64 %840, %26
%843 = add nsw i64 %840, %27
%844 = getelementptr inbounds double, double* %3, i64 %840
%845 = bitcast double* %844 to <2 x double>*
%846 = load <2 x double>, <2 x double>* %845
%847 = getelementptr inbounds double, double* %844, i64 2
%848 = bitcast double* %847 to <2 x double>*
%849 = load <2 x double>, <2 x double>* %848
%850 = getelementptr inbounds double, double* %8, i64 %843
%851 = bitcast double* %850 to <2 x double>*
%852 = load <2 x double>, <2 x double>* %851
%853 = getelementptr inbounds double, double* %850, i64 2
%854 = bitcast double* %853 to <2 x double>*
%855 = load <2 x double>, <2 x double>* %854
%856 = fmul <2 x double> %852, %828
%857 = fmul <2 x double> %855, %830
%858 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %832, <2 x double> %846, <2 x double> %856)
%859 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %834, <2 x double> %849, <2 x double> %857)
%860 = getelementptr inbounds double, double* %8, i64 %842
%861 = bitcast double* %860 to <2 x double>*
%862 = load <2 x double>, <2 x double>* %861
%863 = getelementptr inbounds double, double* %860, i64 2
%864 = bitcast double* %863 to <2 x double>*
%865 = load <2 x double>, <2 x double>* %864
%866 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %836, <2 x double> %862, <2 x double> %858)
%867 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %838, <2 x double> %865, <2 x double> %859)
%868 = getelementptr inbounds double, double* %8, i64 %841
%869 = bitcast double* %868 to <2 x double>*
store <2 x double> %866, <2 x double>* %869
%870 = getelementptr inbounds double, double* %868, i64 2
%871 = bitcast double* %870 to <2 x double>*
store <2 x double> %867, <2 x double>* %871
%872 = add nuw i64 %840, 4
%873 = icmp eq i64 %872, %167
br i1 %873, label %874, label %839
874: ; preds = %839
br i1 %168, label %894, label %875
875: ; preds = %818, %874
%876 = phi i64 [ 0, %818 ], [ %167, %874 ]
br label %877
877: ; preds = %875, %877
%878 = phi i64 [ %892, %877 ], [ %876, %875 ]
%879 = add nsw i64 %878, %35
%880 = add nsw i64 %878, %26
%881 = add nsw i64 %878, %27
%882 = getelementptr inbounds double, double* %3, i64 %878
%883 = load double, double* %882
%884 = getelementptr inbounds double, double* %8, i64 %881
%885 = load double, double* %884
%886 = fmul double %885, %823
%887 = tail call double @llvm.fmuladd.f64(double %822, double %883, double %886)
%888 = getelementptr inbounds double, double* %8, i64 %880
%889 = load double, double* %888
%890 = tail call double @llvm.fmuladd.f64(double %824, double %889, double %887)
%891 = getelementptr inbounds double, double* %8, i64 %879
store double %890, double* %891
%892 = add nuw nsw i64 %878, 1
%893 = icmp eq i64 %892, %49
br i1 %893, label %894, label %877
894: ; preds = %877, %874, %780, %816
%895 = phi double* [ %782, %780 ], [ %817, %816 ], [ %817, %874 ], [ %817, %877 ]
br i1 %752, label %1087, label %896
896: ; preds = %894
br i1 %31, label %897, label %1126
897: ; preds = %896
%898 = load double, double* %895
%899 = load double, double* %34
%900 = insertelement <2 x double> poison, double %898, i64 0
%901 = insertelement <2 x double> %900, double %899, i64 1
br label %903
902: ; preds = %903
br i1 %31, label %945, label %1126
903: ; preds = %897, %903
%904 = phi i64 [ 0, %897 ], [ %937, %903 ]
%905 = phi double [ 0.000000e+00, %897 ], [ %936, %903 ]
%906 = phi double [ 0.000000e+00, %897 ], [ %933, %903 ]
%907 = phi double [ 0.000000e+00, %897 ], [ %920, %903 ]
%908 = add nsw i64 %904, %36
%909 = add nsw i64 %904, %26
%910 = add nsw i64 %904, %27
%911 = getelementptr inbounds double, double* %3, i64 %904
%912 = load double, double* %911
%913 = getelementptr inbounds double, double* %8, i64 %908
%914 = load double, double* %913
%915 = fsub double %912, %914
%916 = getelementptr inbounds double, double* %8, i64 %909
%917 = load double, double* %916
%918 = fmul double %915, %917
%919 = fdiv double %918, %898
%920 = fsub double %907, %919
%921 = getelementptr inbounds double, double* %8, i64 %910
%922 = load double, double* %921
%923 = fmul double %917, 2.000000e+00
%924 = insertelement <2 x double> poison, double %915, i64 0
%925 = shufflevector <2 x double> %924, <2 x double> poison, <2 x i32> zeroinitializer
%926 = insertelement <2 x double> poison, double %922, i64 0
%927 = insertelement <2 x double> %926, double %923, i64 1
%928 = fmul <2 x double> %925, %927
%929 = fdiv <2 x double> %928, %901
%930 = shufflevector <2 x double> %929, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%931 = fadd <2 x double> %929, %930
%932 = extractelement <2 x double> %931, i64 0
%933 = fsub double %906, %932
%934 = getelementptr inbounds double, double* %8, i64 %904
%935 = load double, double* %934
%936 = tail call double @llvm.fmuladd.f64(double %935, double %915, double %905)
%937 = add nuw nsw i64 %904, 1
%938 = icmp eq i64 %937, %50
br i1 %938, label %902, label %903
939: ; preds = %945
br i1 %31, label %940, label %1126
940: ; preds = %939
%941 = fdiv double %966, %936
%942 = fadd double %941, 1.000000e+00
%943 = insertelement <2 x double> poison, double %936, i64 0
%944 = shufflevector <2 x double> %943, <2 x double> poison, <2 x i32> zeroinitializer
br label %1033
945: ; preds = %902, %945
%946 = phi i64 [ %967, %945 ], [ 0, %902 ]
%947 = phi double [ %966, %945 ], [ 0.000000e+00, %902 ]
%948 = add nsw i64 %946, %36
%949 = add nsw i64 %946, %26
%950 = add nsw i64 %946, %27
%951 = load double, double* %34
%952 = load double, double* %895
%953 = fdiv double %951, %952
%954 = getelementptr inbounds double, double* %3, i64 %946
%955 = load double, double* %954
%956 = getelementptr inbounds double, double* %8, i64 %948
%957 = load double, double* %956
%958 = fsub double %955, %957
%959 = getelementptr inbounds double, double* %8, i64 %950
%960 = load double, double* %959
%961 = fmul double %920, %960
%962 = tail call double @llvm.fmuladd.f64(double %953, double %958, double %961)
%963 = getelementptr inbounds double, double* %8, i64 %949
%964 = load double, double* %963
%965 = tail call double @llvm.fmuladd.f64(double %933, double %964, double %962)
%966 = tail call double @llvm.fmuladd.f64(double %965, double %958, double %947)
store double %965, double* %956
%967 = add nuw nsw i64 %946, 1
%968 = icmp eq i64 %967, %51
br i1 %968, label %939, label %945
969: ; preds = %1033
br i1 %31, label %970, label %1126
970: ; preds = %969
%971 = select i1 %169, i1 true, i1 %176
br i1 %971, label %1014, label %972
972: ; preds = %970
%973 = insertelement <2 x double> poison, double %1057, i64 0
%974 = shufflevector <2 x double> %973, <2 x double> poison, <2 x i32> zeroinitializer
%975 = insertelement <2 x double> poison, double %1057, i64 0
%976 = shufflevector <2 x double> %975, <2 x double> poison, <2 x i32> zeroinitializer
%977 = insertelement <2 x double> poison, double %1043, i64 0
%978 = shufflevector <2 x double> %977, <2 x double> poison, <2 x i32> zeroinitializer
%979 = insertelement <2 x double> poison, double %1043, i64 0
%980 = shufflevector <2 x double> %979, <2 x double> poison, <2 x i32> zeroinitializer
br label %981
981: ; preds = %981, %972
%982 = phi i64 [ 0, %972 ], [ %1011, %981 ]
%983 = add nsw i64 %982, %36
%984 = add nsw i64 %982, %35
%985 = getelementptr inbounds double, double* %8, i64 %983
%986 = bitcast double* %985 to <2 x double>*
%987 = load <2 x double>, <2 x double>* %986
%988 = getelementptr inbounds double, double* %985, i64 2
%989 = bitcast double* %988 to <2 x double>*
%990 = load <2 x double>, <2 x double>* %989
%991 = getelementptr inbounds double, double* %8, i64 %982
%992 = bitcast double* %991 to <2 x double>*
%993 = load <2 x double>, <2 x double>* %992
%994 = getelementptr inbounds double, double* %991, i64 2
%995 = bitcast double* %994 to <2 x double>*
%996 = load <2 x double>, <2 x double>* %995
%997 = fmul <2 x double> %974, %993
%998 = fmul <2 x double> %976, %996
%999 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %978, <2 x double> %987, <2 x double> %997)
%1000 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %980, <2 x double> %990, <2 x double> %998)
%1001 = getelementptr inbounds double, double* %8, i64 %984
%1002 = bitcast double* %1001 to <2 x double>*
%1003 = load <2 x double>, <2 x double>* %1002
%1004 = getelementptr inbounds double, double* %1001, i64 2
%1005 = bitcast double* %1004 to <2 x double>*
%1006 = load <2 x double>, <2 x double>* %1005
%1007 = fsub <2 x double> %1003, %999
%1008 = fsub <2 x double> %1006, %1000
%1009 = bitcast double* %1001 to <2 x double>*
store <2 x double> %1007, <2 x double>* %1009
%1010 = bitcast double* %1004 to <2 x double>*
store <2 x double> %1008, <2 x double>* %1010
%1011 = add nuw i64 %982, 4
%1012 = icmp eq i64 %1011, %177
br i1 %1012, label %1013, label %981
1013: ; preds = %981
br i1 %178, label %1087, label %1014
1014: ; preds = %970, %1013
%1015 = phi i64 [ 0, %970 ], [ %177, %1013 ]
%1016 = xor i64 %1015, -1
br i1 %180, label %1030, label %1017
1017: ; preds = %1014
%1018 = add nsw i64 %1015, %36
%1019 = add nsw i64 %1015, %35
%1020 = getelementptr inbounds double, double* %8, i64 %1018
%1021 = load double, double* %1020
%1022 = getelementptr inbounds double, double* %8, i64 %1015
%1023 = load double, double* %1022
%1024 = fmul double %1057, %1023
%1025 = tail call double @llvm.fmuladd.f64(double %1043, double %1021, double %1024)
%1026 = getelementptr inbounds double, double* %8, i64 %1019
%1027 = load double, double* %1026
%1028 = fsub double %1027, %1025
store double %1028, double* %1026
%1029 = or i64 %1015, 1
br label %1030
1030: ; preds = %1017, %1014
%1031 = phi i64 [ %1015, %1014 ], [ %1029, %1017 ]
%1032 = icmp eq i64 %1016, %181
br i1 %1032, label %1087, label %1060
1033: ; preds = %940, %1033
%1034 = phi i64 [ 0, %940 ], [ %1058, %1033 ]
%1035 = phi double [ 0.000000e+00, %940 ], [ %1057, %1033 ]
%1036 = phi double [ 0.000000e+00, %940 ], [ %1043, %1033 ]
%1037 = getelementptr inbounds double, double* %8, i64 %1034
%1038 = load double, double* %1037
%1039 = getelementptr inbounds double, double* %3, i64 %1034
%1040 = load double, double* %1039
%1041 = fmul double %1038, %1040
%1042 = fdiv double %1041, %936
%1043 = fsub double %1036, %1042
%1044 = add nsw i64 %1034, %36
%1045 = fmul double %942, %1038
%1046 = getelementptr inbounds double, double* %8, i64 %1044
%1047 = load double, double* %1046
%1048 = insertelement <2 x double> poison, double %1045, i64 0
%1049 = insertelement <2 x double> %1048, double %1047, i64 1
%1050 = insertelement <2 x double> poison, double %1040, i64 0
%1051 = shufflevector <2 x double> %1050, <2 x double> poison, <2 x i32> zeroinitializer
%1052 = fmul <2 x double> %1049, %1051
%1053 = fdiv <2 x double> %1052, %944
%1054 = shufflevector <2 x double> %1053, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%1055 = fsub <2 x double> %1053, %1054
%1056 = extractelement <2 x double> %1055, i64 0
%1057 = fadd double %1035, %1056
%1058 = add nuw nsw i64 %1034, 1
%1059 = icmp eq i64 %1058, %52
br i1 %1059, label %969, label %1033
1060: ; preds = %1030, %1060
%1061 = phi i64 [ %1085, %1060 ], [ %1031, %1030 ]
%1062 = add nsw i64 %1061, %36
%1063 = add nsw i64 %1061, %35
%1064 = getelementptr inbounds double, double* %8, i64 %1062
%1065 = load double, double* %1064
%1066 = getelementptr inbounds double, double* %8, i64 %1061
%1067 = load double, double* %1066
%1068 = fmul double %1057, %1067
%1069 = tail call double @llvm.fmuladd.f64(double %1043, double %1065, double %1068)
%1070 = getelementptr inbounds double, double* %8, i64 %1063
%1071 = load double, double* %1070
%1072 = fsub double %1071, %1069
store double %1072, double* %1070
%1073 = add nuw nsw i64 %1061, 1
%1074 = add nsw i64 %1073, %36
%1075 = add nsw i64 %1073, %35
%1076 = getelementptr inbounds double, double* %8, i64 %1074
%1077 = load double, double* %1076
%1078 = getelementptr inbounds double, double* %8, i64 %1073
%1079 = load double, double* %1078
%1080 = fmul double %1057, %1079
%1081 = tail call double @llvm.fmuladd.f64(double %1043, double %1077, double %1080)
%1082 = getelementptr inbounds double, double* %8, i64 %1075
%1083 = load double, double* %1082
%1084 = fsub double %1083, %1081
store double %1084, double* %1082
%1085 = add nuw nsw i64 %1061, 2
%1086 = icmp eq i64 %1085, %53
br i1 %1086, label %1087, label %1060
1087: ; preds = %1030, %1060, %1013, %894
br i1 %31, label %1088, label %1126
1088: ; preds = %1087
br i1 %183, label %1111, label %1089
1089: ; preds = %1088, %1089
%1090 = phi i64 [ %1108, %1089 ], [ 0, %1088 ]
%1091 = phi double [ %1107, %1089 ], [ 0.000000e+00, %1088 ]
%1092 = phi i64 [ %1109, %1089 ], [ 0, %1088 ]
%1093 = add nsw i64 %1090, %35
%1094 = getelementptr inbounds double, double* %8, i64 %1093
%1095 = load double, double* %1094
%1096 = getelementptr inbounds double, double* %8, i64 %1090
store double %1095, double* %1096
%1097 = getelementptr inbounds double, double* %3, i64 %1090
%1098 = load double, double* %1097
%1099 = tail call double @llvm.fmuladd.f64(double %1095, double %1098, double %1091)
%1100 = or i64 %1090, 1
%1101 = add nsw i64 %1100, %35
%1102 = getelementptr inbounds double, double* %8, i64 %1101
%1103 = load double, double* %1102
%1104 = getelementptr inbounds double, double* %8, i64 %1100
store double %1103, double* %1104
%1105 = getelementptr inbounds double, double* %3, i64 %1100
%1106 = load double, double* %1105
%1107 = tail call double @llvm.fmuladd.f64(double %1103, double %1106, double %1099)
%1108 = add nuw nsw i64 %1090, 2
%1109 = add i64 %1092, 2
%1110 = icmp eq i64 %1109, %184
br i1 %1110, label %1111, label %1089
1111: ; preds = %1089, %1088
%1112 = phi double [ undef, %1088 ], [ %1107, %1089 ]
%1113 = phi i64 [ 0, %1088 ], [ %1108, %1089 ]
%1114 = phi double [ 0.000000e+00, %1088 ], [ %1107, %1089 ]
br i1 %185, label %1123, label %1115
1115: ; preds = %1111
%1116 = add nsw i64 %1113, %35
%1117 = getelementptr inbounds double, double* %8, i64 %1116
%1118 = load double, double* %1117
%1119 = getelementptr inbounds double, double* %8, i64 %1113
store double %1118, double* %1119
%1120 = getelementptr inbounds double, double* %3, i64 %1113
%1121 = load double, double* %1120
%1122 = tail call double @llvm.fmuladd.f64(double %1118, double %1121, double %1114)
br label %1123
1123: ; preds = %1111, %1115
%1124 = phi double [ %1112, %1111 ], [ %1122, %1115 ]
%1125 = fcmp ogt double %1124, 0.000000e+00
br i1 %1125, label %1707, label %1126
1126: ; preds = %896, %902, %939, %969, %1087, %1123
%1127 = phi double [ %1124, %1123 ], [ 0.000000e+00, %1087 ], [ 0.000000e+00, %969 ], [ 0.000000e+00, %939 ], [ 0.000000e+00, %902 ], [ 0.000000e+00, %896 ]
%1128 = add nsw i32 %751, 1
%1129 = select i1 %752, i32 1, i32 %1128
br label %220
1130: ; preds = %692, %1130
%1131 = phi i64 [ %1153, %1130 ], [ 0, %692 ]
%1132 = phi double [ %1152, %1130 ], [ 0.000000e+00, %692 ]
%1133 = phi i64 [ %1154, %1130 ], [ 0, %692 ]
%1134 = add nsw i64 %1131, %36
%1135 = getelementptr inbounds double, double* %3, i64 %1131
%1136 = load double, double* %1135
%1137 = getelementptr inbounds double, double* %8, i64 %1134
%1138 = load double, double* %1137
%1139 = fsub double %1136, %1138
store double %1139, double* %1137
%1140 = getelementptr inbounds double, double* %8, i64 %1131
%1141 = load double, double* %1140
%1142 = tail call double @llvm.fmuladd.f64(double %1141, double %1139, double %1132)
%1143 = or i64 %1131, 1
%1144 = add nsw i64 %1143, %36
%1145 = getelementptr inbounds double, double* %3, i64 %1143
%1146 = load double, double* %1145
%1147 = getelementptr inbounds double, double* %8, i64 %1144
%1148 = load double, double* %1147
%1149 = fsub double %1146, %1148
store double %1149, double* %1147
%1150 = getelementptr inbounds double, double* %8, i64 %1143
%1151 = load double, double* %1150
%1152 = tail call double @llvm.fmuladd.f64(double %1151, double %1149, double %1142)
%1153 = add nuw nsw i64 %1131, 2
%1154 = add i64 %1133, 2
%1155 = icmp eq i64 %1154, %130
br i1 %1155, label %1156, label %1130
1156: ; preds = %1130, %692
%1157 = phi double [ undef, %692 ], [ %1152, %1130 ]
%1158 = phi i64 [ 0, %692 ], [ %1153, %1130 ]
%1159 = phi double [ 0.000000e+00, %692 ], [ %1152, %1130 ]
br i1 %131, label %1170, label %1160
1160: ; preds = %1156
%1161 = add nsw i64 %1158, %36
%1162 = getelementptr inbounds double, double* %3, i64 %1158
%1163 = load double, double* %1162
%1164 = getelementptr inbounds double, double* %8, i64 %1161
%1165 = load double, double* %1164
%1166 = fsub double %1163, %1165
store double %1166, double* %1164
%1167 = getelementptr inbounds double, double* %8, i64 %1158
%1168 = load double, double* %1167
%1169 = tail call double @llvm.fmuladd.f64(double %1168, double %1166, double %1159)
br label %1170
1170: ; preds = %1156, %1160
%1171 = phi double [ %1157, %1156 ], [ %1169, %1160 ]
br i1 %243, label %1175, label %1174
1172: ; preds = %691
br i1 %243, label %1203, label %1173
1173: ; preds = %1172, %1174
br label %241
1174: ; preds = %1170
br i1 %31, label %1286, label %1173
1175: ; preds = %1170
br i1 %31, label %1176, label %1203
1176: ; preds = %1175
br i1 %133, label %1206, label %1177
1177: ; preds = %1176, %1177
%1178 = phi i64 [ %1200, %1177 ], [ 0, %1176 ]
%1179 = phi double [ %1199, %1177 ], [ 0.000000e+00, %1176 ]
%1180 = phi i64 [ %1201, %1177 ], [ 0, %1176 ]
%1181 = add nsw i64 %1178, %36
%1182 = getelementptr inbounds double, double* %8, i64 %1181
%1183 = load double, double* %1182
%1184 = tail call double @llvm.fmuladd.f64(double %1183, double %1183, double %1179)
%1185 = or i64 %1178, 1
%1186 = add nsw i64 %1185, %36
%1187 = getelementptr inbounds double, double* %8, i64 %1186
%1188 = load double, double* %1187
%1189 = tail call double @llvm.fmuladd.f64(double %1188, double %1188, double %1184)
%1190 = or i64 %1178, 2
%1191 = add nsw i64 %1190, %36
%1192 = getelementptr inbounds double, double* %8, i64 %1191
%1193 = load double, double* %1192
%1194 = tail call double @llvm.fmuladd.f64(double %1193, double %1193, double %1189)
%1195 = or i64 %1178, 3
%1196 = add nsw i64 %1195, %36
%1197 = getelementptr inbounds double, double* %8, i64 %1196
%1198 = load double, double* %1197
%1199 = tail call double @llvm.fmuladd.f64(double %1198, double %1198, double %1194)
%1200 = add nuw nsw i64 %1178, 4
%1201 = add i64 %1180, 4
%1202 = icmp eq i64 %1201, %134
br i1 %1202, label %1206, label %1177
1203: ; preds = %1172, %1175
%1204 = phi double [ %1171, %1175 ], [ 0.000000e+00, %1172 ]
%1205 = fdiv double %1204, 0.000000e+00
br label %1280
1206: ; preds = %1177, %1176
%1207 = phi double [ undef, %1176 ], [ %1199, %1177 ]
%1208 = phi i64 [ 0, %1176 ], [ %1200, %1177 ]
%1209 = phi double [ 0.000000e+00, %1176 ], [ %1199, %1177 ]
br i1 %135, label %1221, label %1210
1210: ; preds = %1206, %1210
%1211 = phi i64 [ %1218, %1210 ], [ %1208, %1206 ]
%1212 = phi double [ %1217, %1210 ], [ %1209, %1206 ]
%1213 = phi i64 [ %1219, %1210 ], [ 0, %1206 ]
%1214 = add nsw i64 %1211, %36
%1215 = getelementptr inbounds double, double* %8, i64 %1214
%1216 = load double, double* %1215
%1217 = tail call double @llvm.fmuladd.f64(double %1216, double %1216, double %1212)
%1218 = add nuw nsw i64 %1211, 1
%1219 = add i64 %1213, 1
%1220 = icmp eq i64 %1219, %132
br i1 %1220, label %1221, label %1210
1221: ; preds = %1210, %1206
%1222 = phi double [ %1207, %1206 ], [ %1217, %1210 ]
%1223 = fdiv double %1171, %1222
br i1 %31, label %1224, label %1280
1224: ; preds = %1221, %1267
%1225 = phi i64 [ %1276, %1267 ], [ 0, %1221 ]
%1226 = phi i64 [ %1269, %1267 ], [ 0, %1221 ]
%1227 = trunc i64 %1225 to i32
%1228 = sub i32 %0, %1227
%1229 = trunc i64 %1225 to i32
%1230 = xor i32 %1229, -1
%1231 = shl i64 %1226, 32
%1232 = ashr exact i64 %1231, 32
%1233 = trunc i64 %1225 to i32
%1234 = and i32 %1228, 1
%1235 = icmp eq i32 %1234, 0
br i1 %1235, label %1243, label %1236
1236: ; preds = %1224
%1237 = add nsw i64 %1232, %37
%1238 = getelementptr inbounds double, double* %8, i64 %1237
%1239 = icmp ult i64 %1225, 4294967296
%1240 = select i1 %1239, double %1223, double 0.000000e+00
store double %1240, double* %1238
%1241 = add nsw i64 %1232, 1
%1242 = add nuw nsw i32 %1233, 1
br label %1243
1243: ; preds = %1236, %1224
%1244 = phi i64 [ undef, %1224 ], [ %1237, %1236 ]
%1245 = phi i64 [ undef, %1224 ], [ %1241, %1236 ]
%1246 = phi i64 [ %1232, %1224 ], [ %1241, %1236 ]
%1247 = phi i32 [ %1233, %1224 ], [ %1242, %1236 ]
%1248 = icmp eq i32 %1230, %136
br i1 %1248, label %1267, label %1249
1249: ; preds = %1243, %1249
%1250 = phi i64 [ %1264, %1249 ], [ %1246, %1243 ]
%1251 = phi i32 [ %1265, %1249 ], [ %1247, %1243 ]
%1252 = add nsw i64 %1250, %37
%1253 = getelementptr inbounds double, double* %8, i64 %1252
%1254 = zext i32 %1251 to i64
%1255 = icmp eq i64 %1225, %1254
%1256 = select i1 %1255, double %1223, double 0.000000e+00
store double %1256, double* %1253
%1257 = add nsw i64 %1250, 1
%1258 = add nuw nsw i32 %1251, 1
%1259 = add nsw i64 %1257, %37
%1260 = getelementptr inbounds double, double* %8, i64 %1259
%1261 = zext i32 %1258 to i64
%1262 = icmp eq i64 %1225, %1261
%1263 = select i1 %1262, double %1223, double 0.000000e+00
store double %1263, double* %1260
%1264 = add nsw i64 %1250, 2
%1265 = add nuw nsw i32 %1251, 2
%1266 = icmp eq i32 %1265, %0
br i1 %1266, label %1267, label %1249
1267: ; preds = %1249, %1243
%1268 = phi i64 [ %1244, %1243 ], [ %1259, %1249 ]
%1269 = phi i64 [ %1245, %1243 ], [ %1264, %1249 ]
%1270 = add nsw i64 %1225, %35
%1271 = add nsw i64 %1225, %36
%1272 = getelementptr inbounds double, double* %8, i64 %1271
%1273 = load double, double* %1272
%1274 = fmul double %1223, %1273
%1275 = getelementptr inbounds double, double* %8, i64 %1270
store double %1274, double* %1275
%1276 = add nuw nsw i64 %1225, 1
%1277 = icmp eq i64 %1276, %43
br i1 %1277, label %1278, label %1224
1278: ; preds = %1267
%1279 = trunc i64 %1268 to i32
br label %1280
1280: ; preds = %1278, %1203, %1221
%1281 = phi double [ %1223, %1221 ], [ %1205, %1203 ], [ %1223, %1278 ]
%1282 = phi double [ %1222, %1221 ], [ 0.000000e+00, %1203 ], [ %1222, %1278 ]
%1283 = phi double [ %1171, %1221 ], [ %1204, %1203 ], [ %1171, %1278 ]
%1284 = phi i32 [ %240, %1221 ], [ %240, %1203 ], [ %1279, %1278 ]
%1285 = fmul double %1282, %1281
br label %1378
1286: ; preds = %1174, %1367
%1287 = phi i64 [ %1374, %1367 ], [ 0, %1174 ]
%1288 = phi double [ %1371, %1367 ], [ 0.000000e+00, %1174 ]
%1289 = icmp eq i64 %1287, 0
br i1 %1289, label %1349, label %1290
1290: ; preds = %1286
%1291 = trunc i64 %1287 to i32
%1292 = and i64 %1287, 1
%1293 = icmp eq i64 %1287, 1
br i1 %1293, label %1329, label %1294
1294: ; preds = %1290
%1295 = and i64 %1287, 9223372036854775806
br label %1296
1296: ; preds = %1296, %1294
%1297 = phi i64 [ 0, %1294 ], [ %1326, %1296 ]
%1298 = phi double [ 0.000000e+00, %1294 ], [ %1321, %1296 ]
%1299 = phi i32 [ %1291, %1294 ], [ %1325, %1296 ]
%1300 = phi i64 [ 0, %1294 ], [ %1327, %1296 ]
%1301 = add nsw i64 %1297, %36
%1302 = add nsw i32 %1299, %28
%1303 = sext i32 %1302 to i64
%1304 = getelementptr inbounds double, double* %8, i64 %1303
%1305 = load double, double* %1304
%1306 = getelementptr inbounds double, double* %8, i64 %1301
%1307 = load double, double* %1306
%1308 = tail call double @llvm.fmuladd.f64(double %1305, double %1307, double %1298)
%1309 = add i32 %1299, %0
%1310 = trunc i64 %1297 to i32
%1311 = xor i32 %1310, -1
%1312 = add i32 %1309, %1311
%1313 = or i64 %1297, 1
%1314 = add nsw i64 %1313, %36
%1315 = add nsw i32 %1312, %28
%1316 = sext i32 %1315 to i64
%1317 = getelementptr inbounds double, double* %8, i64 %1316
%1318 = load double, double* %1317
%1319 = getelementptr inbounds double, double* %8, i64 %1314
%1320 = load double, double* %1319
%1321 = tail call double @llvm.fmuladd.f64(double %1318, double %1320, double %1308)
%1322 = add i32 %1312, %0
%1323 = trunc i64 %1313 to i32
%1324 = xor i32 %1323, -1
%1325 = add i32 %1322, %1324
%1326 = add nuw nsw i64 %1297, 2
%1327 = add i64 %1300, 2
%1328 = icmp eq i64 %1327, %1295
br i1 %1328, label %1329, label %1296
1329: ; preds = %1296, %1290
%1330 = phi double [ undef, %1290 ], [ %1321, %1296 ]
%1331 = phi i32 [ undef, %1290 ], [ %1325, %1296 ]
%1332 = phi i64 [ 0, %1290 ], [ %1326, %1296 ]
%1333 = phi double [ 0.000000e+00, %1290 ], [ %1321, %1296 ]
%1334 = phi i32 [ %1291, %1290 ], [ %1325, %1296 ]
%1335 = icmp eq i64 %1292, 0
br i1 %1335, label %1349, label %1336
1336: ; preds = %1329
%1337 = add nsw i64 %1332, %36
%1338 = add nsw i32 %1334, %28
%1339 = sext i32 %1338 to i64
%1340 = getelementptr inbounds double, double* %8, i64 %1339
%1341 = load double, double* %1340
%1342 = getelementptr inbounds double, double* %8, i64 %1337
%1343 = load double, double* %1342
%1344 = tail call double @llvm.fmuladd.f64(double %1341, double %1343, double %1333)
%1345 = add i32 %1334, %0
%1346 = trunc i64 %1332 to i32
%1347 = xor i32 %1346, -1
%1348 = add i32 %1345, %1347
br label %1349
1349: ; preds = %1336, %1329, %1286
%1350 = phi i32 [ 0, %1286 ], [ %1331, %1329 ], [ %1348, %1336 ]
%1351 = phi double [ 0.000000e+00, %1286 ], [ %1330, %1329 ], [ %1344, %1336 ]
%1352 = sext i32 %1350 to i64
br label %1353
1353: ; preds = %1349, %1353
%1354 = phi i64 [ %1352, %1349 ], [ %1364, %1353 ]
%1355 = phi i64 [ %1287, %1349 ], [ %1365, %1353 ]
%1356 = phi double [ %1351, %1349 ], [ %1363, %1353 ]
%1357 = add nsw i64 %1354, %37
%1358 = add nsw i64 %1355, %36
%1359 = getelementptr inbounds double, double* %8, i64 %1357
%1360 = load double, double* %1359
%1361 = getelementptr inbounds double, double* %8, i64 %1358
%1362 = load double, double* %1361
%1363 = tail call double @llvm.fmuladd.f64(double %1360, double %1362, double %1356)
%1364 = add nsw i64 %1354, 1
%1365 = add nuw nsw i64 %1355, 1
%1366 = icmp eq i64 %1365, %42
br i1 %1366, label %1367, label %1353
1367: ; preds = %1353
%1368 = add nsw i64 %1287, %36
%1369 = getelementptr inbounds double, double* %8, i64 %1368
%1370 = load double, double* %1369
%1371 = tail call double @llvm.fmuladd.f64(double %1363, double %1370, double %1288)
%1372 = add nsw i64 %1287, %35
%1373 = getelementptr inbounds double, double* %8, i64 %1372
store double %1363, double* %1373
%1374 = add nuw nsw i64 %1287, 1
%1375 = icmp eq i64 %1374, %42
br i1 %1375, label %1376, label %1286
1376: ; preds = %1367
%1377 = trunc i64 %1357 to i32
br label %1378
1378: ; preds = %1376, %1280
%1379 = phi double [ %1283, %1280 ], [ %1171, %1376 ]
%1380 = phi double [ %1285, %1280 ], [ %1371, %1376 ]
%1381 = phi i32 [ %1284, %1280 ], [ %1377, %1376 ]
%1382 = fdiv double %1380, %1379
%1383 = fadd double %1382, 1.000000e+00
br i1 %31, label %1387, label %1384
1384: ; preds = %1378, %1438, %1462, %1704
%1385 = phi double [ %1700, %1704 ], [ 0.000000e+00, %1462 ], [ 0.000000e+00, %1438 ], [ 0.000000e+00, %1378 ]
%1386 = phi i32 [ %1705, %1704 ], [ %1463, %1462 ], [ %1381, %1438 ], [ %1381, %1378 ]
br label %232
1387: ; preds = %1378
%1388 = select i1 %137, i1 true, i1 %144
br i1 %1388, label %1421, label %1389
1389: ; preds = %1387
%1390 = insertelement <2 x double> poison, double %1383, i64 0
%1391 = shufflevector <2 x double> %1390, <2 x double> poison, <2 x i32> zeroinitializer
%1392 = insertelement <2 x double> poison, double %1383, i64 0
%1393 = shufflevector <2 x double> %1392, <2 x double> poison, <2 x i32> zeroinitializer
br label %1394
1394: ; preds = %1394, %1389
%1395 = phi i64 [ 0, %1389 ], [ %1418, %1394 ]
%1396 = add nsw i64 %1395, %35
%1397 = add nsw i64 %1395, %36
%1398 = getelementptr inbounds double, double* %8, i64 %1395
%1399 = bitcast double* %1398 to <2 x double>*
%1400 = load <2 x double>, <2 x double>* %1399
%1401 = getelementptr inbounds double, double* %1398, i64 2
%1402 = bitcast double* %1401 to <2 x double>*
%1403 = load <2 x double>, <2 x double>* %1402
%1404 = getelementptr inbounds double, double* %8, i64 %1396
%1405 = bitcast double* %1404 to <2 x double>*
%1406 = load <2 x double>, <2 x double>* %1405
%1407 = getelementptr inbounds double, double* %1404, i64 2
%1408 = bitcast double* %1407 to <2 x double>*
%1409 = load <2 x double>, <2 x double>* %1408
%1410 = fneg <2 x double> %1406
%1411 = fneg <2 x double> %1409
%1412 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1391, <2 x double> %1400, <2 x double> %1410)
%1413 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1393, <2 x double> %1403, <2 x double> %1411)
%1414 = getelementptr inbounds double, double* %8, i64 %1397
%1415 = bitcast double* %1414 to <2 x double>*
store <2 x double> %1412, <2 x double>* %1415
%1416 = getelementptr inbounds double, double* %1414, i64 2
%1417 = bitcast double* %1416 to <2 x double>*
store <2 x double> %1413, <2 x double>* %1417
%1418 = add nuw i64 %1395, 4
%1419 = icmp eq i64 %1418, %145
br i1 %1419, label %1420, label %1394
1420: ; preds = %1394
br i1 %146, label %1438, label %1421
1421: ; preds = %1387, %1420
%1422 = phi i64 [ 0, %1387 ], [ %145, %1420 ]
%1423 = xor i64 %1422, -1
br i1 %148, label %1435, label %1424
1424: ; preds = %1421
%1425 = add nsw i64 %1422, %35
%1426 = add nsw i64 %1422, %36
%1427 = getelementptr inbounds double, double* %8, i64 %1422
%1428 = load double, double* %1427
%1429 = getelementptr inbounds double, double* %8, i64 %1425
%1430 = load double, double* %1429
%1431 = fneg double %1430
%1432 = tail call double @llvm.fmuladd.f64(double %1383, double %1428, double %1431)
%1433 = getelementptr inbounds double, double* %8, i64 %1426
store double %1432, double* %1433
%1434 = or i64 %1422, 1
br label %1435
1435: ; preds = %1424, %1421
%1436 = phi i64 [ %1422, %1421 ], [ %1434, %1424 ]
%1437 = icmp eq i64 %1423, %149
br i1 %1437, label %1438, label %1439
1438: ; preds = %1435, %1439, %1420
br i1 %31, label %1464, label %1384
1439: ; preds = %1435, %1439
%1440 = phi i64 [ %1460, %1439 ], [ %1436, %1435 ]
%1441 = add nsw i64 %1440, %35
%1442 = add nsw i64 %1440, %36
%1443 = getelementptr inbounds double, double* %8, i64 %1440
%1444 = load double, double* %1443
%1445 = getelementptr inbounds double, double* %8, i64 %1441
%1446 = load double, double* %1445
%1447 = fneg double %1446
%1448 = tail call double @llvm.fmuladd.f64(double %1383, double %1444, double %1447)
%1449 = getelementptr inbounds double, double* %8, i64 %1442
store double %1448, double* %1449
%1450 = add nuw nsw i64 %1440, 1
%1451 = add nsw i64 %1450, %35
%1452 = add nsw i64 %1450, %36
%1453 = getelementptr inbounds double, double* %8, i64 %1450
%1454 = load double, double* %1453
%1455 = getelementptr inbounds double, double* %8, i64 %1451
%1456 = load double, double* %1455
%1457 = fneg double %1456
%1458 = tail call double @llvm.fmuladd.f64(double %1383, double %1454, double %1457)
%1459 = getelementptr inbounds double, double* %8, i64 %1452
store double %1458, double* %1459
%1460 = add nuw nsw i64 %1440, 2
%1461 = icmp eq i64 %1460, %44
br i1 %1461, label %1438, label %1439
1462: ; preds = %1611
%1463 = trunc i64 %1612 to i32
br i1 %31, label %1616, label %1384
1464: ; preds = %1438, %1611
%1465 = phi i64 [ %1614, %1611 ], [ 0, %1438 ]
%1466 = phi i64 [ %1613, %1611 ], [ 0, %1438 ]
%1467 = xor i64 %1465, -1
%1468 = add nsw i64 %1467, %38
%1469 = sub nsw i64 %38, %1465
%1470 = getelementptr double, double* %8, i64 %1469
%1471 = add nuw i64 %1465, 1
%1472 = getelementptr double, double* %8, i64 %1471
%1473 = add i64 %73, %1465
%1474 = getelementptr double, double* %8, i64 %1473
%1475 = getelementptr inbounds double, double* %8, i64 %1465
%1476 = load double, double* %1475
%1477 = fdiv double %1476, %1379
%1478 = add nsw i64 %1465, %35
%1479 = getelementptr inbounds double, double* %8, i64 %1478
%1480 = load double, double* %1479
%1481 = fneg double %1480
%1482 = fdiv double %1481, %1379
%1483 = shl i64 %1466, 32
%1484 = ashr exact i64 %1483, 32
%1485 = add nsw i64 %1484, %37
%1486 = add nsw i64 %1465, %36
%1487 = getelementptr inbounds double, double* %8, i64 %1485
%1488 = load double, double* %1487
%1489 = getelementptr inbounds double, double* %8, i64 %1486
%1490 = load double, double* %1489
%1491 = tail call double @llvm.fmuladd.f64(double %1477, double %1490, double %1488)
%1492 = tail call double @llvm.fmuladd.f64(double %1482, double %1476, double %1491)
store double %1492, double* %1487
%1493 = add nsw i64 %1484, 1
%1494 = add nuw nsw i64 %1465, 1
%1495 = icmp eq i64 %1494, %45
br i1 %1495, label %1611, label %1496
1496: ; preds = %1464
%1497 = icmp ult i64 %1468, 4
br i1 %1497, label %1557, label %1498
1498: ; preds = %1496
%1499 = add nsw i64 %1484, %37
%1500 = getelementptr double, double* %71, i64 %1499
%1501 = getelementptr double, double* %1470, i64 %1499
%1502 = icmp ult double* %1500, %72
%1503 = icmp ult double* %1472, %1501
%1504 = and i1 %1502, %1503
%1505 = icmp ult double* %1500, %75
%1506 = icmp ult double* %1474, %1501
%1507 = and i1 %1505, %1506
%1508 = or i1 %1504, %1507
br i1 %1508, label %1557, label %1509
1509: ; preds = %1498
%1510 = and i64 %1468, -4
%1511 = add i64 %1494, %1510
%1512 = add i64 %1493, %1510
%1513 = insertelement <2 x double> poison, double %1477, i64 0
%1514 = shufflevector <2 x double> %1513, <2 x double> poison, <2 x i32> zeroinitializer
%1515 = insertelement <2 x double> poison, double %1477, i64 0
%1516 = shufflevector <2 x double> %1515, <2 x double> poison, <2 x i32> zeroinitializer
%1517 = insertelement <2 x double> poison, double %1482, i64 0
%1518 = shufflevector <2 x double> %1517, <2 x double> poison, <2 x i32> zeroinitializer
%1519 = insertelement <2 x double> poison, double %1482, i64 0
%1520 = shufflevector <2 x double> %1519, <2 x double> poison, <2 x i32> zeroinitializer
br label %1521
1521: ; preds = %1521, %1509
%1522 = phi i64 [ 0, %1509 ], [ %1551, %1521 ]
%1523 = add i64 %1494, %1522
%1524 = add i64 %1493, %1522
%1525 = getelementptr inbounds double, double* %8, i64 %1523
%1526 = bitcast double* %1525 to <2 x double>*
%1527 = load <2 x double>, <2 x double>* %1526
%1528 = getelementptr inbounds double, double* %1525, i64 2
%1529 = bitcast double* %1528 to <2 x double>*
%1530 = load <2 x double>, <2 x double>* %1529
%1531 = add nsw i64 %1524, %37
%1532 = add nsw i64 %1523, %36
%1533 = getelementptr inbounds double, double* %8, i64 %1531
%1534 = bitcast double* %1533 to <2 x double>*
%1535 = load <2 x double>, <2 x double>* %1534
%1536 = getelementptr inbounds double, double* %1533, i64 2
%1537 = bitcast double* %1536 to <2 x double>*
%1538 = load <2 x double>, <2 x double>* %1537
%1539 = getelementptr inbounds double, double* %8, i64 %1532
%1540 = bitcast double* %1539 to <2 x double>*
%1541 = load <2 x double>, <2 x double>* %1540
%1542 = getelementptr inbounds double, double* %1539, i64 2
%1543 = bitcast double* %1542 to <2 x double>*
%1544 = load <2 x double>, <2 x double>* %1543
%1545 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1514, <2 x double> %1541, <2 x double> %1535)
%1546 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1516, <2 x double> %1544, <2 x double> %1538)
%1547 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1518, <2 x double> %1527, <2 x double> %1545)
%1548 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1520, <2 x double> %1530, <2 x double> %1546)
%1549 = bitcast double* %1533 to <2 x double>*
store <2 x double> %1547, <2 x double>* %1549
%1550 = bitcast double* %1536 to <2 x double>*
store <2 x double> %1548, <2 x double>* %1550
%1551 = add nuw i64 %1522, 4
%1552 = icmp eq i64 %1551, %1510
br i1 %1552, label %1553, label %1521
1553: ; preds = %1521
%1554 = add i64 %1524, 3
%1555 = add nsw i64 %1554, %37
%1556 = icmp eq i64 %1468, %1510
br i1 %1556, label %1611, label %1557
1557: ; preds = %1498, %1496, %1553
%1558 = phi i64 [ %1494, %1498 ], [ %1494, %1496 ], [ %1511, %1553 ]
%1559 = phi i64 [ %1493, %1498 ], [ %1493, %1496 ], [ %1512, %1553 ]
%1560 = sub i64 %38, %1558
%1561 = xor i64 %1558, -1
%1562 = and i64 %1560, 1
%1563 = icmp eq i64 %1562, 0
br i1 %1563, label %1577, label %1564
1564: ; preds = %1557
%1565 = getelementptr inbounds double, double* %8, i64 %1558
%1566 = load double, double* %1565
%1567 = add nsw i64 %1559, %37
%1568 = add nsw i64 %1558, %36
%1569 = getelementptr inbounds double, double* %8, i64 %1567
%1570 = load double, double* %1569
%1571 = getelementptr inbounds double, double* %8, i64 %1568
%1572 = load double, double* %1571
%1573 = tail call double @llvm.fmuladd.f64(double %1477, double %1572, double %1570)
%1574 = tail call double @llvm.fmuladd.f64(double %1482, double %1566, double %1573)
store double %1574, double* %1569
%1575 = add nsw i64 %1559, 1
%1576 = add nuw nsw i64 %1558, 1
br label %1577
1577: ; preds = %1564, %1557
%1578 = phi i64 [ undef, %1557 ], [ %1567, %1564 ]
%1579 = phi i64 [ undef, %1557 ], [ %1575, %1564 ]
%1580 = phi i64 [ %1558, %1557 ], [ %1576, %1564 ]
%1581 = phi i64 [ %1559, %1557 ], [ %1575, %1564 ]
%1582 = icmp eq i64 %1561, %150
br i1 %1582, label %1611, label %1583
1583: ; preds = %1577, %1583
%1584 = phi i64 [ %1609, %1583 ], [ %1580, %1577 ]
%1585 = phi i64 [ %1608, %1583 ], [ %1581, %1577 ]
%1586 = getelementptr inbounds double, double* %8, i64 %1584
%1587 = load double, double* %1586
%1588 = add nsw i64 %1585, %37
%1589 = add nsw i64 %1584, %36
%1590 = getelementptr inbounds double, double* %8, i64 %1588
%1591 = load double, double* %1590
%1592 = getelementptr inbounds double, double* %8, i64 %1589
%1593 = load double, double* %1592
%1594 = tail call double @llvm.fmuladd.f64(double %1477, double %1593, double %1591)
%1595 = tail call double @llvm.fmuladd.f64(double %1482, double %1587, double %1594)
store double %1595, double* %1590
%1596 = add nsw i64 %1585, 1
%1597 = add nuw nsw i64 %1584, 1
%1598 = getelementptr inbounds double, double* %8, i64 %1597
%1599 = load double, double* %1598
%1600 = add nsw i64 %1596, %37
%1601 = add nsw i64 %1597, %36
%1602 = getelementptr inbounds double, double* %8, i64 %1600
%1603 = load double, double* %1602
%1604 = getelementptr inbounds double, double* %8, i64 %1601
%1605 = load double, double* %1604
%1606 = tail call double @llvm.fmuladd.f64(double %1477, double %1605, double %1603)
%1607 = tail call double @llvm.fmuladd.f64(double %1482, double %1599, double %1606)
store double %1607, double* %1602
%1608 = add nsw i64 %1585, 2
%1609 = add nuw nsw i64 %1584, 2
%1610 = icmp eq i64 %1609, %45
br i1 %1610, label %1611, label %1583
1611: ; preds = %1577, %1583, %1553, %1464
%1612 = phi i64 [ %1485, %1464 ], [ %1555, %1553 ], [ %1578, %1577 ], [ %1600, %1583 ]
%1613 = phi i64 [ %1493, %1464 ], [ %1512, %1553 ], [ %1579, %1577 ], [ %1608, %1583 ]
%1614 = add nuw nsw i64 %1465, 1
%1615 = icmp eq i64 %1614, %45
br i1 %1615, label %1462, label %1464
1616: ; preds = %1462, %1697
%1617 = phi i64 [ %1702, %1697 ], [ 0, %1462 ]
%1618 = phi double [ %1700, %1697 ], [ 0.000000e+00, %1462 ]
%1619 = icmp eq i64 %1617, 0
br i1 %1619, label %1679, label %1620
1620: ; preds = %1616
%1621 = trunc i64 %1617 to i32
%1622 = and i64 %1617, 1
%1623 = icmp eq i64 %1617, 1
br i1 %1623, label %1659, label %1624
1624: ; preds = %1620
%1625 = and i64 %1617, 9223372036854775806
br label %1626
1626: ; preds = %1626, %1624
%1627 = phi i64 [ 0, %1624 ], [ %1656, %1626 ]
%1628 = phi double [ 0.000000e+00, %1624 ], [ %1651, %1626 ]
%1629 = phi i32 [ %1621, %1624 ], [ %1655, %1626 ]
%1630 = phi i64 [ 0, %1624 ], [ %1657, %1626 ]
%1631 = add nsw i32 %1629, %28
%1632 = sext i32 %1631 to i64
%1633 = getelementptr inbounds double, double* %8, i64 %1632
%1634 = load double, double* %1633
%1635 = getelementptr inbounds double, double* %3, i64 %1627
%1636 = load double, double* %1635
%1637 = fneg double %1634
%1638 = tail call double @llvm.fmuladd.f64(double %1637, double %1636, double %1628)
%1639 = add i32 %1629, %0
%1640 = trunc i64 %1627 to i32
%1641 = xor i32 %1640, -1
%1642 = add i32 %1639, %1641
%1643 = or i64 %1627, 1
%1644 = add nsw i32 %1642, %28
%1645 = sext i32 %1644 to i64
%1646 = getelementptr inbounds double, double* %8, i64 %1645
%1647 = load double, double* %1646
%1648 = getelementptr inbounds double, double* %3, i64 %1643
%1649 = load double, double* %1648
%1650 = fneg double %1647
%1651 = tail call double @llvm.fmuladd.f64(double %1650, double %1649, double %1638)
%1652 = add i32 %1642, %0
%1653 = trunc i64 %1643 to i32
%1654 = xor i32 %1653, -1
%1655 = add i32 %1652, %1654
%1656 = add nuw nsw i64 %1627, 2
%1657 = add i64 %1630, 2
%1658 = icmp eq i64 %1657, %1625
br i1 %1658, label %1659, label %1626
1659: ; preds = %1626, %1620
%1660 = phi double [ undef, %1620 ], [ %1651, %1626 ]
%1661 = phi i32 [ undef, %1620 ], [ %1655, %1626 ]
%1662 = phi i64 [ 0, %1620 ], [ %1656, %1626 ]
%1663 = phi double [ 0.000000e+00, %1620 ], [ %1651, %1626 ]
%1664 = phi i32 [ %1621, %1620 ], [ %1655, %1626 ]
%1665 = icmp eq i64 %1622, 0
br i1 %1665, label %1679, label %1666
1666: ; preds = %1659
%1667 = add nsw i32 %1664, %28
%1668 = sext i32 %1667 to i64
%1669 = getelementptr inbounds double, double* %8, i64 %1668
%1670 = load double, double* %1669
%1671 = getelementptr inbounds double, double* %3, i64 %1662
%1672 = load double, double* %1671
%1673 = fneg double %1670
%1674 = tail call double @llvm.fmuladd.f64(double %1673, double %1672, double %1663)
%1675 = add i32 %1664, %0
%1676 = trunc i64 %1662 to i32
%1677 = xor i32 %1676, -1
%1678 = add i32 %1675, %1677
br label %1679
1679: ; preds = %1666, %1659, %1616
%1680 = phi i32 [ 0, %1616 ], [ %1661, %1659 ], [ %1678, %1666 ]
%1681 = phi double [ 0.000000e+00, %1616 ], [ %1660, %1659 ], [ %1674, %1666 ]
%1682 = sext i32 %1680 to i64
br label %1683
1683: ; preds = %1679, %1683
%1684 = phi i64 [ %1682, %1679 ], [ %1694, %1683 ]
%1685 = phi i64 [ %1617, %1679 ], [ %1695, %1683 ]
%1686 = phi double [ %1681, %1679 ], [ %1693, %1683 ]
%1687 = add nsw i64 %1684, %37
%1688 = getelementptr inbounds double, double* %8, i64 %1687
%1689 = load double, double* %1688
%1690 = getelementptr inbounds double, double* %3, i64 %1685
%1691 = load double, double* %1690
%1692 = fneg double %1689
%1693 = tail call double @llvm.fmuladd.f64(double %1692, double %1691, double %1686)
%1694 = add nsw i64 %1684, 1
%1695 = add nuw nsw i64 %1685, 1
%1696 = icmp eq i64 %1695, %46
br i1 %1696, label %1697, label %1683
1697: ; preds = %1683
%1698 = getelementptr inbounds double, double* %3, i64 %1617
%1699 = load double, double* %1698
%1700 = tail call double @llvm.fmuladd.f64(double %1693, double %1699, double %1618)
%1701 = getelementptr inbounds double, double* %8, i64 %1617
store double %1693, double* %1701
%1702 = add nuw nsw i64 %1617, 1
%1703 = icmp eq i64 %1702, %46
br i1 %1703, label %1704, label %1616
1704: ; preds = %1697
%1705 = trunc i64 %1687 to i32
%1706 = fcmp ogt double %1700, 0.000000e+00
br i1 %1706, label %1707, label %1384
1707: ; preds = %405, %212, %1704, %624, %631, %1123, %426
%1708 = phi i32 [ 1, %426 ], [ 0, %631 ], [ 0, %624 ], [ 3, %1704 ], [ 3, %1123 ], [ 2, %405 ], [ 0, %212 ]
ret i32 %1708
}