void prelim_(int n, int npt, double *x, double *xl, double *xu,
             double (*func)(void *data, int n, const double *x), void *data,
             double rhobeg, int iprint, int maxfun, double *xbase, double *xpt,
             double *fval, double *gopt, double *hq, double *pq, double *bmat,
             double *zmat, int ndim, double *sl, double *su, int *nf,
             int *kopt) {
  int xpt_offset, bmat_offset, zmat_offset;
  double d__1, d__2, d__3, d__4;
  double f;
  int i, j, k, ih, nfm;
  int nfx, ipt, jpt;
  double fbeg, diff, temp, stepa, stepb;
  int itemp;
  static const double half = .5;
  static const double one = 1.;
  static const double two = 2.;
  static const double zero = 0.;
  const double rhosq = rhobeg * rhobeg;
  const double recip = one / rhosq;
  const int np = n + 1;
  for (j = 0; j < n; ++j) {
    xbase[j] = x[j];
    for (k = 0; k < npt; ++k) {
      xpt[k + j * npt] = zero;
    }
    for (i = 0; i < ndim; ++i) {
      bmat[i + j * ndim] = zero;
    }
  }
  for (ih = 0; ih < n * np / 2; ++ih) {
    hq[ih] = zero;
  }
  for (k = 0; k < npt; ++k) {
    pq[k] = zero;
  }
  for (j = 0; j < npt - np; ++j) {
    for (k = 0; k < npt; ++k) {
      zmat[k + j * npt] = zero;
    }
  }
  zmat_offset = 1 + npt;
  zmat -= zmat_offset;
  xpt_offset = 1 + npt;
  xpt -= xpt_offset;
  --x;
  --xl;
  --xu;
  --xbase;
  --fval;
  --gopt;
  --hq;
  --pq;
  bmat_offset = 1 + ndim;
  bmat -= bmat_offset;
  --sl;
  --su;
  *nf = 0;
L50:
  nfm = *nf;
  nfx = *nf - n;
  ++(*nf);
  if (nfm <= 2 * n) {
    if (nfm >= 1 && nfm <= n) {
      stepa = rhobeg;
      if (su[nfm] == zero) {
        stepa = -stepa;
      }
      xpt[*nf + nfm * npt] = stepa;
    } else if (nfm > n) {
      stepa = xpt[*nf - n + nfx * npt];
      stepb = -rhobeg;
      if (sl[nfx] == zero) {
        stepb = two * rhobeg;
        if (su[nfx] < stepb) {
          stepb = su[nfx];
        }
      }
      if (su[nfx] == zero) {
        stepb = -two * rhobeg;
        if (sl[nfx] > stepb) {
          stepb = sl[nfx];
        }
      }
      xpt[*nf + nfx * npt] = stepb;
    }
  } else {
    itemp = (nfm - np) / n;
    jpt = nfm - itemp * n - n;
    ipt = jpt + itemp;
    if (ipt > n) {
      itemp = jpt;
      jpt = ipt - n;
      ipt = itemp;
    }
    xpt[*nf + ipt * npt] = xpt[ipt + 1 + ipt * npt];
    xpt[*nf + jpt * npt] = xpt[jpt + 1 + jpt * npt];
  }
  for (j = 1; j <= n; ++j) {
    x[j] = xbase[j] + xpt[*nf + j * npt];
    if (xl[j] > x[j]) {
      x[j] = xl[j];
    }
    if (xu[j] < x[j]) {
      x[j] = xu[j];
    }
    if (xpt[*nf + j * npt] == sl[j]) {
      x[j] = xl[j];
    }
    if (xpt[*nf + j * npt] == su[j]) {
      x[j] = xu[j];
    }
  }
  f = func(data, n, &x[1]);
  if (iprint == 3) {
    printf("Function number %d    F = %g    The corresponding X is:\n", *nf, f);
    for (i = 1; i <= n; ++i) {
      printf("\t%g\n", x[i]);
    }
  }
  fval[*nf] = f;
  if (*nf == 1) {
    fbeg = f;
    *kopt = 1;
  } else if (f < fval[*kopt]) {
    *kopt = *nf;
  }
  if (*nf <= 2 * n + 1) {
    if (*nf >= 2 && *nf <= n + 1) {
      gopt[nfm] = (f - fbeg) / stepa;
      if (npt < *nf + n) {
        bmat[nfm * ndim + 1] = -one / stepa;
        bmat[*nf + nfm * ndim] = one / stepa;
        bmat[npt + nfm + nfm * ndim] = -half * rhosq;
      }
    } else if (*nf >= n + 2) {
      ih = nfx * (nfx + 1) / 2;
      temp = (f - fbeg) / stepb;
      diff = stepb - stepa;
      hq[ih] = two * (temp - gopt[nfx]) / diff;
      gopt[nfx] = (gopt[nfx] * stepb - temp * stepa) / diff;
      if (stepa * stepb < zero) {
        if (f < fval[*nf - n]) {
          fval[*nf] = fval[*nf - n];
          fval[*nf - n] = f;
          if (*kopt == *nf) {
            *kopt = *nf - n;
          }
          xpt[*nf - n + nfx * npt] = stepb;
          xpt[*nf + nfx * npt] = stepa;
        }
      }
      bmat[nfx * ndim + 1] = -(stepa + stepb) / (stepa * stepb);
      bmat[*nf + nfx * ndim] = -half / xpt[*nf - n + nfx * npt];
      bmat[*nf - n + nfx * ndim] =
          -bmat[nfx * ndim + 1] - bmat[*nf + nfx * ndim];
      zmat[nfx * npt + 1] = sqrt(two) / (stepa * stepb);
      zmat[*nf + nfx * npt] = sqrt(half) / rhosq;
      zmat[*nf - n + nfx * npt] = -zmat[nfx * npt + 1] - zmat[*nf + nfx * npt];
    }
  } else {
    ih = ipt * (ipt - 1) / 2 + jpt;
    zmat[nfx * npt + 1] = recip;
    zmat[*nf + nfx * npt] = recip;
    zmat[ipt + 1 + nfx * npt] = -recip;
    zmat[jpt + 1 + nfx * npt] = -recip;
    temp = xpt[*nf + ipt * npt] * xpt[*nf + jpt * npt];
    hq[ih] = (fbeg - fval[ipt + 1] - fval[jpt + 1] + f) / temp;
  }
  if (*nf < npt && *nf < maxfun) {
    goto L50;
  }
}


x86 assembly (clang, -O0):
<prelim_>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%eax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  -0x30(%rbp),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x1e5d(%rip),%xmm0
divsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1277 <prelim_+0x157>
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1228 <prelim_+0x108>
mov    0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    11f3 <prelim_+0xd3>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x68(%rbp),%eax
jge    1264 <prelim_+0x144>
mov    0x58(%rbp),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    122f <prelim_+0x10f>
jmp    1269 <prelim_+0x149>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    11c6 <prelim_+0xa6>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x4(%rbp),%eax
imul   -0xcc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xd0(%rbp),%eax
cmp    %ecx,%eax
jge    12c7 <prelim_+0x1a7>
mov    0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    127e <prelim_+0x15e>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12f8 <prelim_+0x1d8>
mov    0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12ce <prelim_+0x1ae>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x8(%rbp),%ecx
sub    -0xcc(%rbp),%ecx
cmp    %ecx,%eax
jge    1362 <prelim_+0x242>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    134f <prelim_+0x22f>
mov    0x60(%rbp),%rax
mov    -0x74(%rbp),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    131a <prelim_+0x1fa>
jmp    1354 <prelim_+0x234>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    12ff <prelim_+0x1df>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
mov    0x60(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x60(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
mov    0x30(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x30(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x40(%rbp)
mov    0x48(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x48(%rbp)
mov    0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rbp)
mov    0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
mov    0x58(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x58(%rbp)
mov    0x70(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x70(%rbp)
mov    0x78(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x78(%rbp)
mov    0x80(%rbp),%rax
movl   $0x0,(%rax)
mov    0x80(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x7c(%rbp)
mov    0x80(%rbp),%rax
mov    (%rax),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    0x80(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    %ecx,(%rax)
mov    -0x7c(%rbp),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jg     1680 <prelim_+0x560>
cmpl   $0x1,-0x7c(%rbp)
jl     151f <prelim_+0x3ff>
mov    -0x7c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     151f <prelim_+0x3ff>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x78(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14f4 <prelim_+0x3d4>
jp     14f4 <prelim_+0x3d4>
movsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x7c(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    167b <prelim_+0x55b>
mov    -0x7c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    1676 <prelim_+0x556>
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x70(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15e6 <prelim_+0x4c6>
jp     15e6 <prelim_+0x4c6>
movsd  0x1a68(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x78(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    15e1 <prelim_+0x4c1>
mov    0x78(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    15e6 <prelim_+0x4c6>
mov    0x78(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1650 <prelim_+0x530>
jp     1650 <prelim_+0x530>
movsd  0x1a02(%rip),%xmm0
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x70(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jbe    164b <prelim_+0x52b>
mov    0x70(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
jmp    1650 <prelim_+0x530>
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    167b <prelim_+0x55b>
jmp    1777 <prelim_+0x657>
mov    -0x7c(%rbp),%eax
sub    -0xcc(%rbp),%eax
cltd
idivl  -0x4(%rbp)
mov    %eax,-0xb4(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0xb4(%rbp),%ecx
imul   -0x4(%rbp),%ecx
sub    %ecx,%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
add    -0xb4(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x4(%rbp),%eax
jle    16f3 <prelim_+0x5d3>
mov    -0x88(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x84(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    0x30(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    $0x1,%ecx
mov    -0x84(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x84(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
mov    -0x88(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x88(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     18ef <prelim_+0x7cf>
mov    0x28(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    17fc <prelim_+0x6dc>
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    183a <prelim_+0x71a>
mov    -0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x70(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    188b <prelim_+0x76b>
jp     188b <prelim_+0x76b>
mov    -0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x70(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x78(%rbp),%rax
movslq -0x70(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    18dc <prelim_+0x7bc>
jp     18dc <prelim_+0x7bc>
mov    -0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x70(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    18e1 <prelim_+0x7c1>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    177e <prelim_+0x65e>
mov    -0x28(%rbp),%rax
mov    0x10(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
add    $0x8,%rdx
call   *%rax
movsd  %xmm0,-0x68(%rbp)
cmpl   $0x3,0x18(%rbp)
jne    1970 <prelim_+0x850>
mov    0x80(%rbp),%rax
mov    (%rax),%esi
movsd  -0x68(%rbp),%xmm0
lea    0x1728(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     196b <prelim_+0x84b>
mov    -0x10(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x1733(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1936 <prelim_+0x816>
jmp    1970 <prelim_+0x850>
movsd  -0x68(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    0x80(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
cmpl   $0x1,(%rax)
jne    19b7 <prelim_+0x897>
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x88(%rbp),%rax
movl   $0x1,(%rax)
jmp    19f0 <prelim_+0x8d0>
movsd  -0x68(%rbp),%xmm1
mov    0x38(%rbp),%rax
mov    0x88(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    19eb <prelim_+0x8cb>
mov    0x80(%rbp),%rax
mov    (%rax),%ecx
mov    0x88(%rbp),%rax
mov    %ecx,(%rax)
jmp    19f0 <prelim_+0x8d0>
mov    0x80(%rbp),%rax
mov    (%rax),%eax
mov    -0x4(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1ed1 <prelim_+0xdb1>
mov    0x80(%rbp),%rax
cmpl   $0x2,(%rax)
jl     1aee <prelim_+0x9ce>
mov    0x80(%rbp),%rax
mov    (%rax),%eax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1aee <prelim_+0x9ce>
movsd  -0x68(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8(%rbp),%eax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jge    1ae9 <prelim_+0x9c9>
movsd  0x15b6(%rip),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x7c(%rbp),%ecx
imul   0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x1568(%rip),%xmm0
divsd  -0xa8(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x7c(%rbp),%edx
imul   0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x155a(%rip),%xmm0
mulsd  -0xc0(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    -0x7c(%rbp),%ecx
mov    -0x7c(%rbp),%edx
imul   0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ecc <prelim_+0xdac>
mov    0x80(%rbp),%rax
mov    (%rax),%eax
mov    -0x4(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jl     1ec7 <prelim_+0xda7>
mov    -0x80(%rbp),%eax
mov    -0x80(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
subsd  -0x90(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
subsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
mov    0x40(%rbp),%rax
movslq -0x80(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0x149a(%rip),%xmm0
mulsd  %xmm1,%xmm0
divsd  -0x98(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xa0(%rbp),%xmm1
ff
mulsd  -0xa8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x98(%rbp),%xmm0
ff
mov    0x40(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ced <prelim_+0xbcd>
movsd  -0x68(%rbp),%xmm1
mov    0x38(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1ce8 <prelim_+0xbc8>
mov    0x38(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    0x80(%rbp),%rcx
movslq (%rcx),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x88(%rbp),%rax
mov    (%rax),%eax
mov    0x80(%rbp),%rcx
cmp    (%rcx),%eax
jne    1c99 <prelim_+0xb79>
mov    0x80(%rbp),%rax
mov    (%rax),%ecx
sub    -0x4(%rbp),%ecx
mov    0x88(%rbp),%rax
mov    %ecx,(%rax)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ced <prelim_+0xbcd>
movsd  -0xa8(%rbp),%xmm0
ff
addsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    0x58(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0x12be(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x80(%rbp),%edx
imul   0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x58(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   0x68(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x58(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x80(%rbp),%edx
imul   0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   0x68(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x120f(%rip),%xmm0
call   1040 <sqrt@plt>
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0xb0(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    0x60(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x11e8(%rip),%xmm0
call   1040 <sqrt@plt>
divsd  -0xc0(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x60(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x60(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x60(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
sub    -0x4(%rbp),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ecc <prelim_+0xdac>
jmp    2048 <prelim_+0xf28>
mov    -0x84(%rbp),%eax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    -0x88(%rbp),%eax
mov    %eax,-0x78(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    -0x80(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
mov    0x60(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x60(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    $0x1,%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x60(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
mov    -0x80(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x84(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    0x80(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x88(%rbp),%edx
imul   -0x8(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    (%rax),%eax
cmp    -0x8(%rbp),%eax
jge    2071 <prelim_+0xf51>
mov    0x80(%rbp),%rax
mov    (%rax),%eax
cmp    0x20(%rbp),%eax
jge    2071 <prelim_+0xf51>
jmp    1450 <prelim_+0x330>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prelim_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
movaps %xmm0,0xa0(%rsp)
mov    %r9,0xd8(%rsp)
mov    %r8,%r15
mov    %rcx,%r12
mov    %rdx,%rbx
mov    %esi,%r8d
lea    0x1(%rdi),%eax
mov    %eax,0x14(%rsp)
mov    %esi,%eax
mov    %rax,0x8(%rsp)
mov    %rdi,0x18(%rsp)
test   %edi,%edi
mov    %r8,0x20(%rsp)
jle    1229 <prelim_+0x109>
mov    0x8(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x48(%rsp)
mov    0x1b8(%rsp),%eax
shl    $0x3,%rax
mov    %rax,0x40(%rsp)
mov    0x18(%rsp),%eax
mov    %rax,0x28(%rsp)
xor    %r13d,%r13d
xor    %r14d,%r14d
xor    %ebp,%ebp
jmp    11c6 <prelim_+0xa6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbp
add    %r8d,%r14d
add    0x1b8(%rsp),%r13d
cmp    %rbp,0x28(%rsp)
je     1229 <prelim_+0x109>
movsd  (%rbx,%rbp,8),%xmm0
mov    0x178(%rsp),%rax
movsd  %xmm0,(%rax,%rbp,8)
test   %r8d,%r8d
jle    11fd <prelim_+0xdd>
movslq %r14d,%rax
mov    0x180(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x48(%rsp),%rdx
call   1040 <memset@plt>
mov    0x20(%rsp),%r8
cmpl   $0x0,0x1b8(%rsp)
jle    11b0 <prelim_+0x90>
movslq %r13d,%rax
mov    0x1a8(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x40(%rsp),%rdx
call   1040 <memset@plt>
mov    0x20(%rsp),%r8
jmp    11b0 <prelim_+0x90>
mov    0x14(%rsp),%eax
imul   0x18(%rsp),%eax
cmp    $0x2,%eax
jl     1258 <prelim_+0x138>
shr    %eax
add    $0xffffffff,%eax
lea    0x8(,%rax,8),%rdx
mov    0x198(%rsp),%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x20(%rsp),%r8
movapd 0xa0(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movapd %xmm0,0x90(%rsp)
test   %r8d,%r8d
mov    0x8(%rsp),%rbp
jle    1294 <prelim_+0x174>
mov    0x1a0(%rsp),%rdi
lea    0x0(,%rbp,8),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x20(%rsp),%r8
movsd  0xd64(%rip),%xmm0
divsd  0x90(%rsp),%xmm0
movapd %xmm0,0xf0(%rsp)
mov    %r8d,%eax
sub    0x14(%rsp),%eax
test   %eax,%eax
jle    131e <prelim_+0x1fe>
shl    $0x3,%rbp
mov    %rbp,0x8(%rsp)
mov    %eax,%ecx
lea    -0x1(%rcx),%rax
mov    %ecx,%ebp
and    $0x3,%ebp
xor    %r14d,%r14d
cmp    $0x3,%rax
jae    1b66 <prelim_+0xa46>
xor    %r13d,%r13d
test   %rbp,%rbp
mov    0x8(%rsp),%r14
je     131e <prelim_+0x1fe>
imul   %r8d,%r13d
jmp    12f9 <prelim_+0x1d9>
nopl   (%rax)
add    %r8d,%r13d
add    $0xffffffffffffffff,%rbp
je     131e <prelim_+0x1fe>
test   %r8d,%r8d
jle    12f0 <prelim_+0x1d0>
movslq %r13d,%rax
mov    0x1b0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    %r14,%rdx
call   1040 <memset@plt>
mov    0x20(%rsp),%r8
jmp    12f0 <prelim_+0x1d0>
mov    0x1d0(%rsp),%rdx
mov    0x1c8(%rsp),%r14
mov    0x1c0(%rsp),%r11
mov    %r8d,%eax
not    %eax
cltq
mov    0x1b0(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
mov    %rcx,0x78(%rsp)
mov    0x180(%rsp),%rcx
lea    (%rcx,%rax,8),%r10
mov    0x1b8(%rsp),%eax
not    %eax
cltq
mov    0x1a8(%rsp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %rax,0x70(%rsp)
mov    0x18(%rsp),%rsi
lea    (%rsi,%rsi,1),%eax
mov    %eax,0x6c(%rsp)
movapd 0xcb6(%rip),%xmm1
movapd 0xa0(%rsp),%xmm0
movapd %xmm0,%xmm2
xorpd  %xmm1,%xmm2
movapd %xmm2,0xe0(%rsp)
movapd %xmm0,%xmm2
addsd  %xmm0,%xmm2
movapd %xmm2,0x100(%rsp)
movsd  0xc4b(%rip),%xmm2
mulsd  %xmm0,%xmm2
movsd  %xmm2,0xb0(%rsp)
movsd  0xc3e(%rip),%xmm0
movapd 0x90(%rsp),%xmm2
mulsd  %xmm2,%xmm0
movsd  %xmm0,0xc0(%rsp)
movsd  0xc28(%rip),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,0xb8(%rsp)
movapd 0xf0(%rsp),%xmm0
xorpd  %xmm1,%xmm0
movapd %xmm0,0x110(%rsp)
mov    0x14(%rsp),%eax
lea    -0x8(,%rax,8),%rdi
ff
add    $0xffffffffffffffff,%rax
mov    %rax,0x90(%rsp)
lea    0x1(%rsi,%rsi,1),%eax
mov    %eax,0x68(%rsp)
lea    0x2(%rsi),%eax
mov    %eax,0x64(%rsp)
movslq %r8d,%rax
mov    %rax,0xc8(%rsp)
lea    0x0(,%rax,8),%r13
xor    %ecx,%ecx
mov    %rax,0x88(%rsp)
mov    %rax,0x80(%rsp)
mov    %r10,0x38(%rsp)
mov    %rdi,0x30(%rsp)
mov    %r13,0xd0(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%eax
sub    %esi,%eax
mov    %rax,0x8(%rsp)
lea    0x1(%rcx),%r9d
mov    %r9d,(%rdx)
cmp    0x6c(%rsp),%ecx
mov    %rcx,0x58(%rsp)
jle    1510 <prelim_+0x3f0>
mov    %ecx,%eax
sub    0x14(%rsp),%eax
cltd
idiv   %esi
mov    %eax,%ebp
imul   %esi,%ebp
add    %esi,%ebp
mov    %ecx,%edx
sub    %ebp,%edx
add    %edx,%eax
mov    %eax,%ecx
sub    %esi,%ecx
cmovg  %edx,%eax
cmovle %edx,%ecx
mov    %eax,%ebp
imul   %r8d,%ebp
mov    %rax,0x88(%rsp)
lea    (%rax,%rbp,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%r10,%rdx,8),%xmm0
add    %r9d,%ebp
movslq %ebp,%rax
movsd  %xmm0,(%r10,%rax,8)
mov    %ecx,%eax
imul   %r8d,%eax
mov    %rcx,0x80(%rsp)
lea    (%rcx,%rax,1),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%r10,%rdx,8),%xmm0
add    %r9d,%eax
jmp    15f0 <prelim_+0x4d0>
nopl   0x0(%rax)
test   %ecx,%ecx
jle    1560 <prelim_+0x440>
cmp    %esi,%ecx
jg     1560 <prelim_+0x440>
mov    %ecx,%eax
movsd  -0x8(%r14,%rax,8),%xmm0
cmpeqsd 0xb06(%rip),%xmm0
movapd %xmm0,%xmm1
andpd  0xe0(%rsp),%xmm1
andnpd 0xa0(%rsp),%xmm0
orpd   %xmm1,%xmm0
mov    %ecx,%eax
imul   %r8d,%eax
add    %r9d,%eax
movapd %xmm0,%xmm4
jmp    15f0 <prelim_+0x4d0>
cs nopw 0x0(%rax,%rax,1)
cmp    %esi,%ecx
jle    1698 <prelim_+0x578>
mov    %r9d,%ecx
sub    %esi,%ecx
mov    0x8(%rsp),%rdx
mov    %edx,%eax
imul   %r8d,%eax
movslq %edx,%rdx
movsd  -0x8(%r11,%rdx,8),%xmm1
ucomisd 0xaa6(%rip),%xmm1
movsd  -0x8(%r14,%rdx,8),%xmm2
movapd 0xe0(%rsp),%xmm0
jne    15b1 <prelim_+0x491>
jp     15b1 <prelim_+0x491>
movapd 0x100(%rsp),%xmm0
ucomisd %xmm2,%xmm0
jbe    15b1 <prelim_+0x491>
movapd %xmm2,%xmm0
add    %eax,%ecx
ucomisd 0xa75(%rip),%xmm2
jne    15d2 <prelim_+0x4b2>
jp     15d2 <prelim_+0x4b2>
movsd  0xb0(%rsp),%xmm0
ucomisd %xmm0,%xmm1
jbe    15d2 <prelim_+0x4b2>
movapd %xmm1,%xmm0
movslq %ecx,%rdx
movsd  (%r10,%rdx,8),%xmm4
add    %r9d,%eax
movsd  %xmm0,0x50(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x178(%rsp),%rdx
cltq
movsd  %xmm0,(%r10,%rax,8)
test   %esi,%esi
jle    16b0 <prelim_+0x590>
movslq %r9d,%rax
add    0xc8(%rsp),%rax
lea    (%r10,%rax,8),%rax
xor    %ecx,%ecx
jmp    1630 <prelim_+0x510>
nopl   0x0(%rax,%rax,1)
add    %r13,%rax
add    $0x8,%rcx
cmp    %rcx,%rdi
je     16b0 <prelim_+0x590>
movsd  (%rdx,%rcx,1),%xmm0
addsd  (%rax),%xmm0
movsd  %xmm0,(%rbx,%rcx,1)
movsd  (%r12,%rcx,1),%xmm1
ucomisd %xmm0,%xmm1
jbe    1653 <prelim_+0x533>
movsd  %xmm1,(%rbx,%rcx,1)
movapd %xmm1,%xmm0
movsd  (%r15,%rcx,1),%xmm1
ucomisd %xmm1,%xmm0
jbe    1664 <prelim_+0x544>
movsd  %xmm1,(%rbx,%rcx,1)
movsd  (%rax),%xmm0
ucomisd (%r11,%rcx,1),%xmm0
jne    1681 <prelim_+0x561>
jp     1681 <prelim_+0x561>
movsd  (%r12,%rcx,1),%xmm0
movsd  %xmm0,(%rbx,%rcx,1)
movsd  (%rax),%xmm0
ucomisd (%r14,%rcx,1),%xmm0
jne    1620 <prelim_+0x500>
jp     1620 <prelim_+0x500>
movsd  (%r15,%rcx,1),%xmm0
movsd  %xmm0,(%rbx,%rcx,1)
jmp    1620 <prelim_+0x500>
mov    0x178(%rsp),%rdx
test   %esi,%esi
jg     1608 <prelim_+0x4e8>
nopl   0x0(%rax,%rax,1)
movsd  %xmm4,0x40(%rsp)
mov    0x160(%rsp),%rdi
mov    %rbx,%rdx
call   *0xd8(%rsp)
movsd  %xmm0,0x28(%rsp)
cmpl   $0x3,0x168(%rsp)
03
mov    0x90(%rsp),%r13
lea    0x9a4(%rip),%r14
jne    1728 <prelim_+0x608>
mov    0x1d0(%rsp),%rax
mov    (%rax),%esi
lea    0x958(%rip),%rdi
movsd  0x28(%rsp),%xmm0
mov    $0x1,%al
call   1030 <printf@plt>
cmpl   $0x0,0x18(%rsp)
jle    1728 <prelim_+0x608>
xor    %ebp,%ebp
xchg   %ax,%ax
movsd  (%rbx,%rbp,8),%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1030 <printf@plt>
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1710 <prelim_+0x5f0>
mov    0x1d0(%rsp),%r9
movslq (%r9),%rdx
mov    0x188(%rsp),%rdi
movsd  0x28(%rsp),%xmm5
movsd  %xmm5,-0x8(%rdi,%rdx,8)
mov    $0x1,%eax
movapd %xmm5,%xmm0
cmp    $0x1,%rdx
movsd  0x48(%rsp),%xmm1
movsd  0x40(%rsp),%xmm4
je     177f <prelim_+0x65f>
mov    0x1d8(%rsp),%rax
movslq (%rax),%rcx
movsd  -0x8(%rdi,%rcx,8),%xmm0
ucomisd %xmm5,%xmm0
mov    %edx,%eax
movapd %xmm1,%xmm0
jbe    178f <prelim_+0x66f>
mov    0x1d8(%rsp),%rcx
mov    %eax,(%rcx)
mov    %eax,%ecx
movapd %xmm0,%xmm1
mov    (%r9),%r9d
cmp    0x68(%rsp),%r9d
mov    0x20(%rsp),%r8
mov    0x1c8(%rsp),%r14
mov    0x1c0(%rsp),%r11
mov    0x38(%rsp),%r10
mov    0xd0(%rsp),%r13
movsd  %xmm1,0x48(%rsp)
jle    1890 <prelim_+0x770>
mov    0x88(%rsp),%rbp
lea    -0x1(%rbp),%edx
imul   %ebp,%edx
mov    %edx,%ecx
shr    $0x1f,%ecx
add    %edx,%ecx
mov    0x8(%rsp),%rax
imul   %r8d,%eax
movslq %eax,%rdx
movaps 0xf0(%rsp),%xmm0
mov    0x78(%rsp),%rax
movsd  %xmm0,0x8(%rax,%rdx,8)
lea    (%r9,%rdx,1),%esi
movslq %esi,%rsi
movsd  %xmm0,(%rax,%rsi,8)
lea    0x1(%rbp,%rdx,1),%esi
movslq %esi,%rsi
movaps 0x110(%rsp),%xmm0
movsd  %xmm0,(%rax,%rsi,8)
mov    0x80(%rsp),%rsi
lea    0x1(%rsi,%rdx,1),%edx
movslq %edx,%rdx
movsd  %xmm0,(%rax,%rdx,8)
mov    %ebp,%edx
imul   %r8d,%edx
add    %r9d,%edx
movslq %edx,%rdx
movsd  (%r10,%rdx,8),%xmm0
mov    %esi,%edx
imul   %r8d,%edx
add    %r9d,%edx
movslq %edx,%rdx
mulsd  (%r10,%rdx,8),%xmm0
sar    %ecx
movslq %ebp,%rdx
subsd  (%rdi,%rdx,8),%xmm1
add    %esi,%ecx
movslq %esi,%rdx
subsd  (%rdi,%rdx,8),%xmm1
addsd  %xmm1,%xmm5
divsd  %xmm0,%xmm5
movslq %ecx,%rcx
mov    0x198(%rsp),%rdx
movsd  %xmm5,-0x8(%rdx,%rcx,8)
jmp    1940 <prelim_+0x820>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x2,%r9d
jl     1930 <prelim_+0x810>
cmp    0x14(%rsp),%r9d
jg     1930 <prelim_+0x810>
subsd  %xmm1,%xmm5
divsd  %xmm4,%xmm5
mov    0x58(%rsp),%rdi
movslq %edi,%rcx
mov    0x190(%rsp),%rdx
movsd  %xmm5,-0x8(%rdx,%rcx,8)
mov    0x18(%rsp),%rsi
lea    (%r9,%rsi,1),%ecx
cmp    %r8d,%ecx
jle    1970 <prelim_+0x850>
movsd  0x743(%rip),%xmm0
divsd  %xmm4,%xmm0
mov    %edi,%ecx
imul   0x1b8(%rsp),%ecx
movslq %ecx,%rcx
mov    0x70(%rsp),%rax
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x6ff(%rip),%xmm0
divsd  %xmm4,%xmm0
lea    (%r9,%rcx,1),%edx
movslq %edx,%rdx
movsd  %xmm0,(%rax,%rdx,8)
add    %r8d,%edi
add    %ecx,%edi
movslq %edi,%rcx
movsd  0xc0(%rsp),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    %r9d,%ecx
jmp    1948 <prelim_+0x828>
nopl   0x0(%rax)
cmp    0x64(%rsp),%r9d
jge    1975 <prelim_+0x855>
nopw   0x0(%rax,%rax,1)
mov    %r9d,%ecx
mov    0x18(%rsp),%rsi
mov    0x30(%rsp),%rdi
mov    0x1d0(%rsp),%rdx
cmp    %r8d,%ecx
jge    1b54 <prelim_+0xa34>
cmp    0x170(%rsp),%ecx
jl     1480 <prelim_+0x360>
jmp    1b54 <prelim_+0xa34>
mov    %r9d,%ecx
jmp    1948 <prelim_+0x828>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%edx
imul   %eax,%edx
mov    %edx,%esi
shr    $0x1f,%esi
add    %edx,%esi
sar    %esi
movapd %xmm5,%xmm0
subsd  %xmm1,%xmm0
movsd  0x50(%rsp),%xmm3
divsd  %xmm3,%xmm0
movapd %xmm3,%xmm1
subsd  %xmm4,%xmm1
movslq %eax,%rdx
movapd %xmm4,%xmm2
mulsd  %xmm0,%xmm2
mov    0x190(%rsp),%r10
subsd  -0x8(%r10,%rdx,8),%xmm0
addsd  %xmm0,%xmm0
divsd  %xmm1,%xmm0
movslq %esi,%rsi
mov    0x198(%rsp),%rdi
movsd  %xmm0,-0x8(%rdi,%rsi,8)
movsd  -0x8(%r10,%rdx,8),%xmm0
mulsd  %xmm3,%xmm0
subsd  %xmm2,%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%r10,%rdx,8)
movapd %xmm4,%xmm0
mulsd  %xmm3,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm0,%xmm1
mov    0x18(%rsp),%rsi
jbe    1a7c <prelim_+0x95c>
mov    %r9d,%edx
sub    %esi,%edx
movslq %edx,%rax
mov    0x188(%rsp),%r10
movsd  -0x8(%r10,%rax,8),%xmm1
ucomisd %xmm5,%xmm1
jbe    1a7c <prelim_+0x95c>
movslq %r9d,%rdi
movsd  %xmm1,-0x8(%r10,%rdi,8)
movsd  %xmm5,-0x8(%r10,%rax,8)
cmp    %r9d,%ecx
jne    1a4f <prelim_+0x92f>
mov    0x1d8(%rsp),%rax
mov    %edx,(%rax)
mov    0x1d0(%rsp),%rax
mov    (%rax),%r9d
mov    0x8(%rsp),%rcx
imul   %r8d,%ecx
lea    (%r9,%rcx,1),%edx
sub    %esi,%ecx
add    %r9d,%ecx
movslq %ecx,%rcx
mov    0x38(%rsp),%rax
movsd  0x50(%rsp),%xmm1
movsd  %xmm1,(%rax,%rcx,8)
movslq %edx,%rcx
movsd  %xmm4,(%rax,%rcx,8)
movapd %xmm4,%xmm1
addsd  0x50(%rsp),%xmm1
movapd 0x5b2(%rip),%xmm3
xorpd  %xmm3,%xmm1
divsd  %xmm0,%xmm1
mov    0x8(%rsp),%rbp
mov    %ebp,%ecx
imul   0x1b8(%rsp),%ecx
movslq %ecx,%r10
mov    0x70(%rsp),%rax
movsd  %xmm1,0x8(%rax,%r10,8)
mov    %r9d,%edx
sub    %esi,%edx
imul   %r8d,%ebp
lea    (%rdx,%rbp,1),%ecx
movslq %ecx,%rdi
mov    %rdi,0x28(%rsp)
movsd  0x540(%rip),%xmm1
mov    0x38(%rsp),%rcx
divsd  (%rcx,%rdi,8),%xmm1
lea    (%r9,%r10,1),%edi
movslq %edi,%rdi
movsd  %xmm1,(%rax,%rdi,8)
movsd  0x8(%rax,%r10,8),%xmm2
xorpd  %xmm3,%xmm2
subsd  %xmm1,%xmm2
add    %r10d,%edx
movslq %edx,%rdx
movsd  %xmm2,(%rax,%rdx,8)
movsd  0x520(%rip),%xmm1
divsd  %xmm0,%xmm1
movslq %ebp,%r10
mov    0x78(%rsp),%rdx
movsd  %xmm1,0x8(%rdx,%r10,8)
lea    (%r10,%r9,1),%edi
movslq %edi,%rdi
movsd  0xb8(%rsp),%xmm1
movsd  %xmm1,(%rdx,%rdi,8)
movsd  0x8(%rdx,%r10,8),%xmm0
mov    %rcx,%r10
xorpd  %xmm3,%xmm0
subsd  %xmm1,%xmm0
mov    0x28(%rsp),%rax
movsd  %xmm0,(%rdx,%rax,8)
mov    %r9d,%ecx
jmp    1948 <prelim_+0x828>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffc,%ecx
lea    0x0(,%r8,4),%eax
mov    %eax,0x28(%rsp)
lea    (%r8,%r8,1),%eax
mov    %rax,0x40(%rsp)
lea    (%r8,%r8,2),%eax
mov    %rax,0x58(%rsp)
xor    %r13d,%r13d
mov    %rcx,0x48(%rsp)
mov    %rbp,0x38(%rsp)
jmp    1bb2 <prelim_+0xa92>
cs nopw 0x0(%rax,%rax,1)
add    $0x4,%r13
add    0x28(%rsp),%r14d
cmp    %r13,%rcx
je     12dd <prelim_+0x1bd>
test   %r8d,%r8d
jle    1ba0 <prelim_+0xa80>
movslq %r14d,%rax
mov    0x1b0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    0x8(%rsp),%rdx
mov    %rdx,%rbp
call   1040 <memset@plt>
mov    0x20(%rsp),%rax
add    %r14d,%eax
cltq
mov    0x1b0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    0x40(%rsp),%rax
add    %r14d,%eax
cltq
mov    0x1b0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1040 <memset@plt>
mov    0x58(%rsp),%rax
add    %r14d,%eax
cltq
mov    0x1b0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
mov    0x38(%rsp),%rbp
call   1040 <memset@plt>
mov    0x48(%rsp),%rcx
mov    0x20(%rsp),%r8
jmp    1ba0 <prelim_+0xa80>

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

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