int solve_dual(n, m, precision, epsilon_crit, maxiter, g, g0, ce, ce0, low, up,
               primal, d, d0, ig, dual, dual_old, temp, goal)
long n;
long m;
double precision;
double epsilon_crit;
long maxiter;
double *g;
double *g0;
double *ce, *ce0;
double *low, *up;
double *primal;
double *d, *d0, *ig, *dual, *dual_old, *temp;
long goal;
{
  long i, j, k, iter;
  double sum, w, maxviol, viol, temp1, temp2, isnantest;
  double model_b, dist;
  long retrain, maxfaktor, primal_optimal = 0, at_bound, scalemaxiter;
  double epsilon_a = 1E-15, epsilon_hideo;
  double eq;
  if ((m < 0) || (m > 1))
    perror("SOLVE DUAL: inappropriate number of eq-constrains!");
  for (i = 0; i < 2 * (n + m); i++) {
    dual[i] = 0;
    dual_old[i] = 0;
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      d[i * 2 * (n + m) + j] = ig[i * n + j];
      d[(i + n) * 2 * (n + m) + j] = -ig[i * n + j];
      d[i * 2 * (n + m) + j + n] = -ig[i * n + j];
      d[(i + n) * 2 * (n + m) + j + n] = ig[i * n + j];
    }
    if (m > 0) {
      sum = 0;
      for (j = 0; j < n; j++) {
        sum += (ce[j] * ig[i * n + j]);
      }
      d[i * 2 * (n + m) + 2 * n] = sum;
      d[i * 2 * (n + m) + 2 * n + 1] = -sum;
      d[(n + i) * 2 * (n + m) + 2 * n] = -sum;
      d[(n + i) * 2 * (n + m) + 2 * n + 1] = sum;
      d[(n + n) * 2 * (n + m) + i] = sum;
      d[(n + n + 1) * 2 * (n + m) + i] = -sum;
      d[(n + n) * 2 * (n + m) + (n + i)] = -sum;
      d[(n + n + 1) * 2 * (n + m) + (n + i)] = sum;
      sum = 0;
      for (j = 0; j < n; j++) {
        for (k = 0; k < n; k++) {
          sum += (ce[k] * ce[j] * ig[j * n + k]);
        }
      }
      d[(n + n) * 2 * (n + m) + 2 * n] = sum;
      d[(n + n) * 2 * (n + m) + 2 * n + 1] = -sum;
      d[(n + n + 1) * 2 * (n + m) + 2 * n] = -sum;
      d[(n + n + 1) * 2 * (n + m) + 2 * n + 1] = sum;
    }
  }
  for (i = 0; i < n; i++) {
    w = 0;
    for (j = 0; j < n; j++) {
      w += (ig[i * n + j] * g0[j]);
    }
    d0[i] = up[i] + w;
    d0[i + n] = -low[i] - w;
  }
  if (m > 0) {
    sum = 0;
    for (j = 0; j < n; j++) {
      for (k = 0; k < n; k++) {
        sum += (ce[k] * ig[k * n + j] * g0[j]);
      }
    }
    d0[2 * n] = ce0[0] + sum;
    d0[2 * n + 1] = -ce0[0] - sum;
  }
  maxviol = 999999;
  iter = 0;
  retrain = 1;
  maxfaktor = 1;
  scalemaxiter = maxiter / 5;
  while ((retrain) && (maxviol > 0) && (iter < (scalemaxiter * maxfaktor))) {
    iter++;
    while ((maxviol > precision) && (iter < (scalemaxiter * maxfaktor))) {
      iter++;
      maxviol = 0;
      for (i = 0; i < 2 * (n + m); i++) {
        sum = d0[i];
        for (j = 0; j < 2 * (n + m); j++) {
          sum += d[i * 2 * (n + m) + j] * dual_old[j];
        }
        sum -= d[i * 2 * (n + m) + i] * dual_old[i];
        dual[i] = -sum / d[i * 2 * (n + m) + i];
        if (dual[i] < 0)
          dual[i] = 0;
        viol = fabs(dual[i] - dual_old[i]);
        if (viol > maxviol)
          maxviol = viol;
        dual_old[i] = dual[i];
      }
    }
    if (m > 0) {
      for (i = 0; i < n; i++) {
        temp[i] = dual[i] - dual[i + n] +
                  ce[i] * (dual[n + n] - dual[n + n + 1]) + g0[i];
      }
    } else {
      for (i = 0; i < n; i++) {
        temp[i] = dual[i] - dual[i + n] + g0[i];
      }
    }
    for (i = 0; i < n; i++) {
      primal[i] = 0;
      for (j = 0; j < n; j++) {
        primal[i] += ig[i * n + j] * temp[j];
      }
      primal[i] *= -1.0;
      if (primal[i] <= (low[i])) {
        primal[i] = low[i];
      } else if (primal[i] >= (up[i])) {
        primal[i] = up[i];
      }
    }
    if (m > 0)
      model_b = dual[n + n + 1] - dual[n + n];
    else
      model_b = 0;
    epsilon_hideo = 1E-20;
    for (i = 0; i < n; i++) {
      dist = -model_b * ce[i];
      dist += (g0[i] + 1.0);
      for (j = 0; j < i; j++) {
        dist += (primal[j] * g[j * n + i]);
      }
      for (j = i; j < n; j++) {
        dist += (primal[j] * g[i * n + j]);
      }
      if ((primal[i] < (up[i] - epsilon_hideo)) &&
          (dist < (1.0 - epsilon_crit))) {
        epsilon_hideo = (up[i] - primal[i]) * 2.0;
      } else if ((primal[i] > (low[i] + epsilon_hideo)) &&
                 (dist > (1.0 + epsilon_crit))) {
        epsilon_hideo = (primal[i] - low[i]) * 2.0;
      }
    }
    for (i = 0; i < n; i++) {
      if (primal[i] <= (low[i] + epsilon_hideo)) {
        primal[i] = low[i];
      } else if (primal[i] >= (up[i] - epsilon_hideo)) {
        primal[i] = up[i];
      }
    }
    retrain = 0;
    primal_optimal = 1;
    at_bound = 0;
    for (i = 0; (i < n); i++) {
      dist = -model_b * ce[i];
      dist += (g0[i] + 1.0);
      for (j = 0; j < i; j++) {
        dist += (primal[j] * g[j * n + i]);
      }
      for (j = i; j < n; j++) {
        dist += (primal[j] * g[i * n + j]);
      }
      if ((primal[i] < (up[i] - epsilon_a)) && (dist < (1.0 - epsilon_crit))) {
        retrain = 1;
        primal_optimal = 0;
      } else if ((primal[i] > (low[i] + epsilon_a)) &&
                 (dist > (1.0 + epsilon_crit))) {
        retrain = 1;
        primal_optimal = 0;
      }
      if ((primal[i] <= (low[i] + epsilon_a)) ||
          (primal[i] >= (up[i] - epsilon_a))) {
        at_bound++;
      }
    }
    if (m > 0) {
      eq = -ce0[0];
      for (i = 0; i < n; i++) {
        eq += (ce[i] * primal[i]);
      }
      if ((1E-5 < fabs(eq))) {
        retrain = 1;
        primal_optimal = 0;
      }
    }
    if (retrain) {
      precision /= 10;
      if (((goal == 1) && (maxfaktor < 50000)) || (maxfaktor < 5)) {
        maxfaktor++;
      }
    }
  }
  if (!primal_optimal) {
    for (i = 0; i < n; i++) {
      primal[i] = 0;
      for (j = 0; j < n; j++) {
        primal[i] += ig[i * n + j] * temp[j];
      }
      primal[i] *= -1.0;
      if (primal[i] <= (low[i] + epsilon_a)) {
        primal[i] = low[i];
      } else if (primal[i] >= (up[i] - epsilon_a)) {
        primal[i] = up[i];
      }
    }
  }
  isnantest = 0;
  for (i = 0; i < n; i++) {
    isnantest += primal[i];
  }
  if (m > 0) {
    temp1 = dual[n + n + 1];
    temp2 = dual[n + n];
    for (i = n + n + 1; i >= 2; i--) {
      dual[i] = dual[i - 2];
    }
    dual[0] = temp2;
    dual[1] = temp1;
    isnantest += temp1 + temp2;
  }
  if (isnan(isnantest)) {
    return ((int)4);
  } else if (primal_optimal) {
    return ((int)1);
  } else if (maxviol == 0.0) {
    return ((int)2);
  } else {
    return ((int)3);
  }
}


x86 assembly (clang, -O0):
<solve_dual>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
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),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
movq   $0x0,-0xc8(%rbp)
movsd  0x1e74(%rip),%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
cmpq   $0x0,-0x18(%rbp)
jl     11aa <solve_dual+0x8a>
cmpq   $0x1,-0x18(%rbp)
jle    11b8 <solve_dual+0x98>
lea    0x1e9f(%rip),%rdi
mov    $0x0,%al
call   1040 <perror@plt>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jge    120a <solve_dual+0xea>
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    11c0 <solve_dual+0xa0>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1757 <solve_dual+0x637>
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1361 <solve_dual+0x241>
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x58(%rbp),%rcx
add    -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x58(%rbp),%rcx
add    -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1228 <solve_dual+0x108>
cmpq   $0x0,-0x18(%rbp)
jle    1741 <solve_dual+0x621>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    13d0 <solve_dual+0x2b0>
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    137c <solve_dual+0x25c>
movsd  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
add    $0x1,%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
add    -0x50(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
add    $0x1,%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
add    -0x50(%rbp),%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1645 <solve_dual+0x525>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    162f <solve_dual+0x50f>
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x58(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    15ce <solve_dual+0x4ae>
jmp    1634 <solve_dual+0x514>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    15b8 <solve_dual+0x498>
movsd  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
add    $0x1,%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
add    $0x1,%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
mov    -0x10(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
jmp    1746 <solve_dual+0x626>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1212 <solve_dual+0xf2>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    183b <solve_dual+0x71b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    17d1 <solve_dual+0x6b1>
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    177d <solve_dual+0x65d>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x78(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
subsd  -0x78(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x10(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    175f <solve_dual+0x63f>
cmpq   $0x0,-0x18(%rbp)
jle    1937 <solve_dual+0x817>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    18e3 <solve_dual+0x7c3>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    18cd <solve_dual+0x7ad>
mov    -0x48(%rbp),%rax
mov    -0x60(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x60(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    186c <solve_dual+0x74c>
jmp    18d2 <solve_dual+0x7b2>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1856 <solve_dual+0x736>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x70(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
subsd  -0x70(%rbp),%xmm0
mov    0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x1,%rcx
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x16c9(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
movq   $0x0,-0x68(%rbp)
movq   $0x1,-0xb8(%rbp)
movq   $0x1,-0xc0(%rbp)
mov    -0x30(%rbp),%rax
mov    $0x5,%ecx
cqto
idiv   %rcx
mov    %rax,-0xd8(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0xb8(%rbp)
mov    %al,-0xf1(%rbp)
je     19c6 <solve_dual+0x8a6>
movsd  -0x80(%rbp),%xmm0
xor    %eax,%eax
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
mov    %al,-0xf1(%rbp)
jbe    19c6 <solve_dual+0x8a6>
mov    -0x68(%rbp),%rax
mov    -0xd8(%rbp),%rcx
imul   -0xc0(%rbp),%rcx
ff
cmp    %rcx,%rax
setl   %al
mov    %al,-0xf1(%rbp)
mov    -0xf1(%rbp),%al
test   $0x1,%al
jne    19d9 <solve_dual+0x8b9>
jmp    25a5 <solve_dual+0x1485>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
movsd  -0x80(%rbp),%xmm0
xor    %eax,%eax
ucomisd -0x20(%rbp),%xmm0
mov    %al,-0xf2(%rbp)
jbe    1a1c <solve_dual+0x8fc>
mov    -0x68(%rbp),%rax
mov    -0xd8(%rbp),%rcx
imul   -0xc0(%rbp),%rcx
ff
cmp    %rcx,%rax
setl   %al
mov    %al,-0xf2(%rbp)
mov    -0xf2(%rbp),%al
test   $0x1,%al
jne    1a2f <solve_dual+0x90f>
jmp    1c2c <solve_dual+0xb0c>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jge    1c27 <solve_dual+0xb07>
mov    0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x18(%rbp),%rcx
shl    $0x1,%rcx
cmp    %rcx,%rax
jge    1ae8 <solve_dual+0x9c8>
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1a7e <solve_dual+0x95e>
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x50(%rbp),%rcx
shl    $0x1,%rcx
mov    -0x10(%rbp),%rdx
add    -0x18(%rbp),%rdx
imul   %rdx,%rcx
add    -0x50(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    1baf <solve_dual+0xa8f>
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movaps 0x1470(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0x80(%rbp),%xmm0
jbe    1bfc <solve_dual+0xadc>
movsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1a4b <solve_dual+0x92b>
jmp    19e5 <solve_dual+0x8c5>
cmpq   $0x0,-0x18(%rbp)
jle    1cd3 <solve_dual+0xbb3>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1cce <solve_dual+0xbae>
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x10(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
subsd  0x8(%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1c3f <solve_dual+0xb1f>
jmp    1d37 <solve_dual+0xc17>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1d32 <solve_dual+0xc12>
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
add    -0x10(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1cdb <solve_dual+0xbbb>
jmp    1d37 <solve_dual+0xc17>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1e73 <solve_dual+0xd53>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1dc1 <solve_dual+0xca1>
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1d65 <solve_dual+0xc45>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0x123f(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1e1e <solve_dual+0xcfe>
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e5d <solve_dual+0xd3d>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jb     1e58 <solve_dual+0xd38>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1e5d <solve_dual+0xd3d>
jmp    1e62 <solve_dual+0xd42>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1d3f <solve_dual+0xc1f>
cmpq   $0x0,-0x18(%rbp)
jle    1eae <solve_dual+0xd8e>
mov    0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1eb9 <solve_dual+0xd99>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x1157(%rip),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    210e <solve_dual+0xfee>
movsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0x110d(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x50(%rbp),%rax
jge    1f9a <solve_dual+0xe7a>
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1f40 <solve_dual+0xe20>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1ffc <solve_dual+0xedc>
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    1fa2 <solve_dual+0xe82>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xe8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    207a <solve_dual+0xf5a>
movsd  -0xb0(%rbp),%xmm1
ff
movsd  0xff8(%rip),%xmm0
subsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    207a <solve_dual+0xf5a>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xfcf(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    20f8 <solve_dual+0xfd8>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0xe8(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    20f3 <solve_dual+0xfd3>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  0xf7a(%rip),%xmm1
addsd  -0x28(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    20f3 <solve_dual+0xfd3>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  0xf51(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
jmp    20f8 <solve_dual+0xfd8>
jmp    20fd <solve_dual+0xfdd>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1ed1 <solve_dual+0xdb1>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    21d0 <solve_dual+0x10b0>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xe8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     216f <solve_dual+0x104f>
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    21ba <solve_dual+0x109a>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xe8(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jb     21b5 <solve_dual+0x1095>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    21ba <solve_dual+0x109a>
jmp    21bf <solve_dual+0x109f>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    2116 <solve_dual+0xff6>
movq   $0x0,-0xb8(%rbp)
movq   $0x1,-0xc8(%rbp)
movq   $0x0,-0xd0(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    2470 <solve_dual+0x1350>
movsd  -0xa8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0xde5(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x50(%rbp),%rax
jge    22c2 <solve_dual+0x11a2>
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    2268 <solve_dual+0x1148>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    2324 <solve_dual+0x1204>
mov    0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    22ca <solve_dual+0x11aa>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0xe0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    238a <solve_dual+0x126a>
movsd  -0xb0(%rbp),%xmm1
ff
movsd  0xcd0(%rip),%xmm0
subsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    238a <solve_dual+0x126a>
movq   $0x1,-0xb8(%rbp)
movq   $0x0,-0xc8(%rbp)
jmp    23f0 <solve_dual+0x12d0>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
addsd  -0xe0(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jbe    23eb <solve_dual+0x12cb>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  0xc6a(%rip),%xmm1
addsd  -0x28(%rbp),%xmm1
ucomisd %xmm1,%xmm0
jbe    23eb <solve_dual+0x12cb>
movq   $0x1,-0xb8(%rbp)
movq   $0x0,-0xc8(%rbp)
jmp    23f0 <solve_dual+0x12d0>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    2448 <solve_dual+0x1328>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xe0(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jb     245a <solve_dual+0x133a>
mov    -0xd0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xd0(%rbp)
jmp    245f <solve_dual+0x133f>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    21f9 <solve_dual+0x10d9>
cmpq   $0x0,-0x18(%rbp)
jle    253b <solve_dual+0x141b>
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    24fb <solve_dual+0x13db>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    24aa <solve_dual+0x138a>
movsd  -0xf0(%rbp),%xmm0
ff
movaps 0xb36(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xb0a(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    2536 <solve_dual+0x1416>
movq   $0x1,-0xb8(%rbp)
movq   $0x0,-0xc8(%rbp)
jmp    253b <solve_dual+0x141b>
cmpq   $0x0,-0xb8(%rbp)
je     25a0 <solve_dual+0x1480>
movsd  -0x20(%rbp),%xmm0
movsd  0xad2(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
cmpq   $0x1,0x60(%rbp)
jne    257b <solve_dual+0x145b>
cmpq   $0xc350,-0xc0(%rbp)
jl     2589 <solve_dual+0x1469>
cmpq   $0x5,-0xc0(%rbp)
05
jge    259b <solve_dual+0x147b>
mov    -0xc0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0xc0(%rbp)
jmp    25a0 <solve_dual+0x1480>
jmp    1977 <solve_dual+0x857>
cmpq   $0x0,-0xc8(%rbp)
jne    2708 <solve_dual+0x15e8>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    2703 <solve_dual+0x15e3>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movq   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    263d <solve_dual+0x151d>
mov    0x40(%rbp),%rax
mov    -0x50(%rbp),%rcx
imul   -0x10(%rbp),%rcx
add    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    25e1 <solve_dual+0x14c1>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0x9c3(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xe0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jb     26a2 <solve_dual+0x1582>
mov    0x18(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    26ed <solve_dual+0x15cd>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
subsd  -0xe0(%rbp),%xmm1
ff
ucomisd %xmm1,%xmm0
jb     26e8 <solve_dual+0x15c8>
mov    0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    26ed <solve_dual+0x15cd>
jmp    26f2 <solve_dual+0x15d2>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    25bb <solve_dual+0x149b>
jmp    2708 <solve_dual+0x15e8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    2757 <solve_dual+0x1637>
mov    0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    271b <solve_dual+0x15fb>
cmpq   $0x0,-0x18(%rbp)
jle    2820 <solve_dual+0x1700>
mov    0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x10(%rbp),%rax
add    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
cmpq   $0x2,-0x50(%rbp)
jl     27df <solve_dual+0x16bf>
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x50(%rbp)
jmp    27a5 <solve_dual+0x1685>
movsd  -0x98(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    $0x1,%al
call   1030 <isnan@plt>
cmp    $0x0,%eax
je     2844 <solve_dual+0x1724>
movl   $0x4,-0x4(%rbp)
jmp    2889 <solve_dual+0x1769>
cmpq   $0x0,-0xc8(%rbp)
je     285e <solve_dual+0x173e>
movl   $0x1,-0x4(%rbp)
jmp    2889 <solve_dual+0x1769>
movsd  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2882 <solve_dual+0x1762>
jp     2882 <solve_dual+0x1762>
movl   $0x2,-0x4(%rbp)
jmp    2889 <solve_dual+0x1769>
movl   $0x3,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solve_dual>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,%r14
mov    %r8,%r12
mov    %rcx,0x88(%rsp)
mov    %rdx,0x60(%rsp)
movsd  %xmm1,0x70(%rsp)
movapd %xmm0,%xmm1
mov    %rdi,%r15
mov    %rsi,0x40(%rsp)
cmp    $0x2,%rsi
movsd  %xmm0,0x38(%rsp)
jb     1186 <solve_dual+0x56>
lea    0x1edf(%rip),%rdi
xor    %eax,%eax
call   1050 <perror@plt>
movsd  0x38(%rsp),%xmm1
mov    0x190(%rsp),%r11
mov    0x188(%rsp),%rbx
mov    0x40(%rsp),%rax
add    %r15,%rax
lea    (%rax,%rax,1),%rcx
mov    %rcx,0x90(%rsp)
mov    %rax,0xd0(%rsp)
test   %rax,%rax
jle    1388 <solve_dual+0x258>
mov    0x90(%rsp),%rcx
cmp    $0x2,%rcx
mov    $0x1,%eax
cmovge %rcx,%rax
cmp    $0x4,%rax
jb     11f0 <solve_dual+0xc0>
lea    (%r11,%rax,8),%rcx
cmp    %rbx,%rcx
jbe    1294 <solve_dual+0x164>
lea    (%rbx,%rax,8),%rcx
cmp    %r11,%rcx
jbe    1294 <solve_dual+0x164>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rcx
and    $0x3,%rcx
je     122a <solve_dual+0xfa>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%rbx,%rdx,8)
movq   $0x0,(%r11,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1210 <solve_dual+0xe0>
cmp    $0x3,%rsi
jb     1388 <solve_dual+0x258>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movq   $0x0,(%rbx,%rdx,8)
movq   $0x0,(%r11,%rdx,8)
movq   $0x0,0x8(%rbx,%rdx,8)
movq   $0x0,0x8(%r11,%rdx,8)
movq   $0x0,0x10(%rbx,%rdx,8)
movq   $0x0,0x10(%r11,%rdx,8)
movq   $0x0,0x18(%rbx,%rdx,8)
movq   $0x0,0x18(%r11,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1240 <solve_dual+0x110>
jmp    1388 <solve_dual+0x258>
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
mov    %rax,%rdx
and    %rcx,%rdx
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rbp
jae    12c5 <solve_dual+0x195>
xor    %ebp,%ebp
jmp    1340 <solve_dual+0x210>
and    %rcx,%rdi
xor    %ebp,%ebp
xorpd  %xmm0,%xmm0
xchg   %ax,%ax
movupd %xmm0,(%rbx,%rbp,8)
movupd %xmm0,0x10(%rbx,%rbp,8)
movupd %xmm0,(%r11,%rbp,8)
movupd %xmm0,0x10(%r11,%rbp,8)
movupd %xmm0,0x20(%rbx,%rbp,8)
movupd %xmm0,0x30(%rbx,%rbp,8)
movupd %xmm0,0x20(%r11,%rbp,8)
movupd %xmm0,0x30(%r11,%rbp,8)
movupd %xmm0,0x40(%rbx,%rbp,8)
movupd %xmm0,0x50(%rbx,%rbp,8)
movupd %xmm0,0x40(%r11,%rbp,8)
movupd %xmm0,0x50(%r11,%rbp,8)
movupd %xmm0,0x60(%rbx,%rbp,8)
movupd %xmm0,0x70(%rbx,%rbp,8)
movupd %xmm0,0x60(%r11,%rbp,8)
movupd %xmm0,0x70(%r11,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    12d0 <solve_dual+0x1a0>
test   %rsi,%rsi
je     137f <solve_dual+0x24f>
lea    (%r11,%rbp,8),%rcx
add    $0x10,%rcx
lea    (%rbx,%rbp,8),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
xorpd  %xmm0,%xmm0
nop
movupd %xmm0,-0x10(%rdi,%rbp,1)
movupd %xmm0,(%rdi,%rbp,1)
movupd %xmm0,-0x10(%rcx,%rbp,1)
movupd %xmm0,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1360 <solve_dual+0x230>
cmp    %rdx,%rax
jne    11f2 <solve_dual+0xc2>
test   %r15,%r15
mov    %r12,0x10(%rsp)
jle    186c <solve_dual+0x73c>
lea    (%r15,%r15,1),%rax
mov    %rax,0x30(%rsp)
lea    0x0(,%r15,4),%rax
mov    0xd0(%rsp),%rdx
imul   %rdx,%rax
lea    0x2(,%r15,4),%rcx
imul   %rdx,%rcx
lea    (%rax,%r15,2),%rsi
mov    %rsi,0x20(%rsp)
mov    %rax,0x28(%rsp)
lea    (%rax,%r15,2),%rax
add    $0x1,%rax
mov    %rax,0x18(%rsp)
lea    (%rcx,%r15,2),%rax
mov    %rax,0xc0(%rsp)
mov    %rcx,0xc8(%rsp)
lea    0x1(%rcx,%r15,2),%rax
mov    %rax,0x78(%rsp)
lea    -0x1(%r15),%rax
mov    %rax,0x58(%rsp)
mov    %r15d,%ecx
and    $0x3,%ecx
mov    %r15,%r10
and    $0xfffffffffffffffc,%r10
mov    %r15,%r12
and    $0xfffffffffffffffe,%r12
mov    0x90(%rsp),%rax
add    $0x1,%rax
imul   %r15,%rax
mov    0x170(%rsp),%rbx
lea    (%rbx,%rax,8),%r9
mov    %rdx,%rax
shl    $0x4,%rax
mov    %rax,0x50(%rsp)
mov    %r15,%rbp
imul   %rdx,%rbp
shl    $0x4,%rbp
add    %rbx,%rbp
lea    (%rbx,%r15,8),%r8
movaps 0x1baa(%rip),%xmm1
movapd 0x1ba2(%rip),%xmm0
lea    0x0(,%r15,8),%r13
mov    0x180(%rsp),%rdi
lea    0x8(%rdi),%rax
mov    %rax,0x80(%rsp)
xor    %edx,%edx
mov    %r10,0x48(%rsp)
mov    %rcx,0xb8(%rsp)
mov    %r13,0xb0(%rsp)
jmp    150e <solve_dual+0x3de>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x170(%rsp),%rax
mov    0x20(%rsp),%rcx
movsd  %xmm2,(%rax,%rcx,8)
movapd %xmm2,%xmm3
xorpd  %xmm0,%xmm3
mov    0x18(%rsp),%rcx
movlpd %xmm3,(%rax,%rcx,8)
mov    0xc0(%rsp),%rcx
movlpd %xmm3,(%rax,%rcx,8)
mov    0x78(%rsp),%rcx
movsd  %xmm2,(%rax,%rcx,8)
mov    0x48(%rsp),%r10
mov    0xb8(%rsp),%rcx
mov    0x68(%rsp),%rdx
add    $0x1,%rdx
mov    0x50(%rsp),%rax
add    %rax,%r9
add    %rax,%rbp
add    %rax,%r8
add    %rax,%rbx
add    %r13,%rdi
cmp    %r15,%rdx
je     173f <solve_dual+0x60f>
xor    %eax,%eax
movsd  (%rdi,%rax,8),%xmm2
movsd  %xmm2,(%rbx,%rax,8)
movsd  (%rdi,%rax,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,0x0(%rbp,%rax,8)
movsd  (%rdi,%rax,8),%xmm2
xorps  %xmm1,%xmm2
movlps %xmm2,(%r8,%rax,8)
movsd  (%rdi,%rax,8),%xmm2
movsd  %xmm2,(%r9,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1510 <solve_dual+0x3e0>
cmpq   $0x0,0x40(%rsp)
jle    14ed <solve_dual+0x3bd>
cmpq   $0x3,0x58(%rsp)
jae    1560 <solve_dual+0x430>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
jmp    15bb <solve_dual+0x48b>
xorpd  %xmm2,%xmm2
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm3
movsd  0x8(%r14,%rax,8),%xmm4
mulsd  (%rdi,%rax,8),%xmm3
mulsd  0x8(%rdi,%rax,8),%xmm4
addsd  %xmm2,%xmm3
movsd  0x10(%r14,%rax,8),%xmm5
mulsd  0x10(%rdi,%rax,8),%xmm5
addsd  %xmm3,%xmm4
movsd  0x18(%r14,%rax,8),%xmm2
mulsd  0x18(%rdi,%rax,8),%xmm2
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm2
add    $0x4,%rax
cmp    %rax,%r10
jne    1570 <solve_dual+0x440>
mov    %rdx,0x68(%rsp)
test   %rcx,%rcx
je     15e7 <solve_dual+0x4b7>
lea    (%rdi,%rax,8),%rdx
lea    (%r14,%rax,8),%rax
xor    %esi,%esi
nop
movsd  (%rax,%rsi,8),%xmm3
mulsd  (%rdx,%rsi,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    15d0 <solve_dual+0x4a0>
mov    0x90(%rsp),%rdx
mov    %rdx,%rax
mov    0x68(%rsp),%r10
imul   %r10,%rax
mov    0x30(%rsp),%rsi
add    %rsi,%rax
mov    0x170(%rsp),%rcx
movsd  %xmm2,(%rcx,%rax,8)
shl    $0x3,%rax
movapd %xmm2,%xmm3
xorpd  %xmm0,%xmm3
or     $0x8,%rax
movlpd %xmm3,(%rcx,%rax,1)
lea    (%r10,%r15,1),%rax
imul   %rax,%rdx
add    %rsi,%rdx
movlpd %xmm3,(%rcx,%rdx,8)
shl    $0x3,%rdx
or     $0x8,%rdx
movsd  %xmm2,(%rcx,%rdx,1)
mov    0x28(%rsp),%rsi
lea    (%r10,%rsi,1),%rdx
movsd  %xmm2,(%rcx,%rdx,8)
mov    0xc8(%rsp),%r13
lea    (%r10,%r13,1),%rdx
mov    0x170(%rsp),%rcx
movlpd %xmm3,(%rcx,%rdx,8)
lea    (%rax,%rsi,1),%rdx
mov    0x170(%rsp),%rsi
movlpd %xmm3,(%rsi,%rdx,8)
mov    %rsi,%rdx
add    %r13,%rax
movsd  %xmm2,(%rsi,%rax,8)
xorpd  %xmm2,%xmm2
mov    0x80(%rsp),%rdx
xor    %eax,%eax
mov    0xb0(%rsp),%r13
jmp    16b0 <solve_dual+0x580>
nopl   (%rax)
add    $0x1,%rax
add    %r13,%rdx
cmp    %r15,%rax
je     14a0 <solve_dual+0x370>
movsd  (%r14,%rax,8),%xmm3
cmpq   $0x0,0x58(%rsp)
je     1710 <solve_dual+0x5e0>
xor    %r10d,%r10d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%r10,8),%xmm4
mulsd  %xmm3,%xmm4
mulsd  -0x8(%rdx,%r10,8),%xmm4
addsd  %xmm2,%xmm4
movsd  0x8(%r14,%r10,8),%xmm2
mulsd  %xmm3,%xmm2
mulsd  (%rdx,%r10,8),%xmm2
addsd  %xmm4,%xmm2
add    $0x2,%r10
cmp    %r10,%r12
jne    16d0 <solve_dual+0x5a0>
test   $0x1,%r15b
je     16a0 <solve_dual+0x570>
jmp    1719 <solve_dual+0x5e9>
nopl   0x0(%rax,%rax,1)
xor    %r10d,%r10d
test   $0x1,%r15b
je     16a0 <solve_dual+0x570>
mov    %rax,%rsi
imul   %r15,%rsi
mulsd  (%r14,%r10,8),%xmm3
add    %r10,%rsi
mov    0x180(%rsp),%rcx
mulsd  (%rcx,%rsi,8),%xmm3
addsd  %xmm3,%xmm2
jmp    16a0 <solve_dual+0x570>
test   %r15,%r15
mov    0x10(%rsp),%r12
movsd  0x38(%rsp),%xmm1
jle    186c <solve_dual+0x73c>
mov    %r15d,%edi
and    $0x3,%edi
mov    0x180(%rsp),%r8
lea    0x18(%r8),%rdx
xor    %eax,%eax
jmp    17c5 <solve_dual+0x695>
nopl   0x0(%rax)
mov    0x160(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm2
addsd  %xmm1,%xmm2
mov    0x178(%rsp),%rsi
movsd  %xmm2,(%rsi,%rax,8)
mov    0x158(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm2
xorpd  %xmm0,%xmm2
subsd  %xmm1,%xmm2
lea    (%rax,%r15,1),%rcx
movsd  %xmm2,(%rsi,%rcx,8)
add    $0x1,%rax
add    %r13,%rdx
add    %r13,%r8
cmp    %r15,%rax
movsd  0x38(%rsp),%xmm1
je     186c <solve_dual+0x73c>
cmpq   $0x3,0x58(%rsp)
jae    17e0 <solve_dual+0x6b0>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
jmp    183b <solve_dual+0x70b>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  -0x18(%rdx,%rbp,8),%xmm2
movsd  -0x10(%rdx,%rbp,8),%xmm3
mulsd  (%r12,%rbp,8),%xmm2
mulsd  0x8(%r12,%rbp,8),%xmm3
addsd  %xmm1,%xmm2
movsd  -0x8(%rdx,%rbp,8),%xmm4
mulsd  0x10(%r12,%rbp,8),%xmm4
addsd  %xmm2,%xmm3
movsd  (%rdx,%rbp,8),%xmm1
mulsd  0x18(%r12,%rbp,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rbp
cmp    %rbp,%r10
jne    17f0 <solve_dual+0x6c0>
test   %rdi,%rdi
je     1770 <solve_dual+0x640>
lea    (%r12,%rbp,8),%rbx
lea    (%r8,%rbp,8),%rcx
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rcx,%rsi,8),%xmm2
mulsd  (%rbx,%rsi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1850 <solve_dual+0x720>
jmp    1770 <solve_dual+0x640>
cmpq   $0x0,0x40(%rsp)
jle    1956 <solve_dual+0x826>
test   %r15,%r15
jle    196c <solve_dual+0x83c>
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    %r15,%rdx
shl    $0x4,%rdx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x180(%rsp),%r8
mov    0x188(%rsp),%r13
jmp    18c1 <solve_dual+0x791>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x8,%r8
cmp    %r15,%rsi
je     1978 <solve_dual+0x848>
movsd  (%r12,%rsi,8),%xmm1
cmp    $0x1,%r15
jne    18e0 <solve_dual+0x7b0>
xor    %edi,%edi
jmp    1929 <solve_dual+0x7f9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8,%rbp
xor    %edi,%edi
movapd %xmm0,%xmm2
nopl   0x0(%rax)
movsd  (%r14,%rdi,8),%xmm3
movsd  0x8(%r14,%rdi,8),%xmm0
mulsd  0x0(%rbp),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
mulsd  0x0(%rbp,%r15,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm3,%xmm0
add    $0x2,%rdi
add    %rdx,%rbp
movapd %xmm0,%xmm2
cmp    %rdi,%rax
jne    18f0 <solve_dual+0x7c0>
test   $0x1,%r15b
je     18b0 <solve_dual+0x780>
movsd  (%r14,%rdi,8),%xmm2
imul   %r15,%rdi
add    %rsi,%rdi
mov    0x180(%rsp),%rcx
mulsd  (%rcx,%rdi,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
jmp    18b0 <solve_dual+0x780>
lea    (%r15,%r15,1),%rsi
lea    (%r15,%r15,1),%rbp
add    $0x1,%rbp
mov    0x188(%rsp),%r13
jmp    19c4 <solve_dual+0x894>
xorpd  %xmm0,%xmm0
mov    0x188(%rsp),%r13
mov    0x150(%rsp),%rdx
movsd  (%rdx),%xmm1
addsd  %xmm0,%xmm1
mov    %r15,%rax
shl    $0x4,%rax
mov    0x178(%rsp),%rcx
movsd  %xmm1,(%rcx,%rax,1)
movsd  (%rdx),%xmm1
xorpd  0x1658(%rip),%xmm1
lea    (%r15,%r15,1),%rsi
subsd  %xmm0,%xmm1
lea    (%r15,%r15,1),%rbp
add    $0x1,%rbp
movsd  %xmm1,0x8(%rcx,%rsi,8)
movsd  0x38(%rsp),%xmm1
mov    0x198(%rsp),%r8
movabs $0x6666666666666667,%rcx
66 66 66
mov    0x60(%rsp),%rdi
mov    %rdi,%rax
imul   %rcx
lea    0x0(,%rsi,8),%r9
add    %r13,%r9
lea    0x0(,%rbp,8),%rcx
add    %r13,%rcx
mov    0x90(%rsp),%rax
cmp    $0x2,%rax
mov    $0x1,%ebx
cmovge %rax,%rbx
cmp    $0x5,%rdi
mov    %rbp,0xa8(%rsp)
mov    %r9,0x20(%rsp)
mov    %rcx,0x18(%rsp)
jl     27d0 <solve_dual+0x16a0>
mov    %rdx,%rax
shr    $0x3f,%rax
sar    %rdx
add    %rax,%rdx
mov    %rdx,0xd8(%rsp)
movsd  0x15da(%rip),%xmm14
movapd %xmm14,%xmm15
movsd  0x70(%rsp),%xmm8
subsd  %xmm8,%xmm15
addsd  %xmm14,%xmm8
lea    (%r8,%r15,8),%rax
mov    %rax,0x30(%rsp)
lea    0x8(,%rbp,8),%rax
add    %r13,%rax
mov    %rax,0x38(%rsp)
shl    $0x3,%rsi
or     $0x8,%rsi
add    %r13,%rsi
mov    %r15,%rax
shl    $0x4,%rax
mov    %rax,0x50(%rsp)
add    %r13,%rax
mov    %r8,%rdi
mov    %ebx,%r8d
and    $0x3,%r8d
movabs $0x7ffffffffffffffc,%r10
ff ff 7f
and    %rbx,%r10
cmp    %rdi,%rax
seta   %al
lea    (%r14,%r15,8),%rdx
mov    %rdx,0x48(%rsp)
cmp    %rdi,%r13
mov    %r12,%rdx
setb   %r12b
and    %al,%r12b
lea    0x0(,%r15,8),%rax
add    %r13,%rax
mov    %rax,0x78(%rsp)
cmp    %rdi,%rax
mov    %rdi,%rbp
seta   %al
lea    (%rdx,%r15,8),%r9
mov    0x30(%rsp),%rcx
cmp    %r13,%rcx
seta   %dil
and    %al,%dil
cmp    %rbp,%r9
seta   %bpl
mov    %rbx,0x58(%rsp)
lea    -0x1(%rbx),%rax
mov    %rax,0x68(%rsp)
cmp    %rdx,%rcx
mov    %rcx,%r9
seta   %al
lea    -0x1(%r15),%rbx
mov    %rbx,0x60(%rsp)
and    %bpl,%al
mov    %edi,%ecx
or     %al,%cl
or     %r12b,%cl
mov    %cl,0xe(%rsp)
mov    %r15,%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0xe0(%rsp)
mov    0x198(%rsp),%rbx
cmp    %rbx,0x38(%rsp)
seta   %dl
cmp    %r9,0x18(%rsp)
setb   %cl
and    %dl,%cl
cmp    %rbx,%rsi
mov    %rbx,%rbp
seta   %sil
cmp    %r9,0x20(%rsp)
setb   %bl
and    %sil,%bl
or     %r12b,%cl
or     %dil,%cl
or     %bl,%cl
cmp    %rbp,0x48(%rsp)
seta   %dl
cmp    %r14,%r9
seta   %bl
and    %dl,%bl
or     %al,%bl
or     %cl,%bl
mov    %bl,0xf(%rsp)
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x70(%rsp)
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,0x110(%rsp)
mov    0x170(%rsp),%rax
add    $0x18,%rax
mov    %rax,0xc0(%rsp)
mov    0xd0(%rsp),%r9
shl    $0x4,%r9
lea    0x10(%r13),%rax
mov    %rax,0x100(%rsp)
lea    0x0(,%r15,8),%rax
mov    %rax,0x48(%rsp)
movsd  0x144b(%rip),%xmm10
movapd 0x141b(%rip),%xmm2
xorpd  %xmm11,%xmm11
movapd 0x141e(%rip),%xmm4
movsd  0x143d(%rip),%xmm13
movsd  0x143c(%rip),%xmm12
lea    0x8(%rbp),%rax
mov    %rax,0xf8(%rsp)
mov    0x10(%rsp),%rax
lea    0x8(%rax),%rax
mov    %rax,0xf0(%rsp)
lea    0x8(%r13),%rax
mov    %rax,0xe8(%rsp)
mov    0x180(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x108(%rsp)
lea    0x8(,%r15,8),%rax
mov    %rax,0x38(%rsp)
mov    0xd8(%rsp),%rax
mov    %rax,0x30(%rsp)
xor    %r12d,%r12d
mov    $0x1,%eax
mov    %rax,0x80(%rsp)
mov    %r9,0xc8(%rsp)
jmp    1c85 <solve_dual+0xb55>
cs nopw 0x0(%rax,%rax,1)
nop
xorpd  %xmm10,%xmm10
add    $0x1,%r12
ucomisd %xmm1,%xmm10
jbe    1dfd <solve_dual+0xccd>
cmp    0x30(%rsp),%r12
mov    0x168(%rsp),%rcx
jge    1e05 <solve_dual+0xcd5>
cmpq   $0x0,0xd0(%rsp)
jle    1c80 <solve_dual+0xb50>
xorpd  %xmm3,%xmm3
mov    0x170(%rsp),%rsi
mov    0xc0(%rsp),%rdi
xor    %eax,%eax
jmp    1d3a <solve_dual+0xc0a>
nopw   0x0(%rax,%rax,1)
add    %rax,%rbx
mov    0x170(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  (%r11,%rax,8),%xmm6
mulsd  %xmm0,%xmm6
subsd  %xmm6,%xmm5
xorpd  %xmm2,%xmm5
divsd  %xmm0,%xmm5
xorpd  %xmm0,%xmm0
maxsd  %xmm5,%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movapd %xmm0,%xmm10
subsd  (%r11,%rax,8),%xmm10
andpd  %xmm4,%xmm10
maxsd  %xmm3,%xmm10
movsd  %xmm0,(%r11,%rax,8)
add    $0x1,%rax
add    %r9,%rdi
add    %r9,%rsi
movapd %xmm10,%xmm3
cmp    0x58(%rsp),%rax
je     1c85 <solve_dual+0xb55>
mov    0x178(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm5
cmpq   $0x3,0x68(%rsp)
jae    1d60 <solve_dual+0xc30>
xor    %ebp,%ebp
jmp    1dbb <solve_dual+0xc8b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x18(%rdi,%rbp,8),%xmm0
movsd  -0x10(%rdi,%rbp,8),%xmm6
mulsd  (%r11,%rbp,8),%xmm0
mulsd  0x8(%r11,%rbp,8),%xmm6
addsd  %xmm5,%xmm0
movsd  -0x8(%rdi,%rbp,8),%xmm7
mulsd  0x10(%r11,%rbp,8),%xmm7
addsd  %xmm0,%xmm6
movsd  (%rdi,%rbp,8),%xmm5
mulsd  0x18(%r11,%rbp,8),%xmm5
addsd  %xmm6,%xmm7
addsd  %xmm7,%xmm5
add    $0x4,%rbp
cmp    %rbp,%r10
jne    1d70 <solve_dual+0xc40>
mov    0x90(%rsp),%rbx
imul   %rax,%rbx
test   %r8,%r8
je     1cd0 <solve_dual+0xba0>
lea    (%r11,%rbp,8),%rcx
lea    (%rsi,%rbp,8),%rbp
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1de0 <solve_dual+0xcb0>
jmp    1cd0 <solve_dual+0xba0>
mov    0x168(%rsp),%rcx
cmpq   $0x0,0x40(%rsp)
mov    %r12,0xb0(%rsp)
jle    1e3c <solve_dual+0xd0c>
test   %r15,%r15
mov    0x198(%rsp),%rdx
jle    217b <solve_dual+0x104b>
cmp    $0x1,%r15
sete   %al
or     0xf(%rsp),%al
test   $0x1,%al
je     1e6d <solve_dual+0xd3d>
xor    %eax,%eax
jmp    1ef0 <solve_dual+0xdc0>
test   %r15,%r15
mov    0x198(%rsp),%rdx
mov    0x100(%rsp),%rbx
jle    2ad1 <solve_dual+0x19a1>
cmp    $0x4,%r15
setb   %al
or     0xe(%rsp),%al
je     1f42 <solve_dual+0xe12>
xor    %eax,%eax
jmp    1fb1 <solve_dual+0xe81>
mov    0x20(%rsp),%rax
movsd  (%rax),%xmm3
mov    0x18(%rsp),%rax
subsd  (%rax),%xmm3
unpcklpd %xmm3,%xmm3
xor    %eax,%eax
mov    0x10(%rsp),%rcx
mov    0x78(%rsp),%rsi
mov    0x70(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x0(%r13,%rax,8),%xmm0
movupd (%rsi,%rax,8),%xmm5
subpd  %xmm5,%xmm0
movupd (%r14,%rax,8),%xmm5
mulpd  %xmm3,%xmm5
addpd  %xmm0,%xmm5
movupd (%rcx,%rax,8),%xmm0
addpd  %xmm5,%xmm0
movupd %xmm0,(%rdx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1ea0 <solve_dual+0xd70>
mov    %rdi,%rax
cmp    %r15,%rdi
je     2066 <solve_dual+0xf36>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x78(%rsp),%rcx
subsd  (%rcx,%rax,8),%xmm0
mov    0x20(%rsp),%rcx
movsd  (%rcx),%xmm3
mov    0x18(%rsp),%rcx
subsd  (%rcx),%xmm3
mulsd  (%r14,%rax,8),%xmm3
addsd  %xmm0,%xmm3
mov    0x10(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm3
mov    0x198(%rsp),%rcx
movsd  %xmm3,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r15
jne    1ef0 <solve_dual+0xdc0>
jmp    2066 <solve_dual+0xf36>
xor    %eax,%eax
mov    0x10(%rsp),%rcx
mov    0x78(%rsp),%rsi
mov    0xe0(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movupd -0x10(%rbx,%rax,8),%xmm0
movupd (%rbx,%rax,8),%xmm3
movupd (%rsi,%rax,8),%xmm5
subpd  %xmm5,%xmm0
movupd 0x10(%rsi,%rax,8),%xmm5
subpd  %xmm5,%xmm3
movupd (%rcx,%rax,8),%xmm5
addpd  %xmm0,%xmm5
movupd 0x10(%rcx,%rax,8),%xmm0
addpd  %xmm3,%xmm0
movupd %xmm5,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1f60 <solve_dual+0xe30>
mov    %rdi,%rax
cmp    %r15,%rdi
je     2066 <solve_dual+0xf36>
mov    %rax,%rcx
test   $0x1,%r15b
je     1fea <solve_dual+0xeba>
movsd  0x0(%r13,%rax,8),%xmm0
lea    (%rax,%r15,1),%rcx
subsd  0x0(%r13,%rcx,8),%xmm0
mov    0x10(%rsp),%rcx
addsd  (%rcx,%rax,8),%xmm0
mov    0x198(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
mov    %rax,%rcx
or     $0x1,%rcx
cmp    %rax,0x60(%rsp)
je     2066 <solve_dual+0xf36>
mov    %r15,%r12
sub    %rcx,%r12
mov    0xf8(%rsp),%rax
lea    (%rax,%rcx,8),%rsi
mov    0xf0(%rsp),%rax
lea    (%rax,%rcx,8),%rdi
lea    (%r15,%rcx,1),%rax
mov    0xe8(%rsp),%rdx
lea    (%rdx,%rax,8),%rbx
lea    (%rdx,%rcx,8),%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rbp,%rax,8),%xmm0
subsd  -0x8(%rbx,%rax,8),%xmm0
addsd  -0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%rsi,%rax,8)
movsd  0x0(%rbp,%rax,8),%xmm0
subsd  (%rbx,%rax,8),%xmm0
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r12
jne    2030 <solve_dual+0xf00>
test   %r15,%r15
mov    0x158(%rsp),%r12
mov    0x168(%rsp),%rcx
mov    0x198(%rsp),%rbp
mov    0x60(%rsp),%r13
mov    0x70(%rsp),%rbx
jle    2173 <solve_dual+0x1043>
mov    0x108(%rsp),%rax
xor    %esi,%esi
jmp    20b7 <solve_dual+0xf87>
nopl   (%rax)
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
add    0x48(%rsp),%rax
cmp    %r15,%rsi
je     2173 <solve_dual+0x1043>
movq   $0x0,(%rcx,%rsi,8)
xorpd  %xmm3,%xmm3
xor    %edi,%edi
test   %r13,%r13
je     2102 <solve_dual+0xfd2>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rax,%rdi,8),%xmm0
mulsd  0x0(%rbp,%rdi,8),%xmm0
addsd  %xmm3,%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
movsd  (%rax,%rdi,8),%xmm3
mulsd  0x8(%rbp,%rdi,8),%xmm3
addsd  %xmm0,%xmm3
movsd  %xmm3,(%rcx,%rsi,8)
add    $0x2,%rdi
cmp    %rdi,%rbx
jne    20d0 <solve_dual+0xfa0>
test   $0x1,%r15b
je     2136 <solve_dual+0x1006>
mov    %rsi,%rcx
imul   %r15,%rcx
add    %rdi,%rcx
mov    0x180(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
mov    0x168(%rsp),%rcx
mulsd  0x0(%rbp,%rdi,8),%xmm0
addsd  %xmm0,%xmm3
movsd  %xmm3,(%rcx,%rsi,8)
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rcx,%rsi,8)
movsd  (%r12,%rsi,8),%xmm0
ucomisd %xmm3,%xmm0
jae    20a0 <solve_dual+0xf70>
mov    0x160(%rsp),%rcx
movsd  (%rcx,%rsi,8),%xmm0
mov    0x168(%rsp),%rcx
ucomisd %xmm0,%xmm3
jae    20a0 <solve_dual+0xf70>
jmp    20a5 <solve_dual+0xf75>
cmpq   $0x0,0x40(%rsp)
jle    218f <solve_dual+0x105f>
mov    0x18(%rsp),%rax
movsd  (%rax),%xmm5
mov    0x20(%rsp),%rax
subsd  (%rax),%xmm5
jmp    2193 <solve_dual+0x1063>
xorpd  %xmm5,%xmm5
mov    $0x1,%r13d
test   %r15,%r15
movapd %xmm1,%xmm9
mov    0x50(%rsp),%rdx
jle    243a <solve_dual+0x130a>
mov    %rcx,%rax
mov    0x88(%rsp),%rsi
mov    %rsi,%r13
movsd  0xe6e(%rip),%xmm1
xor    %r12d,%r12d
jmp    2203 <solve_dual+0x10d3>
nopw   0x0(%rax,%rax,1)
subsd  %xmm3,%xmm0
addsd  %xmm0,%xmm0
movapd %xmm0,%xmm1
mov    0x168(%rsp),%rcx
mov    0x50(%rsp),%rdx
add    $0x1,%r12
add    $0x8,%rsi
add    0x38(%rsp),%r13
add    $0x8,%rax
cmp    %r15,%r12
je     236f <solve_dual+0x123f>
mov    0x10(%rsp),%rcx
movsd  (%rcx,%r12,8),%xmm7
addsd  %xmm14,%xmm7
movsd  (%r14,%r12,8),%xmm3
mulsd  %xmm5,%xmm3
subsd  %xmm3,%xmm7
test   %r12,%r12
je     22c0 <solve_dual+0x1190>
cmp    $0x1,%r12
jne    2240 <solve_dual+0x1110>
xor    %edi,%edi
jmp    228d <solve_dual+0x115d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r12,%rbp
and    $0xfffffffffffffffe,%rbp
mov    %rsi,%rbx
movapd %xmm7,%xmm3
xor    %edi,%edi
mov    0x168(%rsp),%rcx
mov    0x48(%rsp),%r9
nopl   (%rax)
movsd  (%rcx,%rdi,8),%xmm6
mulsd  (%rbx),%xmm6
movsd  0x8(%rcx,%rdi,8),%xmm7
addsd  %xmm3,%xmm6
mulsd  (%rbx,%r9,1),%xmm7
addsd  %xmm6,%xmm7
add    $0x2,%rdi
add    %rdx,%rbx
movapd %xmm7,%xmm3
cmp    %rdi,%rbp
jne    2260 <solve_dual+0x1130>
test   $0x1,%r12b
mov    0xc8(%rsp),%r9
je     22c0 <solve_dual+0x1190>
mov    0x168(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm3
imul   %r15,%rdi
add    %r12,%rdi
mov    0x88(%rsp),%rcx
mulsd  (%rcx,%rdi,8),%xmm3
addsd  %xmm3,%xmm7
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rcx,8),%xmm3
mulsd  0x0(%r13,%rcx,8),%xmm3
addsd  %xmm3,%xmm7
lea    (%r12,%rcx,1),%rdx
add    $0x1,%rdx
add    $0x1,%rcx
cmp    %r15,%rdx
jl     22d0 <solve_dual+0x11a0>
mov    0x168(%rsp),%rcx
movsd  (%rcx,%r12,8),%xmm3
mov    0x160(%rsp),%rcx
movsd  (%rcx,%r12,8),%xmm0
movapd %xmm0,%xmm6
subsd  %xmm1,%xmm6
ucomisd %xmm3,%xmm6
jbe    2326 <solve_dual+0x11f6>
ucomisd %xmm7,%xmm15
ja     21d0 <solve_dual+0x10a0>
mov    0x158(%rsp),%rcx
movsd  (%rcx,%r12,8),%xmm6
movapd %xmm1,%xmm0
addsd  %xmm6,%xmm0
ucomisd %xmm0,%xmm3
jbe    21dc <solve_dual+0x10ac>
ucomisd %xmm8,%xmm7
mov    0x168(%rsp),%rcx
mov    0x50(%rsp),%rdx
jbe    21e9 <solve_dual+0x10b9>
subsd  %xmm6,%xmm3
addsd  %xmm3,%xmm3
movapd %xmm3,%xmm1
jmp    21e9 <solve_dual+0x10b9>
test   %r15,%r15
mov    0x158(%rsp),%rbx
jle    2446 <solve_dual+0x1316>
cmpq   $0x0,0x60(%rsp)
mov    0x10(%rsp),%r12
mov    $0x1,%r13d
je     245d <solve_dual+0x132d>
xor    %eax,%eax
mov    0x70(%rsp),%rsi
jmp    23b3 <solve_dual+0x1283>
movsd  %xmm3,0x8(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%rsi
je     245f <solve_dual+0x132f>
movsd  (%rcx,%rax,8),%xmm6
movsd  (%rbx,%rax,8),%xmm3
movapd %xmm1,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm6,%xmm0
jae    23ee <solve_dual+0x12be>
mov    0x160(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm3
mov    0x168(%rsp),%rcx
movapd %xmm3,%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm6
jb     23f3 <solve_dual+0x12c3>
movsd  %xmm3,(%rcx,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm6
movsd  0x8(%rbx,%rax,8),%xmm3
movapd %xmm1,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm6,%xmm0
jae    23a0 <solve_dual+0x1270>
mov    0x160(%rsp),%rcx
movsd  0x8(%rcx,%rax,8),%xmm3
mov    0x168(%rsp),%rcx
movapd %xmm3,%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm6
jae    23a0 <solve_dual+0x1270>
jmp    23a6 <solve_dual+0x1276>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
jmp    2676 <solve_dual+0x1546>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
movapd %xmm9,%xmm1
mov    $0x1,%r13d
jmp    2676 <solve_dual+0x1546>
xor    %eax,%eax
test   $0x1,%r15b
je     24a5 <solve_dual+0x1375>
movsd  (%rcx,%rax,8),%xmm6
movsd  (%rbx,%rax,8),%xmm3
movapd %xmm1,%xmm0
addsd  %xmm3,%xmm0
ucomisd %xmm6,%xmm0
jae    24a0 <solve_dual+0x1370>
mov    0x160(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm3
mov    0x168(%rsp),%rcx
movapd %xmm3,%xmm0
subsd  %xmm1,%xmm0
ucomisd %xmm0,%xmm6
jb     24a5 <solve_dual+0x1375>
movsd  %xmm3,(%rcx,%rax,8)
test   %r15,%r15
jle    266a <solve_dual+0x153a>
mov    %rcx,%rax
mov    0x88(%rsp),%r13
mov    %r13,%rsi
mov    %r13,%rbp
mov    $0x1,%r13d
xor    %edi,%edi
mov    %rdi,0x28(%rsp)
xor    %edi,%edi
jmp    2533 <solve_dual+0x1403>
movsd  (%rbx,%rdi,8),%xmm1
addsd  %xmm12,%xmm1
ucomisd %xmm1,%xmm0
seta   %cl
ucomisd %xmm8,%xmm3
seta   %dl
test   %dl,%cl
mov    $0x1,%ecx
mov    0x28(%rsp),%rdx
cmovne %rcx,%rdx
mov    %rdx,0x28(%rsp)
mov    $0x0,%ecx
cmovne %rcx,%r13
movapd %xmm9,%xmm1
add    $0x1,%rdi
add    $0x8,%rbp
add    0x38(%rsp),%rsi
add    $0x8,%rax
cmp    %r15,%rdi
mov    0x168(%rsp),%rcx
mov    0x50(%rsp),%rdx
je     2676 <solve_dual+0x1546>
movsd  (%r12,%rdi,8),%xmm3
addsd  %xmm14,%xmm3
movsd  (%r14,%rdi,8),%xmm0
mulsd  %xmm5,%xmm0
subsd  %xmm0,%xmm3
test   %rdi,%rdi
mov    %rbp,0x30(%rsp)
je     25fd <solve_dual+0x14cd>
mov    %r13,0xb8(%rsp)
cmp    $0x1,%rdi
jne    2570 <solve_dual+0x1440>
xor    %ebp,%ebp
jmp    25bd <solve_dual+0x148d>
nopl   0x0(%rax)
mov    %rdi,%r12
and    $0xfffffffffffffffe,%r12
mov    %rbp,%rbx
movapd %xmm3,%xmm6
xor    %ebp,%ebp
mov    0x48(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rbp,8),%xmm0
mulsd  (%rbx),%xmm0
movsd  0x8(%rcx,%rbp,8),%xmm3
addsd  %xmm6,%xmm0
mulsd  (%rbx,%r13,1),%xmm3
addsd  %xmm0,%xmm3
add    $0x2,%rbp
add    %rdx,%rbx
movapd %xmm3,%xmm6
cmp    %rbp,%r12
jne    2590 <solve_dual+0x1460>
test   $0x1,%dil
mov    0x10(%rsp),%r12
mov    0x158(%rsp),%rbx
mov    0xb8(%rsp),%r13
je     25fd <solve_dual+0x14cd>
mov    0x168(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm0
imul   %r15,%rbp
add    %rdi,%rbp
mov    0x88(%rsp),%rcx
mulsd  (%rcx,%rbp,8),%xmm0
addsd  %xmm0,%xmm3
xor    %ecx,%ecx
nop
movsd  (%rax,%rcx,8),%xmm0
mulsd  (%rsi,%rcx,8),%xmm0
addsd  %xmm0,%xmm3
lea    (%rdi,%rcx,1),%rdx
add    $0x1,%rdx
add    $0x1,%rcx
cmp    %r15,%rdx
jl     2600 <solve_dual+0x14d0>
mov    0x168(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm0
mov    0x160(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm1
addsd  %xmm13,%xmm1
ucomisd %xmm0,%xmm1
mov    0x30(%rsp),%rbp
jbe    24d0 <solve_dual+0x13a0>
ucomisd %xmm3,%xmm15
jbe    24d0 <solve_dual+0x13a0>
mov    $0x1,%ecx
mov    %rcx,0x28(%rsp)
xor    %r13d,%r13d
jmp    2507 <solve_dual+0x13d7>
xor    %eax,%eax
mov    %rax,0x28(%rsp)
movapd %xmm9,%xmm1
mov    %r13,%rbx
cmpq   $0x0,0x40(%rsp)
mov    0x188(%rsp),%r13
mov    0xe0(%rsp),%rdx
mov    0x110(%rsp),%rsi
mov    0x80(%rsp),%rdi
jle    2769 <solve_dual+0x1639>
mov    0x150(%rsp),%rax
movsd  (%rax),%xmm3
xorpd  %xmm2,%xmm3
test   %r15,%r15
jle    2757 <solve_dual+0x1627>
cmpq   $0x3,0x60(%rsp)
jae    26ca <solve_dual+0x159a>
xor    %eax,%eax
jmp    271b <solve_dual+0x15eb>
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%r14,%rax,8),%xmm0
movsd  0x8(%r14,%rax,8),%xmm1
mulsd  (%rcx,%rax,8),%xmm0
mulsd  0x8(%rcx,%rax,8),%xmm1
addsd  %xmm3,%xmm0
movsd  0x10(%r14,%rax,8),%xmm5
mulsd  0x10(%rcx,%rax,8),%xmm5
addsd  %xmm0,%xmm1
movsd  0x18(%r14,%rax,8),%xmm3
mulsd  0x18(%rcx,%rax,8),%xmm3
addsd  %xmm1,%xmm5
addsd  %xmm5,%xmm3
add    $0x4,%rax
cmp    %rax,%rdx
jne    26d0 <solve_dual+0x15a0>
test   %rsi,%rsi
movapd %xmm9,%xmm1
je     2757 <solve_dual+0x1627>
mov    0x168(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
lea    (%r14,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
mulsd  (%rcx,%rdx,8),%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    2740 <solve_dual+0x1610>
andpd  %xmm4,%xmm3
ucomisd 0x8e5(%rip),%xmm3
jbe    2769 <solve_dual+0x1639>
xor    %ebx,%ebx
jmp    2771 <solve_dual+0x1641>
cmpq   $0x0,0x28(%rsp)
je     27db <solve_dual+0x16ab>
cmpq   $0x1,0x1a0(%rsp)
sete   %al
cmp    $0xc350,%rdi
setb   %cl
cmp    $0x5,%rdi
setb   %dl
ucomisd %xmm11,%xmm10
jbe    27db <solve_dual+0x16ab>
and    %cl,%al
or     %dl,%al
movzbl %al,%eax
add    %rax,%rdi
divsd  0x8a9(%rip),%xmm1
mov    %rdi,0x80(%rsp)
imul   0xd8(%rsp),%rdi
mov    0xb0(%rsp),%r12
mov    %rdi,0x30(%rsp)
cmp    %rdi,%r12
jl     1c85 <solve_dual+0xb55>
jmp    27db <solve_dual+0x16ab>
movsd  0x84f(%rip),%xmm10
xor    %ebx,%ebx
test   %rbx,%rbx
sete   %r14b
mov    0x158(%rsp),%r8
mov    0x198(%rsp),%rdx
jne    2941 <solve_dual+0x1811>
test   %r15,%r15
jle    2941 <solve_dual+0x1811>
mov    %r15,%rax
and    $0xfffffffffffffffe,%rax
mov    0x180(%rsp),%rcx
add    $0x8,%rcx
lea    0x0(,%r15,8),%r9
xor    %ebp,%ebp
movapd 0x7da(%rip),%xmm0
movsd  0x812(%rip),%xmm1
movsd  0x802(%rip),%xmm2
jmp    285d <solve_dual+0x172d>
nopl   0x0(%rax,%rax,1)
mov    0x168(%rsp),%rsi
movsd  %xmm4,(%rsi,%rbp,8)
add    $0x1,%rbp
add    %r9,%rcx
cmp    %r15,%rbp
je     2941 <solve_dual+0x1811>
mov    0x168(%rsp),%rsi
movq   $0x0,(%rsi,%rbp,8)
xorpd  %xmm3,%xmm3
xor    %edi,%edi
cmp    $0x1,%r15
je     28c1 <solve_dual+0x1791>
mov    0x168(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rdi,8),%xmm4
mulsd  (%rdx,%rdi,8),%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi,%rbp,8)
movsd  (%rcx,%rdi,8),%xmm3
mulsd  0x8(%rdx,%rdi,8),%xmm3
addsd  %xmm4,%xmm3
movsd  %xmm3,(%rsi,%rbp,8)
add    $0x2,%rdi
cmp    %rdi,%rax
jne    2890 <solve_dual+0x1760>
test   $0x1,%r15b
je     28f4 <solve_dual+0x17c4>
mov    %rbp,%rsi
imul   %r15,%rsi
add    %rdi,%rsi
mov    0x180(%rsp),%rbx
movsd  (%rbx,%rsi,8),%xmm4
mulsd  (%rdx,%rdi,8),%xmm4
addsd  %xmm4,%xmm3
mov    0x168(%rsp),%rsi
movsd  %xmm3,(%rsi,%rbp,8)
xorpd  %xmm0,%xmm3
mov    0x168(%rsp),%rsi
movlpd %xmm3,(%rsi,%rbp,8)
movsd  (%r8,%rbp,8),%xmm4
movapd %xmm4,%xmm5
addsd  %xmm1,%xmm5
ucomisd %xmm3,%xmm5
jae    2840 <solve_dual+0x1710>
mov    0x160(%rsp),%rsi
movsd  (%rsi,%rbp,8),%xmm4
movapd %xmm4,%xmm5
addsd  %xmm2,%xmm5
ucomisd %xmm5,%xmm3
jae    2840 <solve_dual+0x1710>
jmp    284d <solve_dual+0x171d>
test   %r15,%r15
jle    2973 <solve_dual+0x1843>
lea    -0x1(%r15),%rcx
mov    %r15d,%eax
and    $0x7,%eax
cmp    $0x7,%rcx
jae    298e <solve_dual+0x185e>
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0xa8(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rbp
jmp    29f8 <solve_dual+0x18c8>
xorpd  %xmm0,%xmm0
mov    0xa8(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rbp
jmp    2a1e <solve_dual+0x18ee>
mov    %r15,%rdx
and    $0xfffffffffffffff8,%rdx
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
mov    0xa8(%rsp),%rsi
mov    0x20(%rsp),%rdi
mov    0x18(%rsp),%rbp
mov    0x168(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
addsd  (%rbx,%rcx,8),%xmm0
addsd  0x8(%rbx,%rcx,8),%xmm0
addsd  0x10(%rbx,%rcx,8),%xmm0
addsd  0x18(%rbx,%rcx,8),%xmm0
addsd  0x20(%rbx,%rcx,8),%xmm0
addsd  0x28(%rbx,%rcx,8),%xmm0
addsd  0x30(%rbx,%rcx,8),%xmm0
addsd  0x38(%rbx,%rcx,8),%xmm0
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    29c0 <solve_dual+0x1890>
test   %rax,%rax
je     2a1e <solve_dual+0x18ee>
mov    0x168(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
addsd  (%rcx,%rdx,8),%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
jne    2a10 <solve_dual+0x18e0>
cmpq   $0x0,0x40(%rsp)
movapd %xmm10,0x90(%rsp)
jle    2a8a <solve_dual+0x195a>
movsd  0x0(%rbp),%xmm1
movsd  (%rdi),%xmm2
cmp    $0x2,%rsi
jl     2a76 <solve_dual+0x1946>
lea    0x10(%r13),%rdi
shl    $0x4,%r15
mov    %r13,%rsi
mov    %r15,%rdx
movsd  %xmm0,0x58(%rsp)
movsd  %xmm1,0x68(%rsp)
movsd  %xmm2,0x10(%rsp)
call   1040 <memmove@plt>
movsd  0x10(%rsp),%xmm2
movsd  0x68(%rsp),%xmm1
movsd  0x58(%rsp),%xmm0
movsd  %xmm2,0x0(%r13)
movsd  %xmm1,0x8(%r13)
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    $0x1,%al
call   1030 <isnan@plt>
xor    %ecx,%ecx
test   %eax,%eax
setne  %cl
lea    0x1(%rcx,%rcx,2),%edx
xorpd  %xmm0,%xmm0
cmpeqsd 0x90(%rsp),%xmm0
movq   %xmm0,%rcx
add    $0x3,%ecx
test   %r14b,%r14b
cmove  %edx,%ecx
test   %eax,%eax
cmovne %edx,%ecx
mov    %ecx,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movapd %xmm10,0x90(%rsp)
xorpd  %xmm0,%xmm0
xor    %r14d,%r14d
jmp    2a8a <solve_dual+0x195a>

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

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