#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
int /*<<< orphan*/ printf(char *);
double sqrt(double);
void circlefit(double pts[][2], int npoints, double *radius, double *center,
               double *detcoeff) {
  int point, iter;
  double centroid[2];
  double Mxx, Myy, Mzz, Mxy, Mxz, Myz;
  double Mz, Cov_xy;
  double A0, A1, A2, A3, A22, A33;
  double norm_pt[3];
  double new_pt[2], old_pt[2], epsilon, maxIter, Dy;
  double Det;
  double diff[2];
  for (point = 0; point < npoints; point++) {
    centroid[0] += pts[point][0];
    centroid[1] += pts[point][1];
  }
  centroid[0] /= (double)npoints;
  centroid[1] /= (double)npoints;
  Mxx = 0.0;
  Myy = 0.0;
  Mzz = 0.0;
  Mxy = 0.0;
  Mxz = 0.0;
  Myz = 0.0;
  for (point = 0; point < npoints; point++) {
    norm_pt[0] = pts[point][0] - centroid[0];
    norm_pt[1] = pts[point][1] - centroid[1];
    norm_pt[2] = norm_pt[0] * norm_pt[0] + norm_pt[1] * norm_pt[1];
    Mxx += norm_pt[0] * norm_pt[0];
    Myy += norm_pt[1] * norm_pt[1];
    Mzz += norm_pt[2] * norm_pt[2];
    Mxy += norm_pt[0] * norm_pt[1];
    Mxz += norm_pt[0] * norm_pt[2];
    Myz += norm_pt[1] * norm_pt[2];
  }
  Mxx /= (double)npoints;
  Myy /= (double)npoints;
  Mzz /= (double)npoints;
  Mxy /= (double)npoints;
  Mxz /= (double)npoints;
  Myz /= (double)npoints;
  Mz = Mxx + Myy;
  Cov_xy = Mxx * Myy - Mxy * Mxy;
  A0 = Mxz * Mxz * Myy + Myz * Myz * Mxx - Mzz * Cov_xy -
       2.0 * Mxz * Myz * Mxy + Mz * Mz * Cov_xy;
  A1 = Mzz * Mz + 4 * Cov_xy * Mz - Mxz * Mxz - Myz * Myz - Mz * Mz * Mz;
  A2 = -3 * Mz * Mz - Mzz;
  A3 = 4 * Mz;
  A22 = 2.0 * A2;
  A33 = 3.0 * A3;
  new_pt[0] = 0.0;
  new_pt[1] = 1e+20;
  epsilon = 1e-12;
  maxIter = 20;
  iter = 0;
  do {
    old_pt[1] = new_pt[1];
    new_pt[1] = A0 + new_pt[0] * (A1 + new_pt[0] * (A2 + new_pt[0] * A3));
    if (fabs(new_pt[1]) > fabs(old_pt[1])) {
      new_pt[0] = 0.0;
      printf("WARNING: Newton-Taubin goes in wrong direction.\n");
      break;
    }
    Dy = A1 + new_pt[0] * (A22 + new_pt[0] * A33);
    old_pt[0] = new_pt[0];
    new_pt[0] = old_pt[0] - new_pt[1] / Dy;
    if (new_pt[0] < 0.0) {
      new_pt[0] = 0.0;
    }
  } while ((fabs((new_pt[0] - old_pt[0]) / new_pt[0]) > epsilon) &&
           (++iter < maxIter));
  if (iter == maxIter) {
    new_pt[0] = 0.0;
    printf("Newton-Taubin don't converge.\n");
  }
  Det = new_pt[0] * new_pt[0] - new_pt[0] * Mz + Cov_xy;
  center[0] = (Mxz * (Myy - new_pt[0]) - Myz * Mxy) / (2.0 * Det);
  center[1] = (Myz * (Mxx - new_pt[0]) - Mxz * Mxy) / (2.0 * Det);
  *radius = sqrt(((center[0] * center[0]) + (center[1] * center[1])) + Mz);
  center[0] += centroid[0];
  center[1] += centroid[1];
  *detcoeff = 0.0;
  for (point = 0; point < npoints; point++) {
    diff[0] = pts[point][0] - center[0];
    diff[1] = pts[point][1] - center[1];
    *detcoeff += fabs((sqrt(diff[0] * diff[0] + diff[1] * diff[1])) - *radius);
  }
  *detcoeff /= npoints;
}


x86 assembly (clang, -O0):
<circlefit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    119a <circlefit+0x7a>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
addsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1145 <circlefit+0x25>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x38(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    134e <circlefit+0x22e>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xd0(%rbp),%xmm2
ff
movsd  -0x48(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0xd0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0xc8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f7 <circlefit+0xd7>
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x48(%rbp),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm1
mulsd  -0x68(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm0
mulsd  -0x70(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xbc2(%rip),%xmm1
mulsd  -0x68(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm2
movsd  0xb6b(%rip),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x70(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x78(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0xad1(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xa8b(%rip),%xmm0
mulsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xa6e(%rip),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0xa4e(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0xa23(%rip),%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  0xa0b(%rip),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  0x9f3(%rip),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movl   $0x0,-0x30(%rbp)
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0x90(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0x98(%rbp),%xmm5
ff
movsd  -0xe0(%rbp),%xmm4
ff
movsd  -0xa0(%rbp),%xmm6
ff
mulsd  %xmm6,%xmm4
addsd  %xmm5,%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movaps 0x9ad(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0xe8(%rbp),%xmm1
ff
movaps 0x99a(%rip),%xmm2
pand   %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    16d0 <circlefit+0x5b0>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
lea    0x98a(%rip),%rdi
call   1030 <printf@plt>
jmp    17ce <circlefit+0x6ae>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xa8(%rbp),%xmm3
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xb0(%rbp),%xmm4
ff
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm1
ff
divsd  -0x108(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xe0(%rbp),%xmm0
ff
jbe    1760 <circlefit+0x640>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
jmp    1765 <circlefit+0x645>
movsd  -0xe0(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
divsd  -0xe0(%rbp),%xmm0
ff
movaps 0x8bc(%rip),%xmm1
pand   %xmm1,%xmm0
xor    %eax,%eax
ucomisd -0xf8(%rbp),%xmm0
ff
mov    %al,-0x121(%rbp)
jbe    17c0 <circlefit+0x6a0>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
cvtsi2sd %eax,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0x121(%rbp)
mov    -0x121(%rbp),%al
test   $0x1,%al
jne    161c <circlefit+0x4fc>
cvtsi2sdl -0x30(%rbp),%xmm0
ucomisd -0x100(%rbp),%xmm0
ff
jne    17fe <circlefit+0x6de>
jp     17fe <circlefit+0x6de>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
lea    0x888(%rip),%rdi
call   1030 <printf@plt>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  -0xe0(%rbp),%xmm2
ff
movsd  -0xe0(%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
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
subsd  -0xe0(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x796(%rip),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x70(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm2
subsd  -0xe0(%rbp),%xmm2
ff
movsd  -0x68(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x73f(%rip),%xmm1
mulsd  -0x110(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x20(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
call   1040 <sqrt@plt>
mov    -0x18(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  -0x38(%rbp),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a16 <circlefit+0x8f6>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x120(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x118(%rbp),%xmm1
ff
mulsd  -0x118(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm0
movaps 0x648(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x28(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1968 <circlefit+0x848>
cvtsi2sdl -0xc(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<circlefit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r8,%r14
mov    %rcx,%r12
mov    %rdx,%r15
mov    %esi,%ebp
mov    %rdi,%rbx
mov    %esi,%r13d
test   %esi,%esi
jle    115a <circlefit+0x3a>
lea    -0x1(%r13),%rcx
mov    %r13d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1174 <circlefit+0x54>
xor    %ecx,%ecx
jmp    11b0 <circlefit+0x90>
cvtsi2sd %ebp,%xmm1
xorpd  %xmm2,%xmm2
movapd 0xe96(%rip),%xmm0
movapd %xmm0,(%rsp)
jmp    12b6 <circlefit+0x196>
mov    %r13d,%edx
and    $0xfffffffc,%edx
lea    0x30(%rbx),%rsi
xor    %ecx,%ecx
movupd -0x30(%rsi),%xmm0
addpd  %xmm7,%xmm0
movupd -0x20(%rsi),%xmm1
addpd  %xmm0,%xmm1
movupd -0x10(%rsi),%xmm0
addpd  %xmm1,%xmm0
movupd (%rsi),%xmm7
addpd  %xmm0,%xmm7
add    $0x4,%rcx
add    $0x40,%rsi
cmp    %rcx,%rdx
jne    1180 <circlefit+0x60>
test   %rax,%rax
je     11e2 <circlefit+0xc2>
shl    $0x4,%rcx
add    %rbx,%rcx
shl    $0x4,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rcx,%rdx,1),%xmm0
addpd  %xmm0,%xmm7
add    $0x10,%rdx
cmp    %rdx,%rax
jne    11d0 <circlefit+0xb0>
xorps  %xmm1,%xmm1
cvtsi2sd %ebp,%xmm1
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
divpd  %xmm0,%xmm7
test   %ebp,%ebp
movapd %xmm7,(%rsp)
jle    12b2 <circlefit+0x192>
movapd %xmm1,%xmm8
mov    %r13,%rax
shl    $0x4,%rax
xorpd  %xmm4,%xmm4
xor    %ecx,%ecx
xorpd  %xmm3,%xmm3
xorpd  %xmm5,%xmm5
nopl   0x0(%rax)
movapd %xmm5,%xmm1
movapd %xmm3,%xmm9
movapd %xmm4,%xmm6
movupd (%rbx,%rcx,1),%xmm4
subpd  %xmm7,%xmm4
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
movapd %xmm0,%xmm3
mulsd  %xmm0,%xmm3
movapd %xmm4,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
unpcklpd %xmm4,%xmm0
mulpd  %xmm0,%xmm0
movapd %xmm0,%xmm3
addpd  %xmm9,%xmm3
movapd %xmm4,%xmm5
unpcklpd %xmm2,%xmm5
movapd %xmm4,%xmm14
shufpd $0x1,%xmm2,%xmm14
mulpd  %xmm5,%xmm14
movapd %xmm14,%xmm5
addpd  %xmm1,%xmm5
unpcklpd %xmm2,%xmm2
mulpd  %xmm4,%xmm2
movapd %xmm2,%xmm4
addpd  %xmm6,%xmm4
add    $0x10,%rcx
cmp    %rcx,%rax
jne    1220 <circlefit+0x100>
addpd  %xmm6,%xmm2
addpd  %xmm1,%xmm14
addpd  %xmm9,%xmm0
movapd %xmm8,%xmm1
jmp    12bf <circlefit+0x19f>
xorpd  %xmm2,%xmm2
xorpd  %xmm0,%xmm0
xorpd  %xmm14,%xmm14
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
divpd  %xmm4,%xmm0
movapd %xmm1,%xmm3
movapd %xmm14,%xmm1
unpckhpd %xmm14,%xmm1
divsd  %xmm3,%xmm1
movapd %xmm3,0x70(%rsp)
divsd  %xmm3,%xmm14
divpd  %xmm4,%xmm2
movapd %xmm0,%xmm5
unpckhpd %xmm0,%xmm5
movapd %xmm0,%xmm15
addsd  %xmm5,%xmm15
movapd %xmm14,%xmm6
mulsd  %xmm14,%xmm6
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm3,%xmm4
mulsd  %xmm5,%xmm4
movapd %xmm5,%xmm7
mulsd  %xmm0,%xmm7
subsd  %xmm6,%xmm7
movapd %xmm2,%xmm6
mulsd  %xmm2,%xmm6
mulsd  %xmm0,%xmm6
addsd  %xmm4,%xmm6
movapd %xmm1,%xmm4
movsd  0xcfb(%rip),%xmm13
mulsd  %xmm15,%xmm13
mulsd  %xmm15,%xmm13
subsd  %xmm1,%xmm13
mulsd  %xmm7,%xmm1
subsd  %xmm1,%xmm6
movsd  0xccc(%rip),%xmm5
mulsd  %xmm2,%xmm5
mulsd  %xmm3,%xmm5
mulsd  %xmm14,%xmm5
addsd  %xmm6,%xmm5
movapd %xmm15,%xmm6
mulsd  %xmm15,%xmm6
movapd %xmm6,%xmm12
mulsd  %xmm7,%xmm12
addsd  %xmm5,%xmm12
movsd  0xca2(%rip),%xmm1
movapd %xmm7,0x60(%rsp)
movapd %xmm7,%xmm5
mulsd  %xmm1,%xmm5
mulsd  %xmm15,%xmm5
mulsd  %xmm15,%xmm4
movapd %xmm2,%xmm7
shufpd $0x1,%xmm2,%xmm7
xorpd  0xc51(%rip),%xmm7
addsd  %xmm5,%xmm4
pshufd $0xee,%xmm7,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movaps %xmm7,0x50(%rsp)
mulsd  %xmm7,%xmm3
addsd  %xmm5,%xmm3
mulsd  %xmm15,%xmm6
subsd  %xmm6,%xmm3
mulsd  %xmm15,%xmm1
movapd %xmm13,%xmm10
addsd  %xmm13,%xmm10
movsd  0xc4a(%rip),%xmm11
mulsd  %xmm1,%xmm11
xorpd  %xmm4,%xmm4
movsd  0xc41(%rip),%xmm6
mov    $0x14,%eax
movapd 0xc03(%rip),%xmm9
lea    0xc5a(%rip),%rdi
movsd  0xc2b(%rip),%xmm8
lea    0xc2c(%rip),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm6,%xmm7
movapd %xmm4,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm13,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm3,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm12,%xmm6
movapd %xmm6,%xmm5
andpd  %xmm9,%xmm5
andpd  %xmm9,%xmm7
ucomisd %xmm7,%xmm5
ja     14eb <circlefit+0x3cb>
movapd %xmm4,%xmm5
mulsd  %xmm11,%xmm5
addsd  %xmm10,%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm3,%xmm5
movapd %xmm6,%xmm7
divsd  %xmm5,%xmm7
movapd %xmm4,%xmm5
subsd  %xmm7,%xmm5
xorpd  %xmm7,%xmm7
maxsd  %xmm5,%xmm7
movapd %xmm7,%xmm5
subsd  %xmm4,%xmm5
divsd  %xmm7,%xmm5
andpd  0xb68(%rip),%xmm5
ucomisd %xmm8,%xmm5
jbe    1528 <circlefit+0x408>
movapd %xmm7,%xmm4
add    $0xffffffff,%eax
jne    1440 <circlefit+0x320>
movapd %xmm15,0x10(%rsp)
movapd %xmm14,0x20(%rsp)
movapd %xmm0,0x30(%rsp)
movapd %xmm2,0x40(%rsp)
mov    %rcx,%rdi
jmp    1505 <circlefit+0x3e5>
movapd %xmm15,0x10(%rsp)
movapd %xmm14,0x20(%rsp)
movapd %xmm0,0x30(%rsp)
movapd %xmm2,0x40(%rsp)
call   1030 <puts@plt>
xorpd  %xmm7,%xmm7
movapd 0x40(%rsp),%xmm2
movapd 0x30(%rsp),%xmm0
movapd 0x20(%rsp),%xmm14
movapd 0x10(%rsp),%xmm15
movapd 0x60(%rsp),%xmm4
movapd 0x50(%rsp),%xmm5
movapd %xmm15,%xmm3
mulsd  %xmm7,%xmm3
movapd %xmm7,%xmm1
mulsd  %xmm7,%xmm1
subsd  %xmm3,%xmm1
addsd  %xmm1,%xmm4
addsd  %xmm4,%xmm4
unpcklpd %xmm7,%xmm7
subpd  %xmm7,%xmm0
unpcklpd %xmm14,%xmm14
mulpd  %xmm5,%xmm14
mulpd  %xmm0,%xmm2
addpd  %xmm14,%xmm2
unpcklpd %xmm4,%xmm4
divpd  %xmm4,%xmm2
movupd %xmm2,(%r12)
movapd %xmm2,%xmm0
mulpd  %xmm2,%xmm0
unpckhpd %xmm0,%xmm0
mulsd  %xmm2,%xmm2
addsd  %xmm0,%xmm2
addsd  %xmm15,%xmm2
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm2
jb     15a6 <circlefit+0x486>
xorps  %xmm0,%xmm0
sqrtsd %xmm2,%xmm0
jmp    15b3 <circlefit+0x493>
movapd %xmm2,%xmm0
call   1040 <sqrt@plt>
xorpd  %xmm3,%xmm3
movapd (%rsp),%xmm1
movsd  %xmm0,(%r15)
movupd (%r12),%xmm0
addpd  %xmm0,%xmm1
movupd %xmm1,(%r12)
movq   $0x0,(%r14)
test   %ebp,%ebp
jle    1650 <circlefit+0x530>
shl    $0x4,%r13
xor    %ebp,%ebp
xorpd  %xmm2,%xmm2
jmp    161d <circlefit+0x4fd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1040 <sqrt@plt>
xorpd  %xmm2,%xmm2
movapd %xmm0,%xmm3
subsd  (%r15),%xmm3
andpd  0xa16(%rip),%xmm3
addsd  (%r14),%xmm3
movsd  %xmm3,(%r14)
add    $0x10,%rbp
cmp    %rbp,%r13
je     1650 <circlefit+0x530>
movsd  (%rbx,%rbp,1),%xmm0
subsd  (%r12),%xmm0
movsd  0x8(%rbx,%rbp,1),%xmm1
subsd  0x8(%r12),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
ucomisd %xmm2,%xmm0
jb     15f0 <circlefit+0x4d0>
xorps  %xmm3,%xmm3
sqrtsd %xmm0,%xmm3
jmp    15fd <circlefit+0x4dd>
divsd  0x70(%rsp),%xmm3
movsd  %xmm3,(%r14)
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@str = [30 x i8] c"Newton-Taubin don't converge.\00"
@str.2 = [48 x i8] c"WARNING: Newton-Taubin goes in wrong direction.\00"
define void @circlefit([2 x double]* nocapture %0, i32 %1, double* nocapture %2, double* nocapture %3, double* nocapture %4) {
%6 = icmp sgt i32 %1, 0
br i1 %6, label %9, label %7
7: ; preds = %5
%8 = sitofp i32 %1 to double
br label %93
9: ; preds = %5
%10 = zext i32 %1 to i64
%11 = add nsw i64 %10, -1
%12 = and i64 %10, 3
%13 = icmp ult i64 %11, 3
br i1 %13, label %42, label %14
14: ; preds = %9
%15 = and i64 %10, 4294967292
br label %16
16: ; preds = %16, %14
%17 = phi i64 [ 0, %14 ], [ %39, %16 ]
%18 = phi <2 x double> [ undef, %14 ], [ %38, %16 ]
%19 = phi i64 [ 0, %14 ], [ %40, %16 ]
%20 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %17, i64 0
%21 = bitcast double* %20 to <2 x double>*
%22 = load <2 x double>, <2 x double>* %21
%23 = fadd <2 x double> %18, %22
%24 = or i64 %17, 1
%25 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %24, i64 0
%26 = bitcast double* %25 to <2 x double>*
%27 = load <2 x double>, <2 x double>* %26
%28 = fadd <2 x double> %23, %27
%29 = or i64 %17, 2
%30 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %29, i64 0
%31 = bitcast double* %30 to <2 x double>*
%32 = load <2 x double>, <2 x double>* %31
%33 = fadd <2 x double> %28, %32
%34 = or i64 %17, 3
%35 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %34, i64 0
%36 = bitcast double* %35 to <2 x double>*
%37 = load <2 x double>, <2 x double>* %36
%38 = fadd <2 x double> %33, %37
%39 = add nuw nsw i64 %17, 4
%40 = add i64 %19, 4
%41 = icmp eq i64 %40, %15
br i1 %41, label %42, label %16
42: ; preds = %16, %9
%43 = phi i64 [ 0, %9 ], [ %39, %16 ]
%44 = phi <2 x double> [ undef, %9 ], [ %38, %16 ]
%45 = icmp eq i64 %12, 0
br i1 %45, label %57, label %46
46: ; preds = %42, %46
%47 = phi i64 [ %54, %46 ], [ %43, %42 ]
%48 = phi <2 x double> [ %53, %46 ], [ %44, %42 ]
%49 = phi i64 [ %55, %46 ], [ 0, %42 ]
%50 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %47, i64 0
%51 = bitcast double* %50 to <2 x double>*
%52 = load <2 x double>, <2 x double>* %51
%53 = fadd <2 x double> %48, %52
%54 = add nuw nsw i64 %47, 1
%55 = add i64 %49, 1
%56 = icmp eq i64 %55, %12
br i1 %56, label %57, label %46
57: ; preds = %46, %42
%58 = phi <2 x double> [ %44, %42 ], [ %53, %46 ]
%59 = sitofp i32 %1 to double
%60 = insertelement <2 x double> poison, double %59, i64 0
%61 = shufflevector <2 x double> %60, <2 x double> poison, <2 x i32> zeroinitializer
%62 = fdiv <2 x double> %58, %61
br i1 %6, label %63, label %93
63: ; preds = %57
%64 = zext i32 %1 to i64
br label %65
65: ; preds = %63, %65
%66 = phi i64 [ 0, %63 ], [ %87, %65 ]
%67 = phi <2 x double> [ zeroinitializer, %63 ], [ %86, %65 ]
%68 = phi <2 x double> [ zeroinitializer, %63 ], [ %80, %65 ]
%69 = phi <2 x double> [ zeroinitializer, %63 ], [ %83, %65 ]
%70 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %66, i64 0
%71 = bitcast double* %70 to <2 x double>*
%72 = load <2 x double>, <2 x double>* %71
%73 = fsub <2 x double> %72, %62
%74 = extractelement <2 x double> %73, i64 1
%75 = fmul double %74, %74
%76 = extractelement <2 x double> %73, i64 0
%77 = tail call double @llvm.fmuladd.f64(double %76, double %76, double %75)
%78 = shufflevector <2 x double> %73, <2 x double> undef, <2 x i32> <i32 1, i32 undef>
%79 = shufflevector <2 x double> %78, <2 x double> %73, <2 x i32> <i32 0, i32 2>
%80 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %79, <2 x double> %79, <2 x double> %68)
%81 = insertelement <2 x double> %73, double %77, i64 1
%82 = insertelement <2 x double> %78, double %77, i64 1
%83 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %81, <2 x double> %82, <2 x double> %69)
%84 = insertelement <2 x double> poison, double %77, i64 0
%85 = shufflevector <2 x double> %84, <2 x double> poison, <2 x i32> zeroinitializer
%86 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %73, <2 x double> %85, <2 x double> %67)
%87 = add nuw nsw i64 %66, 1
%88 = icmp eq i64 %87, %64
br i1 %88, label %89, label %65
89: ; preds = %65
%90 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %73, <2 x double> %85, <2 x double> %67)
%91 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %81, <2 x double> %82, <2 x double> %69)
%92 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %79, <2 x double> %79, <2 x double> %68)
br label %93
93: ; preds = %89, %7, %57
%94 = phi double [ %59, %57 ], [ %8, %7 ], [ %59, %89 ]
%95 = phi <2 x double> [ %62, %57 ], [ <double 0x7FF8000000000000, double 0x7FF8000000000000>, %7 ], [ %62, %89 ]
%96 = phi <2 x double> [ zeroinitializer, %57 ], [ zeroinitializer, %7 ], [ %90, %89 ]
%97 = phi <2 x double> [ zeroinitializer, %57 ], [ zeroinitializer, %7 ], [ %92, %89 ]
%98 = phi <2 x double> [ zeroinitializer, %57 ], [ zeroinitializer, %7 ], [ %91, %89 ]
%99 = insertelement <2 x double> poison, double %94, i64 0
%100 = shufflevector <2 x double> %99, <2 x double> poison, <2 x i32> zeroinitializer
%101 = fdiv <2 x double> %97, %100
%102 = extractelement <2 x double> %98, i64 1
%103 = fdiv double %102, %94
%104 = extractelement <2 x double> %98, i64 0
%105 = fdiv double %104, %94
%106 = fdiv <2 x double> %96, %100
%107 = extractelement <2 x double> %101, i64 0
%108 = extractelement <2 x double> %101, i64 1
%109 = fadd double %107, %108
%110 = fneg double %105
%111 = fmul double %105, %110
%112 = tail call double @llvm.fmuladd.f64(double %108, double %107, double %111)
%113 = extractelement <2 x double> %106, i64 0
%114 = fmul <2 x double> %106, %106
%115 = extractelement <2 x double> %114, i64 0
%116 = extractelement <2 x double> %106, i64 1
%117 = fmul double %116, %116
%118 = fmul double %117, %108
%119 = tail call double @llvm.fmuladd.f64(double %115, double %107, double %118)
%120 = fneg double %103
%121 = tail call double @llvm.fmuladd.f64(double %120, double %112, double %119)
%122 = fmul double %113, -2.000000e+00
%123 = fmul double %116, %122
%124 = tail call double @llvm.fmuladd.f64(double %123, double %105, double %121)
%125 = fmul double %109, %109
%126 = tail call double @llvm.fmuladd.f64(double %125, double %112, double %124)
%127 = fmul double %112, 4.000000e+00
%128 = fmul double %109, %127
%129 = tail call double @llvm.fmuladd.f64(double %103, double %109, double %128)
%130 = shufflevector <2 x double> %106, <2 x double> undef, <2 x i32> <i32 1, i32 0>
%131 = fneg <2 x double> %130
%132 = extractelement <2 x double> %131, i64 1
%133 = tail call double @llvm.fmuladd.f64(double %132, double %113, double %129)
%134 = extractelement <2 x double> %131, i64 0
%135 = tail call double @llvm.fmuladd.f64(double %134, double %116, double %133)
%136 = fneg double %125
%137 = tail call double @llvm.fmuladd.f64(double %136, double %109, double %135)
%138 = fmul double %109, -3.000000e+00
%139 = tail call double @llvm.fmuladd.f64(double %138, double %109, double %120)
%140 = fmul double %109, 4.000000e+00
%141 = fmul double %139, 2.000000e+00
%142 = fmul double %140, 3.000000e+00
br label %143
143: ; preds = %164, %93
%144 = phi double [ 1.000000e+20, %93 ], [ %149, %164 ]
%145 = phi double [ 0.000000e+00, %93 ], [ %159, %164 ]
%146 = phi i32 [ 0, %93 ], [ %165, %164 ]
%147 = tail call double @llvm.fmuladd.f64(double %145, double %140, double %139)
%148 = tail call double @llvm.fmuladd.f64(double %145, double %147, double %137)
%149 = tail call double @llvm.fmuladd.f64(double %145, double %148, double %126)
%150 = tail call double @llvm.fabs.f64(double %149)
%151 = tail call double @llvm.fabs.f64(double %144)
%152 = fcmp ogt double %150, %151
br i1 %152, label %167, label %153
153: ; preds = %143
%154 = tail call double @llvm.fmuladd.f64(double %145, double %142, double %141)
%155 = tail call double @llvm.fmuladd.f64(double %145, double %154, double %137)
%156 = fdiv double %149, %155
%157 = fsub double %145, %156
%158 = fcmp olt double %157, 0.000000e+00
%159 = select i1 %158, double 0.000000e+00, double %157
%160 = fsub double %159, %145
%161 = fdiv double %160, %159
%162 = tail call double @llvm.fabs.f64(double %161)
%163 = fcmp ogt double %162, 0x3D719799812DEA11
br i1 %163, label %164, label %170
164: ; preds = %153
%165 = add nuw nsw i32 %146, 1
%166 = icmp eq i32 %165, 20
br i1 %166, label %167, label %143
167: ; preds = %164, %143
%168 = phi i8* [ getelementptr inbounds ([48 x i8], [48 x i8]* @str.2, i64 0, i64 0), %143 ], [ getelementptr inbounds ([30 x i8], [30 x i8]* @str, i64 0, i64 0), %164 ]
%169 = tail call i32 @puts(i8* dereferenceable(1) %168)
br label %170
170: ; preds = %153, %167
%171 = phi double [ 0.000000e+00, %167 ], [ %159, %153 ]
%172 = fneg double %171
%173 = fmul double %109, %172
%174 = tail call double @llvm.fmuladd.f64(double %171, double %171, double %173)
%175 = fadd double %112, %174
%176 = fmul double %175, 2.000000e+00
%177 = insertelement <2 x double> poison, double %171, i64 0
%178 = shufflevector <2 x double> %177, <2 x double> poison, <2 x i32> zeroinitializer
%179 = fsub <2 x double> %101, %178
%180 = insertelement <2 x double> poison, double %105, i64 0
%181 = shufflevector <2 x double> %180, <2 x double> poison, <2 x i32> zeroinitializer
%182 = fmul <2 x double> %181, %131
%183 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %106, <2 x double> %179, <2 x double> %182)
%184 = insertelement <2 x double> poison, double %176, i64 0
%185 = shufflevector <2 x double> %184, <2 x double> poison, <2 x i32> zeroinitializer
%186 = fdiv <2 x double> %183, %185
%187 = getelementptr inbounds double, double* %3, i64 1
%188 = bitcast double* %3 to <2 x double>*
store <2 x double> %186, <2 x double>* %188
%189 = fmul <2 x double> %186, %186
%190 = extractelement <2 x double> %189, i64 1
%191 = extractelement <2 x double> %186, i64 0
%192 = tail call double @llvm.fmuladd.f64(double %191, double %191, double %190)
%193 = fadd double %109, %192
%194 = tail call double @sqrt(double %193)
store double %194, double* %2
%195 = bitcast double* %3 to <2 x double>*
%196 = load <2 x double>, <2 x double>* %195
%197 = fadd <2 x double> %95, %196
%198 = bitcast double* %3 to <2 x double>*
store <2 x double> %197, <2 x double>* %198
store double 0.000000e+00, double* %4
br i1 %6, label %199, label %221
199: ; preds = %170
%200 = zext i32 %1 to i64
br label %201
201: ; preds = %199, %201
%202 = phi i64 [ 0, %199 ], [ %219, %201 ]
%203 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %202, i64 0
%204 = load double, double* %203
%205 = load double, double* %3
%206 = fsub double %204, %205
%207 = getelementptr inbounds [2 x double], [2 x double]* %0, i64 %202, i64 1
%208 = load double, double* %207
%209 = load double, double* %187
%210 = fsub double %208, %209
%211 = fmul double %210, %210
%212 = tail call double @llvm.fmuladd.f64(double %206, double %206, double %211)
%213 = tail call double @sqrt(double %212)
%214 = load double, double* %2
%215 = fsub double %213, %214
%216 = tail call double @llvm.fabs.f64(double %215)
%217 = load double, double* %4
%218 = fadd double %217, %216
store double %218, double* %4
%219 = add nuw nsw i64 %202, 1
%220 = icmp eq i64 %219, %200
br i1 %220, label %221, label %201
221: ; preds = %201, %170
%222 = phi double [ 0.000000e+00, %170 ], [ %218, %201 ]
%223 = fdiv double %222, %94
store double %223, double* %4
ret void
}