int minfit(double *AB, int M, int N, int P, double *q) {
  int i, j, k, l, t, t2, ierr, cancel, iter, l1, np, n1;
  double eps, g, x, s, temp, f, h, tol, c, y, z;
  double *e;
  e = (double *)malloc(sizeof(double) * N);
  ierr = 0;
  eps = macheps();
  tol = eps * eps;
  g = x = 0.0;
  np = N + P;
  for (i = 0; i < N; ++i) {
    l = i + 1;
    e[i] = g;
    s = 0.0;
    for (k = i; k < M; ++k) {
      t = k * np;
      temp = AB[t + i];
      s += temp * temp;
    }
    if (s < tol) {
      g = 0.0;
    } else {
      f = AB[i * np + i];
      g = (f < 0) ? sqrt(s) : -sqrt(s);
      h = f * g - s;
      AB[i * np + i] = f - g;
      for (j = l; j < np; ++j) {
        s = 0.0;
        for (k = i; k < M; ++k) {
          t = k * np;
          s += (AB[t + i] * AB[t + j]);
        }
        f = s / h;
        for (k = i; k < M; ++k) {
          t = k * np;
          AB[t + j] += (f * AB[t + i]);
        }
      }
    }
    q[i] = g;
    s = 0.0;
    t = i * np;
    if (i < M) {
      for (k = l; k < N; ++k) {
        temp = AB[t + k];
        s = s + temp * temp;
      }
    }
    if (s < tol) {
      g = 0.0;
    } else {
      f = AB[t + i + 1];
      g = (f < 0) ? sqrt(s) : -sqrt(s);
      h = f * g - s;
      AB[t + i + 1] = f - g;
      for (k = l; k < N; ++k) {
        e[k] = AB[t + k] / h;
      }
      for (j = l; j < M; j++) {
        s = 0.0;
        t2 = j * np;
        for (k = l; k < N; k++) {
          s += AB[t2 + k] * AB[t + k];
        }
        for (k = l; k < N; k++) {
          AB[t2 + k] += s * e[k];
        }
      }
    }
    temp = fabs(q[i]) + fabs(e[i]);
    if (x < temp) {
      x = temp;
    }
  }
  for (i = N - 1; i >= 0; --i) {
    t = i * np;
    if (g != 0.0) {
      h = AB[t + i + 1] * g;
      for (j = l; j < N; ++j) {
        AB[j * np + i] = AB[t + j] / h;
      }
      for (j = l; j < N; ++j) {
        s = 0.0;
        for (k = l; k < N; ++k) {
          s += AB[t + k] * AB[k * np + j];
        }
        for (k = l; k < N; ++k) {
          AB[k * np + j] += (s * AB[k * np + i]);
        }
      }
    }
    for (j = l; j < N; ++j) {
      AB[t + j] = AB[j * np + i] = 0.0;
    }
    AB[t + i] = 1.0;
    g = e[i];
    l = i;
  }
  eps = eps * x;
  n1 = N + 1;
  for (i = M; i < N; ++i) {
    for (j = n1 - 1; j < np; ++j) {
      AB[i * np + j] = 0.0;
    }
  }
  for (k = N - 1; k >= 0; --k) {
    iter = 0;
    while (1) {
      iter++;
      if (iter > 50) {
        printf("Convergence Not Achieved \n");
        return 15;
      }
      cancel = 1;
      for (l = k; l >= 0; --l) {
        if (fabs(e[l]) <= eps) {
          cancel = 0;
          break;
        }
        if (fabs(q[l - 1]) <= eps) {
          break;
        }
      }
      if (cancel) {
        c = 0.0;
        s = 1.0;
        l1 = l - 1;
        for (i = l; i <= k; ++i) {
          f = s * e[i];
          e[i] *= c;
          if (fabs(f) <= eps) {
            break;
          }
          g = q[i];
          h = q[i] = hypot(f, g);
          c = g / h;
          s = -f / h;
          for (j = n1 - 1; j < np; ++j) {
            y = AB[l1 * np + j];
            z = AB[i * np + j];
            AB[l1 * np + j] = y * c + z * s;
            AB[i * np + j] = z * c - y * s;
          }
        }
      }
      z = q[k];
      if (l != k) {
        x = q[l];
        y = q[k - 1];
        g = e[k - 1];
        h = e[k];
        f = 0.5 * (((g + z) / h) * ((g - z) / y) + y / h - h / y);
        g = hypot(f, 1.0);
        if (f < 0.0) {
          temp = f - g;
        } else {
          temp = f + g;
        }
        f = x - (z / x) * z + (h / x) * (y / temp - h);
        c = s = 1.0;
        for (i = l + 1; i <= k; ++i) {
          g = e[i];
          y = q[i];
          h = s * g;
          g = c * g;
          e[i - 1] = z = hypot(f, h);
          c = f / z;
          s = h / z;
          f = x * c + g * s;
          g = g * c - x * s;
          h = y * s;
          y *= c;
          for (j = 0; j < N; ++j) {
            t = j * np;
            x = AB[t + i - 1];
            z = AB[t + i];
            AB[t + i - 1] = x * c + z * s;
            AB[t + i] = z * c - x * s;
          }
          q[i - 1] = z = hypot(f, h);
          if (z != 0.0) {
            c = f / z;
            s = h / z;
          }
          f = c * g + s * y;
          x = c * y - s * g;
          for (j = n1 - 1; j < np; ++j) {
            y = AB[(i - 1) * np + j];
            z = AB[i * np + j];
            AB[(i - 1) * np + j] = y * c + z * s;
            AB[i * np + j] = z * c - y * s;
          }
        }
        e[l] = 0.0;
        e[k] = f;
        q[k] = x;
      } else {
        if (z < 0.0) {
          q[k] = -z;
          for (j = 0; j < N; j++) {
            t = j * np;
            AB[t + k] = -AB[t + k];
          }
        }
        break;
      }
    }
  }
  free(e);
  return ierr;
}


x86 assembly (clang, -O0):
<minfit>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movslq -0x18(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0xb8(%rbp)
movl   $0x0,-0x44(%rbp)
mov    $0x0,%al
call   1070 <macheps@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    178d <minfit+0x62d>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1268 <minfit+0x108>
mov    -0x34(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1211 <minfit+0xb1>
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    128c <minfit+0x12c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    146e <minfit+0x30e>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    12d2 <minfit+0x172>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
jmp    12fb <minfit+0x19b>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1469 <minfit+0x309>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13de <minfit+0x27e>
mov    -0x34(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1384 <minfit+0x224>
movsd  -0x78(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1456 <minfit+0x2f6>
mov    -0x34(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13f9 <minfit+0x299>
jmp    145b <minfit+0x2fb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    136a <minfit+0x20a>
jmp    146e <minfit+0x30e>
movsd  -0x68(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14f6 <minfit+0x396>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    14f1 <minfit+0x391>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14a4 <minfit+0x344>
jmp    14f6 <minfit+0x396>
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    151a <minfit+0x3ba>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
jmp    1720 <minfit+0x5c0>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    155f <minfit+0x3ff>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1588 <minfit+0x428>
movsd  -0x78(%rbp),%xmm0
call   1080 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    163a <minfit+0x4da>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15f6 <minfit+0x496>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    171b <minfit+0x5bb>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    16b4 <minfit+0x554>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1664 <minfit+0x504>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1708 <minfit+0x5a8>
movsd  -0x78(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16ba <minfit+0x55a>
jmp    170d <minfit+0x5ad>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1640 <minfit+0x4e0>
jmp    1720 <minfit+0x5c0>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x18cc(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x18b1(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    177a <minfit+0x61a>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    177f <minfit+0x61f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d9 <minfit+0x79>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     19b4 <minfit+0x854>
mov    -0x2c(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movsd  -0x68(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17c7 <minfit+0x667>
jp     17c7 <minfit+0x667>
jmp    1923 <minfit+0x7c3>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1839 <minfit+0x6d9>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17ef <minfit+0x68f>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    191e <minfit+0x7be>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    18ad <minfit+0x74d>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1859 <minfit+0x6f9>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    190b <minfit+0x7ab>
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    18b3 <minfit+0x753>
jmp    1910 <minfit+0x7b0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    183f <minfit+0x6df>
jmp    1923 <minfit+0x7c3>
mov    -0x38(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1971 <minfit+0x811>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1929 <minfit+0x7c9>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  0x168a(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1796 <minfit+0x636>
movsd  -0x60(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1a2d <minfit+0x8cd>
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1a1a <minfit+0x8ba>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19e7 <minfit+0x887>
jmp    1a1f <minfit+0x8bf>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19d2 <minfit+0x872>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     2408 <minfit+0x12a8>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x32,-0x4c(%rbp)
jle    1a74 <minfit+0x914>
lea    0x15bf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xf,-0x4(%rbp)
jmp    241a <minfit+0x12ba>
movl   $0x1,-0x48(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmpl   $0x0,-0x38(%rbp)
jl     1b05 <minfit+0x9a5>
mov    -0xb8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x155e(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1ac1 <minfit+0x961>
movl   $0x0,-0x48(%rbp)
jmp    1b05 <minfit+0x9a5>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1526(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1af2 <minfit+0x992>
jmp    1b05 <minfit+0x9a5>
jmp    1af7 <minfit+0x997>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1a81 <minfit+0x921>
cmpl   $0x0,-0x48(%rbp)
je     1d21 <minfit+0xbc1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x14ee(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1d1c <minfit+0xbbc>
movsd  -0x78(%rbp),%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm1
ff
movaps 0x1475(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1ba3 <minfit+0xa43>
jmp    1d1c <minfit+0xbbc>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm1
call   1060 <hypot@plt>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1d09 <minfit+0xba9>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1c26 <minfit+0xac6>
jmp    1d0e <minfit+0xbae>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b36 <minfit+0x9d6>
jmp    1d21 <minfit+0xbc1>
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
je     2343 <minfit+0x11e3>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0xb8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x68(%rbp),%xmm1
addsd  -0xb0(%rbp),%xmm1
ff
divsd  -0x90(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm2
subsd  -0xb0(%rbp),%xmm2
ff
divsd  -0xa8(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm0
ff
divsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xa8(%rbp),%xmm0
ff
subsd  %xmm0,%xmm1
movsd  0x121a(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  0x11f6(%rip),%xmm1
call   1060 <hypot@plt>
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x88(%rbp),%xmm0
ff
jbe    1e4c <minfit+0xcec>
movsd  -0x88(%rbp),%xmm0
ff
subsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
jmp    1e5e <minfit+0xcfe>
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xb0(%rbp),%xmm1
ff
divsd  -0x70(%rbp),%xmm1
movsd  -0xb0(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0x70(%rbp),%xmm0
movsd  -0xa8(%rbp),%xmm2
ff
divsd  -0x80(%rbp),%xmm2
subsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  0x113f(%rip),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x1132(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     2301 <minfit+0x11a1>
mov    -0xb8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
call   1060 <hypot@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0xb8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    2118 <minfit+0xfb8>
mov    -0x30(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    203e <minfit+0xede>
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm1
ff
call   1060 <hypot@plt>
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2167 <minfit+0x1007>
jp     2167 <minfit+0x1007>
jmp    2194 <minfit+0x1034>
movsd  -0x88(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
divsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x68(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0xa8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm2
ff
movsd  -0x78(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x58(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    22ee <minfit+0x118e>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xa0(%rbp),%xmm2
ff
movsd  -0xa8(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2205 <minfit+0x10a5>
jmp    22f3 <minfit+0x1193>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1eef <minfit+0xd8f>
mov    -0xb8(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0xb8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    23f0 <minfit+0x1290>
xorps  %xmm0,%xmm0
ucomisd -0xb0(%rbp),%xmm0
ff
jbe    23eb <minfit+0x128b>
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    23e6 <minfit+0x1286>
mov    -0x30(%rbp),%eax
imul   -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    2387 <minfit+0x1227>
jmp    23eb <minfit+0x128b>
jmp    23f5 <minfit+0x1295>
jmp    1a47 <minfit+0x8e7>
jmp    23fa <minfit+0x129a>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1a36 <minfit+0x8d6>
mov    -0xb8(%rbp),%rdi
call   1030 <free@plt>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<minfit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1e8,%rsp
mov    %r8,0x58(%rsp)
mov    %ecx,%r14d
mov    %edx,%ebp
mov    %esi,%r12d
mov    %rdi,%r13
movslq %edx,%rbx
lea    0x0(,%rbx,8),%rdi
call   1060 <malloc@plt>
mov    %rax,%r15
xor    %eax,%eax
call   1080 <macheps@plt>
mov    %rbx,%r10
cvtsi2sd %eax,%xmm0
mov    %r14,%rax
mov    %r14,0x108(%rsp)
lea    (%r14,%rbp,1),%ecx
mov    %rcx,%rax
mov    %rcx,0x90(%rsp)
movslq %ecx,%r8
mov    %rbp,0x68(%rsp)
mov    %ebp,%eax
test   %r10d,%r10d
mov    %r13,0x28(%rsp)
mov    %rbx,0x20(%rsp)
mov    %r15,0x18(%rsp)
mov    %r8,0x8(%rsp)
mov    %rax,%rcx
mov    %rax,0x70(%rsp)
movsd  %xmm0,0x140(%rsp)
jle    1fb6 <minfit+0xe46>
movapd %xmm0,%xmm8
mulsd  %xmm0,%xmm8
mov    %r12d,0x120(%rsp)
movslq %r12d,%rbx
mov    %ebx,%ecx
lea    -0x2(%rax),%rdx
mov    %rdx,0x110(%rsp)
lea    0x0(,%r8,8),%r12
lea    0x8(,%r8,8),%rdx
mov    %rdx,0x160(%rsp)
lea    0x8(%r13),%rdx
lea    0x18(%r15),%rsi
lea    -0x3(%rax),%rdi
mov    %rdi,0x150(%rsp)
lea    0x0(%r13,%r8,8),%rdi
mov    %rdi,0x78(%rsp)
lea    0x38(,%r8,8),%rdi
add    %r13,%rdi
mov    %rdi,0xc0(%rsp)
add    $0x38,%r15
lea    -0x5(%rax),%rdi
mov    %rdi,0xa0(%rsp)
xorpd  %xmm9,%xmm9
mov    $0x1,%edi
mov    %rdi,(%rsp)
movapd 0x1d79(%rip),%xmm10
movapd 0x1d60(%rip),%xmm11
mov    %r13,%rbp
xorpd  %xmm4,%xmm4
xorpd  %xmm1,%xmm1
mov    %rax,0x10(%rsp)
mov    %rcx,0xa8(%rsp)
mov    %rcx,0xb0(%rsp)
xor    %ecx,%ecx
mov    %r13,%r14
mov    0x58(%rsp),%r9
mov    %r13,%r11
mov    0x18(%rsp),%rdi
movsd  %xmm8,0x148(%rsp)
mov    %rbx,0x130(%rsp)
jmp    1394 <minfit+0x224>
nopl   0x0(%rax)
mov    0x58(%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x130(%rsp),%rbx
mov    0x60(%rsp),%rdx
mov    0x10(%rsp),%rsi
mov    0x40(%rsp),%rcx
movsd  (%r9,%rcx,8),%xmm0
movsd  (%rdi,%rcx,8),%xmm4
andpd  %xmm10,%xmm0
andpd  %xmm10,%xmm4
addsd  %xmm0,%xmm4
maxsd  %xmm12,%xmm4
addq   $0x1,(%rsp)
mov    0x160(%rsp),%rcx
add    %rcx,%r14
addq   $0xffffffffffffffff,0xb0(%rsp)
add    %rcx,%rdx
add    $0xffffffffffffffff,%rsi
mov    %rsi,0x10(%rsp)
mov    0xd8(%rsp),%rsi
add    $0x8,%rsi
addq   $0xffffffffffffffff,0x150(%rsp)
add    %r12,%rbp
add    %r12,0x78(%rsp)
add    %rcx,0xc0(%rsp)
add    $0x8,%r15
addq   $0xffffffffffffffff,0xa0(%rsp)
mov    0x30(%rsp),%rcx
cmp    %rax,%rcx
je     1ae4 <minfit+0x974>
mov    %rsi,0xd8(%rsp)
movapd %xmm4,%xmm12
mov    %rcx,%r13
movsd  %xmm1,(%rdi,%rcx,8)
xorpd  %xmm5,%xmm5
cmp    %rbx,%rcx
jge    13e5 <minfit+0x275>
xorpd  %xmm5,%xmm5
mov    0xb0(%rsp),%rax
mov    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rcx),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    %r12,%rcx
add    $0xffffffffffffffff,%rax
jne    13d0 <minfit+0x260>
lea    0x1(%r13),%rcx
mov    0x90(%rsp),%rax
imul   %r13d,%eax
mov    %eax,0x80(%rsp)
ucomisd %xmm5,%xmm8
xorpd  %xmm3,%xmm3
xorpd  %xmm1,%xmm1
mov    0x10(%rsp),%rsi
mov    %rcx,%rax
mov    %rcx,0x30(%rsp)
mov    %r13,0x40(%rsp)
mov    %rdx,0x60(%rsp)
ja     15d4 <minfit+0x464>
movslq 0x80(%rsp),%rbx
add    %r13,%rbx
movsd  (%r11,%rbx,8),%xmm4
ucomisd %xmm9,%xmm5
jb     1450 <minfit+0x2e0>
xorps  %xmm0,%xmm0
sqrtsd %xmm5,%xmm0
jmp    14de <minfit+0x36e>
nopw   0x0(%rax,%rax,1)
movapd %xmm5,%xmm0
movsd  %xmm12,0xe0(%rsp)
movsd  %xmm4,0xf0(%rsp)
movsd  %xmm5,0x98(%rsp)
call   1090 <sqrt@plt>
movsd  0x98(%rsp),%xmm5
movsd  0xf0(%rsp),%xmm4
xorpd  %xmm3,%xmm3
movsd  0xe0(%rsp),%xmm12
mov    0x30(%rsp),%rcx
mov    0x10(%rsp),%rsi
movapd 0x1b58(%rip),%xmm11
movapd 0x1b5f(%rip),%xmm10
xorpd  %xmm9,%xmm9
mov    0x60(%rsp),%rdx
movsd  0x148(%rsp),%xmm8
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x58(%rsp),%r9
movapd %xmm4,%xmm1
cmpltsd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm11,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rbx,8)
cmp    %r8,%rcx
jge    15b0 <minfit+0x440>
mulsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
mov    %rdx,%rax
mov    (%rsp),%rcx
mov    0x130(%rsp),%rbx
jmp    1541 <minfit+0x3d1>
nopl   (%rax)
add    $0x1,%rcx
add    $0x8,%rax
cmp    %r8,%rcx
jge    15c0 <minfit+0x450>
cmp    %rbx,0x40(%rsp)
jge    1530 <minfit+0x3c0>
xorpd  %xmm0,%xmm0
mov    0xb0(%rsp),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%r14,%rsi,1),%xmm2
mulsd  (%rax,%rsi,1),%xmm2
addsd  %xmm2,%xmm0
add    %r12,%rsi
add    $0xffffffffffffffff,%rdx
jne    1560 <minfit+0x3f0>
cmp    %rbx,0x40(%rsp)
jge    1530 <minfit+0x3c0>
divsd  %xmm4,%xmm0
mov    0xb0(%rsp),%rdx
xor    %esi,%esi
nopl   (%rax)
movsd  (%r14,%rsi,1),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rax,%rsi,1),%xmm2
movsd  %xmm2,(%rax,%rsi,1)
add    %r12,%rsi
add    $0xffffffffffffffff,%rdx
jne    1590 <minfit+0x420>
jmp    1530 <minfit+0x3c0>
nop
mov    0x130(%rsp),%rbx
jmp    15cf <minfit+0x45f>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rdx
mov    0x10(%rsp),%rsi
mov    0x30(%rsp),%rcx
mov    0x40(%rsp),%r13
movsd  %xmm1,(%r9,%r13,8)
cmp    %rbx,%r13
jge    1607 <minfit+0x497>
cmp    %r10,%rcx
jge    1607 <minfit+0x497>
xorpd  %xmm3,%xmm3
mov    $0x1,%eax
nopl   (%rax)
movsd  (%r14,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rax
cmp    %rax,%rsi
jne    15f0 <minfit+0x480>
xorpd  %xmm1,%xmm1
ucomisd %xmm3,%xmm8
mov    0x70(%rsp),%rax
ja     130c <minfit+0x19c>
mov    0x80(%rsp),%ecx
add    0x30(%rsp),%ecx
movslq %ecx,%rbx
movsd  (%r11,%rbx,8),%xmm4
ucomisd %xmm9,%xmm3
jb     1650 <minfit+0x4e0>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    16cb <minfit+0x55b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm3,%xmm0
movsd  %xmm12,0xe0(%rsp)
movsd  %xmm3,0x80(%rsp)
movapd %xmm4,0xf0(%rsp)
call   1090 <sqrt@plt>
movapd 0xf0(%rsp),%xmm4
movsd  0x80(%rsp),%xmm3
movsd  0xe0(%rsp),%xmm12
movapd 0x1966(%rip),%xmm11
movapd 0x196d(%rip),%xmm10
xorpd  %xmm9,%xmm9
movsd  0x148(%rsp),%xmm8
mov    0x70(%rsp),%rax
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x40(%rsp),%rdx
mov    %rdx,%r9
not    %r9
lea    (%r9,%rax,1),%rcx
imul   %r8,%rdx
mov    %rdx,0x80(%rsp)
movapd %xmm4,%xmm1
cmpltsd %xmm9,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm11,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movapd %xmm4,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r11,%rbx,8)
cmp    %r10,0x30(%rsp)
mov    0x130(%rsp),%rbx
jge    1818 <minfit+0x6a8>
mulsd  %xmm1,%xmm4
subsd  %xmm3,%xmm4
mov    (%rsp),%rax
cmp    $0x2,%rcx
jb     17fa <minfit+0x68a>
mov    0x70(%rsp),%rax
lea    (%r9,%rax,1),%rsi
add    $0xfffffffffffffffe,%rsi
mov    %rsi,%r8
shr    %r8
add    $0x1,%r8
movapd %xmm4,%xmm0
unpcklpd %xmm4,%xmm0
cmp    $0x2,%rsi
jae    1765 <minfit+0x5f5>
xor    %ebx,%ebx
jmp    17b8 <minfit+0x648>
mov    0x150(%rsp),%rax
shr    %rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
xor    %ebx,%ebx
mov    0x60(%rsp),%rsi
mov    0xd8(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movupd (%rsi,%rbx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,-0x10(%rdx,%rbx,8)
movupd 0x10(%rsi,%rbx,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%rdx,%rbx,8)
add    $0x4,%rbx
add    $0xfffffffffffffffe,%rax
jne    1790 <minfit+0x620>
mov    %rcx,%rax
and    $0xfffffffffffffffe,%rax
test   $0x1,%r8b
je     17e4 <minfit+0x674>
add    (%rsp),%rbx
mov    0x80(%rsp),%rdx
lea    (%rbx,%rdx,1),%rsi
movupd (%r11,%rsi,8),%xmm2
divpd  %xmm0,%xmm2
movupd %xmm2,(%rdi,%rbx,8)
cmp    %rax,%rcx
mov    0x8(%rsp),%r8
mov    0x130(%rsp),%rbx
je     1818 <minfit+0x6a8>
add    (%rsp),%rax
mov    0x70(%rsp),%rsi
nop
movsd  0x0(%rbp,%rax,8),%xmm0
divsd  %xmm4,%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1800 <minfit+0x690>
cmp    %rbx,0x30(%rsp)
jge    1ad0 <minfit+0x960>
mov    0xa0(%rsp),%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    0x70(%rsp),%rax
lea    (%r9,%rax,1),%rsi
add    $0xfffffffffffffffc,%rsi
mov    %rsi,0xf0(%rsp)
shr    $0x2,%rsi
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0x158(%rsp)
add    $0x1,%rsi
mov    %rsi,0x98(%rsp)
mov    (%rsp),%r9
add    %r9,0x80(%rsp)
lea    0x1(%r9),%rdx
mov    %rdx,0xe0(%rsp)
mov    %rcx,%rdx
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0xd0(%rsp)
add    %r9,%rdx
mov    %rdx,0x168(%rsp)
mov    0xc0(%rsp),%rsi
mov    0x78(%rsp),%rdx
jmp    18c8 <minfit+0x758>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
add    %r12,%rdx
add    %r12,%rsi
cmp    0xa8(%rsp),%r9
je     12f0 <minfit+0x180>
mov    0x30(%rsp),%rbx
cmp    0x20(%rsp),%rbx
jge    18b0 <minfit+0x740>
mov    %r9,%r13
imul   %r8,%r13
xorpd  %xmm2,%xmm2
mov    (%rsp),%rbx
test   $0x1,%cl
je     1914 <minfit+0x7a4>
mov    (%rsp),%rbx
add    %r13,%rbx
movsd  (%r11,%rbx,8),%xmm0
mov    0x80(%rsp),%rbx
mulsd  (%r11,%rbx,8),%xmm0
addsd  %xmm9,%xmm0
mov    0xe0(%rsp),%rbx
movapd %xmm0,%xmm2
mov    0x40(%rsp),%r10
cmp    %r10,0x110(%rsp)
je     195c <minfit+0x7ec>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdx,%rbx,8),%xmm3
movsd  0x8(%rdx,%rbx,8),%xmm0
mulsd  0x0(%rbp,%rbx,8),%xmm3
mulsd  0x8(%rbp,%rbx,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x2,%rbx
movapd %xmm0,%xmm2
cmp    %rbx,%rax
jne    1930 <minfit+0x7c0>
mov    0x30(%rsp),%rbx
cmp    0x20(%rsp),%rbx
jge    18b0 <minfit+0x740>
mov    (%rsp),%rbx
cmp    $0x4,%rcx
jb     1aa0 <minfit+0x930>
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
cmpq   $0x4,0xf0(%rsp)
jae    1995 <minfit+0x825>
xor    %r8d,%r8d
jmp    1a1b <minfit+0x8ab>
mov    0x158(%rsp),%r11
xor    %r8d,%r8d
movupd -0x30(%r15,%r8,8),%xmm3
movupd -0x20(%r15,%r8,8),%xmm4
mulpd  %xmm2,%xmm3
movupd -0x30(%rsi,%r8,8),%xmm5
addpd  %xmm3,%xmm5
movupd -0x20(%rsi,%r8,8),%xmm3
movupd -0x10(%rsi,%r8,8),%xmm6
movupd (%rsi,%r8,8),%xmm7
mulpd  %xmm2,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm5,-0x30(%rsi,%r8,8)
movupd %xmm4,-0x20(%rsi,%r8,8)
movupd -0x10(%r15,%r8,8),%xmm3
movupd (%r15,%r8,8),%xmm4
mulpd  %xmm2,%xmm3
addpd  %xmm6,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm7,%xmm4
movupd %xmm3,-0x10(%rsi,%r8,8)
movupd %xmm4,(%rsi,%r8,8)
add    $0x8,%r8
add    $0xfffffffffffffffe,%r11
jne    19a0 <minfit+0x830>
testb  $0x1,0x98(%rsp)
01
mov    0x28(%rsp),%r11
je     1a72 <minfit+0x902>
add    (%rsp),%r8
mov    0x18(%rsp),%rax
movupd (%rax,%r8,8),%xmm3
movupd 0x10(%rax,%r8,8),%xmm4
mov    0x70(%rsp),%rax
add    %r13,%r8
movupd (%r11,%r8,8),%xmm5
movupd 0x10(%r11,%r8,8),%xmm6
mulpd  %xmm2,%xmm3
addpd  %xmm5,%xmm3
mulpd  %xmm2,%xmm4
addpd  %xmm6,%xmm4
movupd %xmm3,(%r11,%r8,8)
movupd %xmm4,0x10(%r11,%r8,8)
mov    0x168(%rsp),%rbx
cmp    0xd0(%rsp),%rcx
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%r8
je     18b0 <minfit+0x740>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  (%rdx,%rbx,8),%xmm2
movsd  %xmm2,(%rdx,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rax
jne    1aa0 <minfit+0x930>
jmp    18b0 <minfit+0x740>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%r9
mov    0x20(%rsp),%r10
mov    0x70(%rsp),%rax
jmp    1302 <minfit+0x192>
cmpl   $0x0,0x68(%rsp)
jle    1fac <minfit+0xe3c>
mov    %r10,%rbp
neg    %rbp
lea    -0x1(%r10),%rcx
lea    (%r8,%r8,1),%rdx
mov    %rcx,%rax
imul   %r8,%rax
lea    (%r11,%rax,8),%rsi
add    $0x8,%rsi
neg    %r12
shl    $0x4,%r8
lea    (%r11,%r10,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x80(%rsp)
xorpd  %xmm0,%xmm0
mov    %rcx,0x98(%rsp)
mov    %rcx,0xe0(%rsp)
mov    %r11,0xf0(%rsp)
mov    %r10,%rdi
mov    %rbp,(%rsp)
jmp    1b9b <minfit+0xa2b>
nopl   0x0(%rax,%rax,1)
movslq 0xc0(%rsp),%rax
add    %rdi,%rax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,(%r11,%rax,8)
mov    0x18(%rsp),%rax
movsd  (%rax,%rdi,8),%xmm1
addq   $0xfffffffffffffff8,0xf0(%rsp)
add    %r12,%rsi
addq   $0xffffffffffffffff,0xe0(%rsp)
addq   $0xfffffffffffffff8,0x80(%rsp)
cmp    $0x1,%r14
jle    1fa2 <minfit+0xe32>
movslq %edi,%rcx
mov    %r10,%rax
sub    %rcx,%rax
mov    %rax,0x30(%rsp)
mov    %rcx,%rax
mov    %rcx,0x10(%rsp)
not    %rax
mov    %rax,0x40(%rsp)
mov    %rdi,0x60(%rsp)
lea    -0x1(%rdi),%rcx
mov    %rcx,%rax
imul   0x8(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    0x90(%rsp),%rax
mov    %eax,%edi
mov    %rcx,%rax
mov    %rcx,0x78(%rsp)
imul   %ecx,%edi
mov    %rdi,0xc0(%rsp)
ucomisd %xmm0,%xmm1
jne    1bfc <minfit+0xa8c>
jnp    1ee0 <minfit+0xd70>
mov    0x60(%rsp),%rax
cmp    0x68(%rsp),%eax
jge    1ee0 <minfit+0xd70>
mov    0x78(%rsp),%rcx
mov    0xc0(%rsp),%rax
add    %ecx,%eax
cltq
mulsd  0x8(%r11,%rax,8),%xmm1
mov    0x60(%rsp),%r9
movslq %r9d,%rbp
testb  $0x1,0x30(%rsp)
je     1c5d <minfit+0xaed>
mov    0xa0(%rsp),%rax
add    %rbp,%rax
movsd  (%r11,%rax,8),%xmm2
divsd  %xmm1,%xmm2
mov    %rbp,%rax
imul   0x8(%rsp),%rax
add    %rcx,%rax
movsd  %xmm2,(%r11,%rax,8)
add    $0x1,%rbp
mov    0x40(%rsp),%rax
cmp    (%rsp),%rax
je     1cc9 <minfit+0xb59>
mov    0x8(%rsp),%rdi
mov    %rdi,%rax
imul   %rbp,%rax
mov    0xf0(%rsp),%rbx
lea    (%rbx,%rax,8),%rax
lea    0x1(%rbp),%rcx
imul   %rdi,%rcx
lea    (%rbx,%rcx,8),%rcx
mov    0x98(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  -0x8(%rsi,%rbp,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rax,%rbx,8)
movsd  (%rsi,%rbp,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,(%rcx,%rbx,8)
add    $0x2,%rbp
add    %rdx,%rbx
cmp    %rbp,%r10
jne    1ca0 <minfit+0xb30>
cmp    0x68(%rsp),%r9d
jge    1ee0 <minfit+0xd70>
mov    0x10(%rsp),%rax
lea    (%r11,%rax,8),%r15
movslq 0x60(%rsp),%rdi
mov    0xa0(%rsp),%rax
add    %rdi,%rax
mov    %rax,0xd8(%rsp)
mov    %rdi,%rcx
imul   0x8(%rsp),%rcx
lea    0x1(%rdi),%rax
mov    %rax,0x110(%rsp)
mov    0x78(%rsp),%rax
mov    %rcx,0xb0(%rsp)
add    %rcx,%rax
mov    %rax,0x130(%rsp)
mov    %r11,%r14
mov    %rdi,%r13
mov    %rdi,0xa8(%rsp)
jmp    1d5a <minfit+0xbea>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13
add    $0x8,%r14
add    $0x8,%r15
cmp    %r10,%r13
mov    0x28(%rsp),%r11
je     1ee0 <minfit+0xd70>
xorpd  %xmm2,%xmm2
mov    %rdi,%rbp
testb  $0x1,0x30(%rsp)
je     1d97 <minfit+0xc27>
mov    0xd8(%rsp),%rax
movsd  (%r11,%rax,8),%xmm1
mov    0xb0(%rsp),%rax
add    %r13,%rax
mulsd  (%r11,%rax,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x110(%rsp),%rbp
movapd %xmm1,%xmm2
mov    0x40(%rsp),%rax
cmp    (%rsp),%rax
je     1dfd <minfit+0xc8d>
mov    0x8(%rsp),%rdi
mov    %rdi,%rax
imul   %rbp,%rax
lea    (%r14,%rax,8),%rcx
lea    0x1(%rbp),%rax
imul   %rdi,%rax
mov    0xa8(%rsp),%rdi
lea    (%r14,%rax,8),%rax
mov    0x10(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rbp,8),%xmm3
mulsd  (%rcx,%rbx,8),%xmm3
movsd  (%rsi,%rbp,8),%xmm1
addsd  %xmm2,%xmm3
mulsd  (%rax,%rbx,8),%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rbp
add    %rdx,%rbx
movapd %xmm1,%xmm2
cmp    %rbp,%r10
jne    1dd0 <minfit+0xc60>
mov    %rdi,%rbx
testb  $0x1,0x30(%rsp)
je     1e38 <minfit+0xcc8>
mov    0xb0(%rsp),%rax
add    %r13,%rax
mov    0x130(%rsp),%rcx
movsd  (%r11,%rcx,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r11,%rax,8),%xmm2
movsd  %xmm2,(%r11,%rax,8)
mov    0x110(%rsp),%rbx
mov    0x40(%rsp),%rax
cmp    (%rsp),%rax
je     1d40 <minfit+0xbd0>
mov    %r10,%rbp
sub    %rbx,%rbp
mov    0x8(%rsp),%r9
mov    %r9,%rax
imul   %rbx,%rax
lea    (%rax,%r13,1),%rcx
mov    0x28(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
add    0xe0(%rsp),%rax
lea    (%rdi,%rax,8),%rax
mov    0x20(%rsp),%r10
add    $0x1,%rbx
imul   %r9,%rbx
lea    (%r15,%rbx,8),%r11
mov    0x80(%rsp),%rdi
lea    (%rdi,%rbx,8),%rbx
mov    0xa8(%rsp),%rdi
xor    %r9d,%r9d
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%r9,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rcx,%r9,1),%xmm2
movsd  %xmm2,(%rcx,%r9,1)
movsd  (%rbx,%r9,1),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%r11,%r9,1),%xmm2
movsd  %xmm2,(%r11,%r9,1)
add    %r8,%r9
add    $0xfffffffffffffffe,%rbp
jne    1ea0 <minfit+0xd30>
jmp    1d40 <minfit+0xbd0>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%r14
cmp    0x68(%rsp),%r14d
mov    0x58(%rsp),%r9
mov    0x78(%rsp),%rdi
jge    1b50 <minfit+0x9e0>
movslq %r14d,%rbp
testb  $0x1,0x30(%rsp)
je     1f2f <minfit+0xdbf>
mov    %rbp,%rax
imul   0x8(%rsp),%rax
add    %rdi,%rax
movq   $0x0,(%r11,%rax,8)
mov    0xa0(%rsp),%rax
add    %rbp,%rax
movq   $0x0,(%r11,%rax,8)
add    $0x1,%rbp
mov    0x40(%rsp),%rax
cmp    (%rsp),%rax
je     1b50 <minfit+0x9e0>
lea    0x1(%rbp),%rax
mov    0x8(%rsp),%rcx
imul   %rcx,%rax
mov    0xf0(%rsp),%rbx
lea    (%rbx,%rax,8),%rax
imul   %rbp,%rcx
lea    (%rbx,%rcx,8),%rcx
mov    0x98(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
movq   $0x0,(%rcx,%rbx,8)
movq   $0x0,-0x8(%rsi,%rbp,8)
movq   $0x0,(%rax,%rbx,8)
movq   $0x0,(%rsi,%rbp,8)
add    $0x2,%rbp
add    %rdx,%rbx
cmp    %rbp,%r10
jne    1f70 <minfit+0xe00>
jmp    1b50 <minfit+0x9e0>
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%r8
mov    0x120(%rsp),%r12d
jmp    1fc5 <minfit+0xe55>
xorpd  %xmm4,%xmm4
mov    0x58(%rsp),%r9
mov    %r13,%r11
mov    %r15,%rdi
mov    0x68(%rsp),%rax
sub    %r12d,%eax
jle    2074 <minfit+0xf04>
mov    %eax,0x30(%rsp)
mov    0x90(%rsp),%rdx
mov    %edx,%eax
imul   %r12d,%eax
mov    0x68(%rsp),%rsi
lea    (%rax,%rsi,1),%ecx
mov    %ecx,(%rsp)
lea    0x1(%rsi),%ecx
cmp    %ecx,%edx
cmovg  %edx,%ecx
mov    %esi,%edx
not    %edx
add    %ecx,%edx
lea    0x8(,%rdx,8),%rcx
mov    %rcx,0x40(%rsp)
not    %r12d
xor    %ebx,%ebx
add    %esi,%r12d
movapd %xmm4,0x120(%rsp)
jne    2c16 <minfit+0x1aa6>
testb  $0x1,0x30(%rsp)
je     2074 <minfit+0xf04>
cmpl   $0x0,0x108(%rsp)
jle    2074 <minfit+0xf04>
imul   0x90(%rsp),%ebx
mov    (%rsp),%eax
add    %ebx,%eax
cltq
lea    (%r11,%rax,8),%rdi
xor    %esi,%esi
mov    0x40(%rsp),%rdx
call   1050 <memset@plt>
movapd 0x120(%rsp),%xmm4
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x58(%rsp),%r9
cmpl   $0x0,0x68(%rsp)
jle    2bea <minfit+0x1a7a>
mulsd  0x140(%rsp),%xmm4
movabs $0xffffffff00000000,%rcx
ff ff ff
lea    -0x1(%r10),%rdx
lea    0x1(%r10),%rax
cmp    %r8,%rax
cmovle %r8,%rax
mov    %rax,0x190(%rsp)
sub    %r10,%rax
mov    %rax,0xd0(%rsp)
and    $0xfffffffffffffffe,%rax
mov    %rax,0x140(%rsp)
add    %r10,%rax
mov    %rax,0x1a8(%rsp)
mov    0x70(%rsp),%rax
and    $0xfffffffe,%eax
mov    %rax,0x1b8(%rsp)
mov    %r10,%rax
shl    $0x20,%rax
add    %rcx,%rax
mov    %rax,0x1a0(%rsp)
mov    0x68(%rsp),%rax
add    $0xfffffffe,%eax
imul   0x90(%rsp),%eax
mov    %eax,0xcc(%rsp)
lea    (%r11,%r10,8),%rax
mov    %rax,0x188(%rsp)
lea    0x0(,%r8,8),%rax
mov    %rax,0xa8(%rsp)
mov    %r8,%rax
shl    $0x20,%rax
mov    %rax,0x148(%rsp)
lea    0x8(%r11),%rax
mov    %rax,0x1c0(%rsp)
lea    (%r10,%r8,1),%rax
lea    (%r11,%rax,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x180(%rsp)
mov    %r8,%rax
shl    $0x4,%rax
mov    %rax,0x1b0(%rsp)
xorpd  %xmm0,%xmm0
movhpd 0xeb6(%rip),%xmm0
movapd %xmm0,0x1d0(%rsp)
movapd 0xe95(%rip),%xmm1
movapd 0xe7d(%rip),%xmm2
lea    (%r11,%r10,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x178(%rsp)
movapd %xmm4,0x120(%rsp)
mov    %rdx,%r10
lea    -0x1(%rdx),%rbx
mov    $0x1,%eax
mov    %rdx,0x78(%rsp)
mov    %rbx,0x198(%rsp)
jmp    2210 <minfit+0x10a0>
nopw   0x0(%rax,%rax,1)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd 0x120(%rsp),%xmm4
mov    0x1c8(%rsp),%rbp
movq   $0x0,(%rdi,%rbp,8)
movsd  %xmm0,(%rdi,%r10,8)
movsd  %xmm3,(%r9,%r10,8)
mov    0x174(%rsp),%eax
add    $0x1,%eax
cmp    $0x33,%eax
movapd 0xe0e(%rip),%xmm1
movapd 0xdf6(%rip),%xmm2
je     2bf3 <minfit+0x1a83>
mov    %eax,0x174(%rsp)
mov    %r10d,%esi
mov    0xcc(%rsp),%edx
mov    0x1a0(%rsp),%rax
mov    %r10,%rcx
nopl   0x0(%rax)
mov    %rcx,%rbx
mov    %rax,%rbp
mov    %edx,%r14d
mov    %esi,%ecx
mov    %rcx,(%rsp)
test   %rbx,%rbx
mov    %rax,0x30(%rsp)
mov    %rbx,0x40(%rsp)
js     229d <minfit+0x112d>
mov    %ebx,%ecx
movsd  (%rdi,%rcx,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm4
jae    22ad <minfit+0x113d>
mov    0x40(%rsp),%rbx
lea    -0x1(%rbx),%rcx
movsd  -0x8(%r9,%rbx,8),%xmm0
andpd  %xmm1,%xmm0
movabs $0xffffffff00000000,%rdx
ff ff ff
mov    0x30(%rsp),%rbp
lea    (%rdx,%rbp,1),%rax
mov    %r14d,%edx
sub    0x90(%rsp),%edx
mov    (%rsp),%rsi
add    $0xffffffff,%esi
ucomisd %xmm0,%xmm4
jb     2230 <minfit+0x10c0>
mov    %rbp,%rbx
sar    $0x20,%rbx
cmp    %r10,%rbx
jle    28a0 <minfit+0x1730>
movsd  (%r9,%r10,8),%xmm3
mov    0x40(%rsp),%eax
cmp    %r10,%rax
je     2b00 <minfit+0x1990>
mov    0x30(%rsp),%rax
mov    %rax,%rbp
sar    $0x20,%rbp
sar    $0x1d,%rax
movsd  (%r9,%rax,1),%xmm0
movaps %xmm0,0x30(%rsp)
mov    0x198(%rsp),%rbx
movsd  (%r9,%rbx,8),%xmm4
movsd  %xmm4,0xb0(%rsp)
movsd  (%rdi,%rbx,8),%xmm5
movsd  (%rdi,%r10,8),%xmm2
movapd %xmm3,%xmm1
addsd  %xmm5,%xmm1
divsd  %xmm2,%xmm1
subsd  %xmm3,%xmm5
divsd  %xmm4,%xmm5
mulsd  %xmm1,%xmm5
movapd %xmm4,%xmm0
movapd %xmm2,0x40(%rsp)
divsd  %xmm2,%xmm0
addsd  %xmm5,%xmm0
movapd %xmm2,%xmm1
divsd  %xmm4,%xmm1
subsd  %xmm1,%xmm0
mulsd  0xced(%rip),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0xcd7(%rip),%xmm1
movapd %xmm3,0x110(%rsp)
call   1070 <hypot@plt>
movapd 0x30(%rsp),%xmm3
mov    0x78(%rsp),%r10
movsd  0x10(%rsp),%xmm4
movapd %xmm4,%xmm1
cmpltsd 0xcbb(%rip),%xmm1
movapd %xmm1,%xmm2
andnpd %xmm0,%xmm2
xorpd  0xc7b(%rip),%xmm0
andpd  %xmm1,%xmm0
orpd   %xmm2,%xmm0
addsd  %xmm4,%xmm0
movapd 0x110(%rsp),%xmm2
movapd %xmm2,%xmm1
divsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm1
movapd %xmm3,%xmm2
subsd  %xmm1,%xmm2
movsd  0xb0(%rsp),%xmm1
divsd  %xmm0,%xmm1
movapd 0x40(%rsp),%xmm0
subsd  %xmm0,%xmm1
divsd  %xmm3,%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm2,%xmm0
cmp    %r10,%rbp
jge    2870 <minfit+0x1700>
mov    %rbp,%rdx
mov    0x8(%rsp),%r8
imul   %r8,%rdx
mov    0x190(%rsp),%rcx
lea    (%rcx,%rdx,1),%rax
mov    %rax,0x150(%rsp)
mov    0x20(%rsp),%rax
add    %rax,%rdx
mov    %rdx,0x168(%rsp)
lea    0x1(%rbp),%rdx
imul   %r8,%rdx
add    %rdx,%rcx
mov    %rcx,0x158(%rsp)
add    %rax,%rdx
mov    %rdx,0x160(%rsp)
unpcklpd %xmm0,%xmm3
movslq (%rsp),%rax
mov    %rax,%rbx
shl    $0x20,%rbx
mov    0x1c0(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    %r8,%rcx
imul   %rax,%rcx
mov    0x188(%rsp),%rdi
lea    (%rdi,%rcx,8),%rdx
add    $0x1,%rax
imul   %r8,%rax
lea    (%rdi,%rax,8),%r12
mov    0x28(%rsp),%r11
lea    (%r11,%rax,8),%r14
lea    (%r11,%rcx,8),%r15
xor    %ecx,%ecx
mov    %rbp,0x1c8(%rsp)
movsd  0xb9f(%rip),%xmm1
movapd %xmm1,%xmm6
mov    0x58(%rsp),%r9
mov    0x18(%rsp),%rdi
jmp    251d <minfit+0x13ad>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm1,%xmm0
xorpd  0xb54(%rip),%xmm0
movapd 0x80(%rsp),%xmm3
movapd %xmm3,%xmm2
movapd 0xe0(%rsp),%xmm4
unpcklpd %xmm4,%xmm2
unpcklpd %xmm1,%xmm0
mulpd  %xmm2,%xmm0
unpcklpd %xmm3,%xmm4
movapd %xmm6,%xmm3
mulpd  %xmm4,%xmm3
addpd  %xmm0,%xmm3
mov    0x110(%rsp),%rcx
add    $0x1,%rcx
movabs $0x100000000,%rax
add    %rax,%rbx
add    $0x8,%rsi
mov    0xa8(%rsp),%rax
add    %rax,%rdx
add    %rax,%r12
add    %rax,%r14
add    %rax,%r15
mov    0x10(%rsp),%rbp
cmp    %r10,%rbp
jge    21c0 <minfit+0x1050>
mov    %rbx,(%rsp)
mov    %rdx,0xd8(%rsp)
movapd %xmm3,0x30(%rsp)
mov    %rcx,0x110(%rsp)
mov    %rcx,%rax
imul   %r8,%rax
mov    0x168(%rsp),%rcx
add    %rax,%rcx
lea    (%r11,%rcx,8),%rcx
mov    %rcx,0xc0(%rsp)
mov    0x150(%rsp),%rcx
add    %rax,%rcx
lea    (%r11,%rcx,8),%rcx
mov    %rcx,0xf0(%rsp)
mov    0x160(%rsp),%rcx
add    %rax,%rcx
lea    (%r11,%rcx,8),%rcx
mov    %rcx,0x98(%rsp)
add    0x158(%rsp),%rax
lea    (%r11,%rax,8),%rax
mov    %rax,0xa0(%rsp)
lea    0x1(%rbp),%rax
mov    %rax,0x10(%rsp)
movsd  0x8(%rdi,%rbp,8),%xmm0
movsd  0x8(%r9,%rbp,8),%xmm2
movsd  %xmm2,0xb0(%rsp)
mulsd  %xmm0,%xmm1
movapd %xmm1,0x40(%rsp)
mulsd  %xmm0,%xmm6
movapd %xmm6,0x80(%rsp)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
mov    %rdi,%r13
mov    %rsi,%rbx
call   1070 <hypot@plt>
movapd 0x40(%rsp),%xmm6
movapd 0x30(%rsp),%xmm5
mov    0x28(%rsp),%rdi
mov    %rbp,0x60(%rsp)
movsd  %xmm0,0x0(%r13,%rbp,8)
shufpd $0x2,%xmm5,%xmm6
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
movapd 0x80(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
movapd %xmm6,%xmm2
mulsd  %xmm5,%xmm2
mulsd  %xmm0,%xmm5
addsd  %xmm1,%xmm5
movapd %xmm3,%xmm1
mulsd  %xmm0,%xmm1
subsd  %xmm2,%xmm1
movapd %xmm1,0x80(%rsp)
movsd  0xb0(%rsp),%xmm3
movapd %xmm3,%xmm1
mulsd  %xmm6,%xmm1
movapd %xmm0,%xmm2
mulsd  %xmm3,%xmm2
movapd %xmm2,0xe0(%rsp)
mov    0x70(%rsp),%rax
mov    %rbx,0xb0(%rsp)
mov    %rbx,%rcx
mov    (%rsp),%rdx
mov    0x148(%rsp),%rbp
mov    0xa8(%rsp),%rbx
xchg   %ax,%ax
mov    %rdx,%rsi
sar    $0x1d,%rsi
movsd  (%rdi,%rsi,1),%xmm7
movsd  (%rcx),%xmm2
movapd %xmm6,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm6,%xmm4
mulsd  %xmm7,%xmm4
mulsd  %xmm0,%xmm7
addsd  %xmm3,%xmm7
movsd  %xmm7,(%rdi,%rsi,1)
mulsd  %xmm0,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,(%rcx)
add    %rbp,%rdx
add    %rbx,%rcx
add    $0xffffffffffffffff,%rax
jne    2690 <minfit+0x1520>
movapd %xmm5,%xmm0
movapd %xmm5,0x30(%rsp)
movapd %xmm6,0x40(%rsp)
movapd %xmm1,0x130(%rsp)
call   1070 <hypot@plt>
movapd 0x40(%rsp),%xmm1
mov    0x58(%rsp),%r9
mov    0x60(%rsp),%rax
movsd  %xmm0,(%r9,%rax,8)
ucomisd 0x91f(%rip),%xmm0
jne    2715 <minfit+0x15a5>
jnp    272c <minfit+0x15bc>
movapd 0x130(%rsp),%xmm1
unpcklpd 0x30(%rsp),%xmm1
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movapd %xmm1,%xmm6
unpckhpd %xmm1,%xmm6
cmpl   $0x0,0x108(%rsp)
mov    0x28(%rsp),%r11
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%r8
mov    0x78(%rsp),%r10
mov    (%rsp),%rbx
mov    0xb0(%rsp),%rsi
mov    0xd8(%rsp),%rdx
jle    24a0 <minfit+0x1330>
mov    %rcx,%rax
cmpq   $0x2,0xd0(%rsp)
jb     2820 <minfit+0x16b0>
mov    0xa0(%rsp),%rax
cmp    %rax,0xc0(%rsp)
jae    27ac <minfit+0x163c>
mov    %rcx,%rax
mov    0x98(%rsp),%rcx
cmp    0xf0(%rsp),%rcx
jb     2820 <minfit+0x16b0>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
xor    %eax,%eax
mov    0x140(%rsp),%rcx
xchg   %ax,%ax
movupd (%rdx,%rax,8),%xmm5
movupd (%r12,%rax,8),%xmm2
movapd %xmm0,%xmm3
mulpd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm5,%xmm4
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm5,(%rdx,%rax,8)
mulpd  %xmm6,%xmm2
subpd  %xmm4,%xmm2
movupd %xmm2,(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    27c0 <minfit+0x1650>
mov    0x1a8(%rsp),%rax
cmp    %rcx,0xd0(%rsp)
je     24a0 <minfit+0x1330>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,8),%xmm0
movsd  (%r14,%rax,8),%xmm4
movapd %xmm1,%xmm2
mulsd  %xmm4,%xmm2
movapd %xmm1,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm6,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%r15,%rax,8)
mulsd  %xmm6,%xmm4
subsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rax,8)
add    $0x1,%rax
cmp    %r8,%rax
jl     2820 <minfit+0x16b0>
jmp    24a0 <minfit+0x1330>
cs nopw 0x0(%rax,%rax,1)
mov    0x58(%rsp),%r9
mov    0x28(%rsp),%r11
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%r8
movapd 0x120(%rsp),%xmm4
jmp    21d9 <minfit+0x1069>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %r14d,%rax
mov    0x20(%rsp),%rdx
lea    (%rdx,%rax,1),%rcx
lea    (%r11,%rcx,8),%rbp
mov    0x190(%rsp),%rsi
lea    (%rsi,%rax,1),%rcx
lea    (%r11,%rcx,8),%rcx
mov    %rcx,0x80(%rsp)
mov    %rbx,%rcx
imul   %r8,%rcx
add    %rcx,%rsi
mov    %rsi,0x10(%rsp)
add    %rdx,%rcx
mov    %rcx,0xe0(%rsp)
movslq (%rsp),%rcx
imul   %r8,%rcx
mov    0x188(%rsp),%rdx
lea    (%rdx,%rcx,8),%r12
lea    (%r11,%rcx,8),%r13
lea    (%r11,%rax,8),%r14
xor    %r15d,%r15d
movapd 0x1d0(%rsp),%xmm6
jmp    2950 <minfit+0x17e0>
nopl   0x0(%rax)
lea    0x1(%rbx),%rax
add    $0x1,%r15
mov    0xa8(%rsp),%rcx
add    %rcx,%r12
add    %rcx,%r13
cmp    %r10,%rbx
mov    %rax,%rbx
mov    0x18(%rsp),%rdi
movapd 0x120(%rsp),%xmm4
movapd 0x6ce(%rip),%xmm1
movapd 0x6b6(%rip),%xmm2
jge    22ad <minfit+0x113d>
movsd  (%rdi,%rbx,8),%xmm3
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
mulsd  %xmm3,%xmm0
mulsd  %xmm3,%xmm6
movsd  %xmm6,(%rdi,%rbx,8)
movapd %xmm0,%xmm3
andpd  %xmm1,%xmm3
ucomisd %xmm3,%xmm4
jae    22ad <minfit+0x113d>
movsd  (%r9,%rbx,8),%xmm1
movaps %xmm1,0x110(%rsp)
movapd %xmm0,0xb0(%rsp)
call   1070 <hypot@plt>
movapd 0x110(%rsp),%xmm6
mov    0x78(%rsp),%r10
mov    0x8(%rsp),%r8
mov    0x28(%rsp),%r11
mov    0x58(%rsp),%r9
movsd  %xmm0,(%r9,%rbx,8)
movapd 0xb0(%rsp),%xmm1
xorpd  0x634(%rip),%xmm1
unpcklpd %xmm1,%xmm6
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
cmpl   $0x0,0x108(%rsp)
mov    0x20(%rsp),%rdx
jle    2910 <minfit+0x17a0>
movapd %xmm6,%xmm0
unpckhpd %xmm6,%xmm0
mov    %rdx,%rax
cmpq   $0x2,0xd0(%rsp)
jb     2ab0 <minfit+0x1940>
mov    %r15,%rax
imul   %r8,%rax
mov    0x10(%rsp),%rcx
add    %rax,%rcx
lea    (%r11,%rcx,8),%rcx
cmp    %rcx,%rbp
jae    2a36 <minfit+0x18c6>
add    0xe0(%rsp),%rax
lea    (%r11,%rax,8),%rcx
mov    %rdx,%rax
cmp    0x80(%rsp),%rcx
jb     2ab0 <minfit+0x1940>
movapd %xmm6,%xmm1
unpcklpd %xmm6,%xmm1
xor    %eax,%eax
mov    0x140(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rax,8),%xmm2
movupd (%r12,%rax,8),%xmm3
movapd %xmm0,%xmm4
mulpd  %xmm3,%xmm4
movapd %xmm0,%xmm5
mulpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,0x0(%rbp,%rax,8)
mulpd  %xmm1,%xmm3
subpd  %xmm5,%xmm3
movupd %xmm3,(%r12,%rax,8)
add    $0x2,%rax
cmp    %rax,%rcx
jne    2a50 <minfit+0x18e0>
mov    0x1a8(%rsp),%rax
cmp    %rcx,0xd0(%rsp)
je     2910 <minfit+0x17a0>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm1
movsd  0x0(%r13,%rax,8),%xmm2
movapd %xmm0,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm0,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm6,%xmm1
addsd  %xmm3,%xmm1
movsd  %xmm1,(%r14,%rax,8)
mulsd  %xmm6,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,0x0(%r13,%rax,8)
add    $0x1,%rax
cmp    %r8,%rax
jl     2ab0 <minfit+0x1940>
jmp    2910 <minfit+0x17a0>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
mov    0x180(%rsp),%rsi
mov    0x178(%rsp),%rbx
jbe    2b9a <minfit+0x1a2a>
xorpd  0x4da(%rip),%xmm3
movlpd %xmm3,(%r9,%r10,8)
cmpl   $0x1,0x68(%rsp)
mov    0x1b8(%rsp),%rdx
mov    0x1b0(%rsp),%rbp
jne    2b47 <minfit+0x19d7>
xor    %eax,%eax
jmp    2b78 <minfit+0x1a08>
xor    %ecx,%ecx
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movsd  (%rbx,%rcx,1),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rbx,%rcx,1)
movsd  (%rsi,%rcx,1),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rsi,%rcx,1)
add    $0x2,%rax
add    %rbp,%rcx
cmp    %rax,%rdx
jne    2b50 <minfit+0x19e0>
testb  $0x1,0x70(%rsp)
je     2b9a <minfit+0x1a2a>
imul   %r8,%rax
add    %r10,%rax
movsd  (%r11,%rax,8),%xmm0
xorpd  0x46c(%rip),%xmm0
movlpd %xmm0,(%r11,%rax,8)
movabs $0xffffffff00000000,%rax
ff ff ff
add    %rax,0x1a0(%rsp)
mov    0xcc(%rsp),%eax
sub    0x90(%rsp),%eax
mov    %eax,0xcc(%rsp)
add    $0xfffffffffffffff8,%rsi
mov    %rsi,0x180(%rsp)
add    $0xfffffffffffffff8,%rbx
mov    %rbx,0x178(%rsp)
test   %r10,%r10
mov    0x198(%rsp),%rdx
jg     219c <minfit+0x102c>
call   1030 <free@plt>
xor    %eax,%eax
jmp    2c04 <minfit+0x1a94>
lea    0x43e(%rip),%rdi
call   1040 <puts@plt>
mov    $0xf,%eax
add    $0x1e8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x30(%rsp),%r12d
and    $0xfffffffe,%r12d
add    0x108(%rsp),%eax
mov    0x68(%rsp),%rcx
lea    (%rax,%rcx,2),%ebp
mov    0x90(%rsp),%rax
lea    (%rax,%rax,1),%r13d
xor    %ebx,%ebx
mov    (%rsp),%r14d
mov    0x40(%rsp),%r15
jmp    2c62 <minfit+0x1af2>
nopw   0x0(%rax,%rax,1)
add    $0x2,%ebx
add    %r13d,%ebp
add    %r13d,%r14d
cmp    %ebx,%r12d
je     2022 <minfit+0xeb2>
cmpl   $0x0,0x108(%rsp)
jle    2c50 <minfit+0x1ae0>
movslq %r14d,%rax
lea    (%r11,%rax,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1050 <memset@plt>
movslq %ebp,%rax
mov    0x28(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1050 <memset@plt>
movapd 0x120(%rsp),%xmm4
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%r10
mov    0x28(%rsp),%r11
mov    0x58(%rsp),%r9
jmp    2c50 <minfit+0x1ae0>

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

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