double intersection_area_circle_triangle(double radius, const double tri_org[2],
                                         const double tri_u[2],
                                         const double tri_v[2]) {
  const double origin[2] = {0, 0};
  int i, j;
  const double iradius = 1. / radius;
  const double iradius2 = 1. / (radius * radius);
  int inside = 0;
  double vert[6];
  vert[2 * 0 + 0] = tri_org[0];
  vert[2 * 0 + 1] = tri_org[1];
  vert[2 * 1 + 0] = (tri_org[0] + tri_u[0]);
  vert[2 * 1 + 1] = (tri_org[1] + tri_u[1]);
  vert[2 * 2 + 0] = (tri_org[0] + tri_v[0]);
  vert[2 * 2 + 1] = (tri_org[1] + tri_v[1]);
  double vert_org[6];
  vert_org[2 * 0 + 0] = 0;
  vert_org[2 * 0 + 1] = 0;
  vert_org[2 * 1 + 0] = tri_u[0];
  vert_org[2 * 1 + 1] = tri_u[1];
  vert_org[2 * 2 + 0] = tri_v[0];
  vert_org[2 * 2 + 1] = tri_v[1];
  double tri_r[3];
  for (i = 0; i < 3; ++i) {
    tri_r[i] = pythag2(vert[2 * i + 0], vert[2 * i + 1]) * iradius;
    if (tri_r[i] <= 1.0) {
      inside |= (1 << i);
    }
  }
  if (TriangleContainsPoint(tri_org, tri_u, tri_v, origin)) {
    inside |= (1 << 3);
  }
  if ((inside & 0x7) == 0x7) {
    return 0.5 * fabs(LeftTurn(origin, tri_u, tri_v));
  }
  double seg[6];
  seg[2 * 0 + 0] = tri_u[0];
  seg[2 * 0 + 1] = tri_u[1];
  seg[2 * 1 + 0] = (tri_v[0] - tri_u[0]);
  seg[2 * 1 + 1] = (tri_v[1] - tri_u[1]);
  seg[2 * 2 + 0] = -tri_v[0];
  seg[2 * 2 + 1] = -tri_v[1];
  double side_length[3];
  for (i = 0; i < 3; ++i) {
    side_length[i] = pythag2(seg[2 * i + 0], seg[2 * i + 1]) * iradius;
  }
  double seg_dot[3];
  for (i = 0; i < 3; ++i) {
    seg_dot[i] =
        (vert[2 * i + 0] * seg[2 * i + 0] + vert[2 * i + 1] * seg[2 * i + 1]) *
        iradius2;
  }
  double xp[12];
  int nxp[3];
  int nx = 0;
  for (i = 0; i < 3; ++i) {
    int ip1 = (i + 1) % 3;
    int in0 = (inside & (1 << i)) ? 1 : 0;
    int in1 = (inside & (1 << ip1)) ? 1 : 0;
    if (in0 && in1) {
      nxp[i] = 0;
    } else {
      double isl2 = 1. / (side_length[i] * side_length[i]);
      double disc =
          (seg_dot[i] * seg_dot[i] * isl2 - (tri_r[i] * tri_r[i] - 1)) * isl2;
      double t0 = -seg_dot[i] * isl2;
      double t, t2, tdist, t2dist;
      if (in0 != in1) {
        nxp[i] = 1;
        nx += 1;
        if (disc < 0) {
          disc = 0;
        }
        disc = sqrt(disc);
        t = t0 + disc;
        t2 = t0 - disc;
        if (t > 0.5) {
          tdist = fabs(t - 1.);
        } else {
          tdist = fabs(t);
        }
        if (t2 > 0.5) {
          t2dist = fabs(t2 - 1.);
        } else {
          t2dist = fabs(t2);
        }
        if (t2dist < tdist) {
          t = t2;
        }
        if (t < 0) {
          t = 0;
        }
        if (t > 1) {
          t = 1;
        }
        xp[2 * 2 * i + 0] = vert_org[2 * i + 0] + t * seg[2 * i + 0];
        xp[2 * 2 * i + 1] = vert_org[2 * i + 1] + t * seg[2 * i + 1];
      } else {
        if (disc <= 0) {
          nxp[i] = 0;
        } else {
          disc = sqrt(disc);
          nxp[i] = 0;
          t = t0 - disc;
          t2 = t0 + disc;
          if (0 < t && t < 1 && 0 < t2 && t2 < 1) {
            xp[2 * (2 * i + 0) + 0] = vert_org[2 * i + 0] + t * seg[2 * i + 0];
            xp[2 * (2 * i + 0) + 1] = vert_org[2 * i + 1] + t * seg[2 * i + 1];
            xp[2 * (2 * i + 1) + 0] = vert_org[2 * i + 0] + t * seg[2 * i + 0];
            xp[2 * (2 * i + 1) + 1] = vert_org[2 * i + 1] + t * seg[2 * i + 1];
            nxp[i] += 2;
            nx += 2;
          }
        }
      }
    }
  }
  if (0 == nx) {
    if ((inside & 0x7) == 0x7) {
      return -1;
    } else {
      if (inside & 0x8) {
        return 3.14159265358979323846 * radius * radius;
      } else {
        return 0;
      }
    }
  } else if (2 == nx) {
    if (nxp[0] < 2 && nxp[1] < 2 && nxp[2] < 2) {
    } else {
      for (i = 0; i < 3; ++i) {
        if (nxp[i] > 1) {
          break;
        }
      }
      double sector_area = CircularSectorArea(
          radius, pythag2(xp[2 * (2 * i + 1) + 0] - xp[2 * 2 * i + 0],
                          xp[2 * (2 * i + 1) + 1] - xp[2 * 2 * i + 1]));
      if (inside & (1 << 3)) {
        return 3.14159265358979323846 * radius * radius - sector_area;
      } else {
        return sector_area;
      }
    }
  } else if (4 == nx) {
  } else if (6 == nx) {
  } else {
    return -1;
  }
  int vtype[6];
  double vp[12];
  int nv = 0;
  for (i = 0; i < 3; ++i) {
    if (inside & (1 << i)) {
      vp[2 * nv + 0] = vert_org[2 * i + 0];
      vp[2 * nv + 1] = vert_org[2 * i + 1];
      vtype[nv++] = 1;
    }
    for (j = 0; j < nxp[i]; ++j) {
      vp[2 * nv + 0] = xp[2 * (2 * i + j) + 0];
      vp[2 * nv + 1] = xp[2 * (2 * i + j) + 1];
      vtype[nv++] = 0;
    }
  }
  if (nv < 3) {
    return -1;
  }
  double area = polygon_area(nv, vp);
  for (i = 0; i < nv; ++i) {
    int im1 = i - 1;
    if (im1 < 0) {
      im1 = nv - 1;
    }
    if ((0 == vtype[im1]) && (0 == vtype[i])) {
      area +=
          CircularSectorArea(radius, pythag2(vp[2 * i + 0] - vp[2 * im1 + 0],
                                             vp[2 * i + 1] - vp[2 * im1 + 1]));
    }
  }
  return area;
}


x86 assembly (clang, -O0):
<intersection_area_circle_triangle>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2c0,%rsp
movsd  %xmm0,-0x10(%rbp)
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
lea    -0x40(%rbp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1050 <memset@plt>
movsd  0x1e5c(%rip),%xmm0
divsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x10(%rbp),%xmm1
mulsd  -0x10(%rbp),%xmm1
movsd  0x1e40(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x28(%rbp),%rax
addsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
addsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1335 <intersection_area_circle_triangle+0x1c5>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
mov    $0x2,%al
call   1040 <pythag2@plt>
cvtsi2sd %eax,%xmm0
mulsd  -0x50(%rbp),%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0xe0(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
movsd  0x1cfd(%rip),%xmm0
ucomisd -0xe0(%rbp,%rax,8),%xmm0
ff ff
jb     1322 <intersection_area_circle_triangle+0x1b2>
mov    -0x44(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
or     -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1327 <intersection_area_circle_triangle+0x1b7>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12a8 <intersection_area_circle_triangle+0x138>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
lea    -0x40(%rbp),%rcx
mov    $0x0,%al
call   1030 <TriangleContainsPoint@plt>
cmp    $0x0,%eax
je     135e <intersection_area_circle_triangle+0x1ee>
mov    -0x5c(%rbp),%eax
or     $0x8,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
and    $0x7,%eax
cmp    $0x7,%eax
jne    13a5 <intersection_area_circle_triangle+0x235>
lea    -0x40(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    $0x0,%al
call   1060 <LeftTurn@plt>
cvtsi2sd %eax,%xmm1
movaps 0x1c95(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1c81(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    14ab <intersection_area_circle_triangle+0x33b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
mov    $0x2,%al
call   1040 <pythag2@plt>
cvtsi2sd %eax,%xmm0
mulsd  -0x50(%rbp),%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x130(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    144e <intersection_area_circle_triangle+0x2de>
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1534 <intersection_area_circle_triangle+0x3c4>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x90(%rbp,%rax,8),%xmm1
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
mulsd  -0x110(%rbp,%rax,8),%xmm1
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x58(%rbp),%xmm0
movslq -0x44(%rbp),%rax
movsd  %xmm0,-0x150(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    14b2 <intersection_area_circle_triangle+0x342>
movl   $0x0,-0x1c0(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1b72 <intersection_area_circle_triangle+0xa02>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %edx,-0x1c4(%rbp)
mov    -0x5c(%rbp),%edx
mov    -0x44(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
and    %eax,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x1c8(%rbp)
mov    -0x5c(%rbp),%edx
mov    -0x1c4(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
and    %eax,%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x1cc(%rbp)
cmpl   $0x0,-0x1c8(%rbp)
je     15d8 <intersection_area_circle_triangle+0x468>
cmpl   $0x0,-0x1cc(%rbp)
je     15d8 <intersection_area_circle_triangle+0x468>
movslq -0x44(%rbp),%rax
movl   $0x0,-0x1bc(%rbp,%rax,4)
jmp    1b5f <intersection_area_circle_triangle+0x9ef>
movslq -0x44(%rbp),%rax
movsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movslq -0x44(%rbp),%rax
mulsd  -0x130(%rbp,%rax,8),%xmm1
ff ff
movsd  0x1a06(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movslq -0x44(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movslq -0x44(%rbp),%rax
mulsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movsd  -0x1d8(%rbp),%xmm2
ff
movslq -0x44(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm1
ff ff
movslq -0x44(%rbp),%rax
movsd  -0xe0(%rbp,%rax,8),%xmm3
ff ff
mulsd  %xmm3,%xmm1
movsd  0x19ba(%rip),%xmm3
addsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x1d8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movslq -0x44(%rbp),%rax
movsd  -0x150(%rbp,%rax,8),%xmm0
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x1d8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e8(%rbp)
ff
mov    -0x1c8(%rbp),%eax
cmp    -0x1cc(%rbp),%eax
je     1915 <intersection_area_circle_triangle+0x7a5>
movslq -0x44(%rbp),%rax
movl   $0x1,-0x1bc(%rbp,%rax,4)
mov    -0x1c0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c0(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x1e0(%rbp),%xmm0
ff
jbe    1701 <intersection_area_circle_triangle+0x591>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
movsd  -0x1e0(%rbp),%xmm0
ff
call   1090 <sqrt@plt>
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
addsd  -0x1e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
subsd  -0x1e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  0x18c2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    178c <intersection_area_circle_triangle+0x61c>
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  0x1890(%rip),%xmm1
subsd  %xmm1,%xmm0
movaps 0x18a5(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
jmp    17a7 <intersection_area_circle_triangle+0x637>
movsd  -0x1f0(%rbp),%xmm0
ff
movaps 0x1885(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  0x1861(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    17ed <intersection_area_circle_triangle+0x67d>
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  0x182f(%rip),%xmm1
subsd  %xmm1,%xmm0
movaps 0x1844(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
jmp    1808 <intersection_area_circle_triangle+0x698>
movsd  -0x1f8(%rbp),%xmm0
ff
movaps 0x1824(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
movsd  -0x208(%rbp),%xmm1
ff
movsd  -0x200(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1832 <intersection_area_circle_triangle+0x6c2>
movsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x1f0(%rbp),%xmm0
ff
jbe    184e <intersection_area_circle_triangle+0x6de>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
movsd  0x17a2(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1878 <intersection_area_circle_triangle+0x708>
movsd  0x1790(%rip),%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
add    $0x0,%eax
cltq
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
jmp    1b5a <intersection_area_circle_triangle+0x9ea>
xorps  %xmm0,%xmm0
ucomisd -0x1e0(%rbp),%xmm0
ff
jb     193a <intersection_area_circle_triangle+0x7ca>
movslq -0x44(%rbp),%rax
movl   $0x0,-0x1bc(%rbp,%rax,4)
jmp    1b55 <intersection_area_circle_triangle+0x9e5>
movsd  -0x1e0(%rbp),%xmm0
ff
call   1090 <sqrt@plt>
movsd  %xmm0,-0x1e0(%rbp)
ff
movslq -0x44(%rbp),%rax
movl   $0x0,-0x1bc(%rbp,%rax,4)
movsd  -0x1e8(%rbp),%xmm0
ff
subsd  -0x1e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
addsd  -0x1e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b50 <intersection_area_circle_triangle+0x9e0>
movsd  0x1655(%rip),%xmm0
ucomisd -0x1f0(%rbp),%xmm0
ff
jbe    1b50 <intersection_area_circle_triangle+0x9e0>
movsd  -0x1f8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1b50 <intersection_area_circle_triangle+0x9e0>
movsd  0x162a(%rip),%xmm0
ucomisd -0x1f8(%rbp),%xmm0
ff
jbe    1b50 <intersection_area_circle_triangle+0x9e0>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm1
ff ff
movsd  -0x1f0(%rbp),%xmm0
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x110(%rbp,%rax,8),%xmm2
ff ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x1b0(%rbp,%rax,8)
ff ff
movslq -0x44(%rbp),%rax
mov    -0x1bc(%rbp,%rax,4),%ecx
add    $0x2,%ecx
mov    %ecx,-0x1bc(%rbp,%rax,4)
mov    -0x1c0(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c0(%rbp)
jmp    1b55 <intersection_area_circle_triangle+0x9e5>
jmp    1b5a <intersection_area_circle_triangle+0x9ea>
jmp    1b5f <intersection_area_circle_triangle+0x9ef>
jmp    1b64 <intersection_area_circle_triangle+0x9f4>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1545 <intersection_area_circle_triangle+0x3d5>
xor    %eax,%eax
cmp    -0x1c0(%rbp),%eax
jne    1bd9 <intersection_area_circle_triangle+0xa69>
mov    -0x5c(%rbp),%eax
and    $0x7,%eax
cmp    $0x7,%eax
jne    1ba1 <intersection_area_circle_triangle+0xa31>
movsd  0x1471(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
mov    -0x5c(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1bcc <intersection_area_circle_triangle+0xa5c>
movsd  0x1458(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
mov    $0x2,%eax
cmp    -0x1c0(%rbp),%eax
jne    1d47 <intersection_area_circle_triangle+0xbd7>
cmpl   $0x2,-0x1bc(%rbp)
jge    1c16 <intersection_area_circle_triangle+0xaa6>
cmpl   $0x2,-0x1b8(%rbp)
jge    1c16 <intersection_area_circle_triangle+0xaa6>
cmpl   $0x2,-0x1b4(%rbp)
jge    1c16 <intersection_area_circle_triangle+0xaa6>
jmp    1d42 <intersection_area_circle_triangle+0xbd2>
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1c51 <intersection_area_circle_triangle+0xae1>
movslq -0x44(%rbp),%rax
cmpl   $0x1,-0x1bc(%rbp,%rax,4)
01
jle    1c3e <intersection_area_circle_triangle+0xace>
jmp    1c51 <intersection_area_circle_triangle+0xae1>
jmp    1c43 <intersection_area_circle_triangle+0xad3>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1c1d <intersection_area_circle_triangle+0xaad>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x2b0(%rbp)
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x1b0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
add    $0x0,%eax
cltq
subsd  -0x1b0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x1b0(%rbp,%rax,8),%xmm1
ff ff
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
add    $0x1,%eax
cltq
subsd  -0x1b0(%rbp,%rax,8),%xmm1
ff ff
mov    $0x2,%al
call   1040 <pythag2@plt>
movsd  -0x2b0(%rbp),%xmm0
ff
mov    %eax,%edi
mov    $0x1,%al
call   1070 <CircularSectorArea@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
mov    -0x5c(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1d30 <intersection_area_circle_triangle+0xbc0>
movsd  0x131b(%rip),%xmm0
mulsd  -0x10(%rbp),%xmm0
movsd  -0x10(%rbp),%xmm2
movsd  -0x210(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
movsd  -0x210(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
jmp    1d8f <intersection_area_circle_triangle+0xc1f>
mov    $0x4,%eax
cmp    -0x1c0(%rbp),%eax
jne    1d5d <intersection_area_circle_triangle+0xbed>
jmp    1d8a <intersection_area_circle_triangle+0xc1a>
mov    $0x6,%eax
cmp    -0x1c0(%rbp),%eax
jne    1d73 <intersection_area_circle_triangle+0xc03>
jmp    1d85 <intersection_area_circle_triangle+0xc15>
movsd  0x128d(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
jmp    1d8a <intersection_area_circle_triangle+0xc1a>
jmp    1d8f <intersection_area_circle_triangle+0xc1f>
jmp    1d94 <intersection_area_circle_triangle+0xc24>
movl   $0x0,-0x294(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x3,-0x44(%rbp)
jge    1ef9 <intersection_area_circle_triangle+0xd89>
mov    -0x5c(%rbp),%eax
mov    -0x44(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1e3d <intersection_area_circle_triangle+0xccd>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x294(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0xc0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x294(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
mov    -0x294(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x294(%rbp)
cltq
movl   $0x1,-0x230(%rbp,%rax,4)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
movslq -0x44(%rbp),%rcx
cmp    -0x1bc(%rbp,%rcx,4),%eax
jge    1ee6 <intersection_area_circle_triangle+0xd76>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    -0x48(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x1b0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x294(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    -0x48(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x1b0(%rbp,%rax,8),%xmm0
ff ff
mov    -0x294(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  %xmm0,-0x290(%rbp,%rax,8)
ff ff
mov    -0x294(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x294(%rbp)
cltq
movl   $0x0,-0x230(%rbp,%rax,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1e44 <intersection_area_circle_triangle+0xcd4>
jmp    1eeb <intersection_area_circle_triangle+0xd7b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1da5 <intersection_area_circle_triangle+0xc35>
cmpl   $0x3,-0x294(%rbp)
jge    1f18 <intersection_area_circle_triangle+0xda8>
movsd  0x10fa(%rip),%xmm0
movsd  %xmm0,-0x8(%rbp)
jmp    204e <intersection_area_circle_triangle+0xede>
mov    -0x294(%rbp),%edi
lea    -0x290(%rbp),%rsi
mov    $0x0,%al
call   1080 <polygon_area@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x2a0(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x294(%rbp),%eax
jge    2041 <intersection_area_circle_triangle+0xed1>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2a4(%rbp)
cmpl   $0x0,-0x2a4(%rbp)
jge    1f76 <intersection_area_circle_triangle+0xe06>
mov    -0x294(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2a4(%rbp)
movslq -0x2a4(%rbp),%rcx
xor    %eax,%eax
cmp    -0x230(%rbp,%rcx,4),%eax
jne    202e <intersection_area_circle_triangle+0xebe>
movslq -0x44(%rbp),%rcx
xor    %eax,%eax
cmp    -0x230(%rbp,%rcx,4),%eax
jne    202e <intersection_area_circle_triangle+0xebe>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x2b8(%rbp)
ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
movsd  -0x290(%rbp,%rax,8),%xmm0
ff ff
mov    -0x2a4(%rbp),%eax
shl    $0x1,%eax
add    $0x0,%eax
cltq
subsd  -0x290(%rbp,%rax,8),%xmm0
ff ff
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
movsd  -0x290(%rbp,%rax,8),%xmm1
ff ff
mov    -0x2a4(%rbp),%eax
shl    $0x1,%eax
add    $0x1,%eax
cltq
subsd  -0x290(%rbp,%rax,8),%xmm1
mov    $0x2,%al
call   1040 <pythag2@plt>
movsd  -0x2b8(%rbp),%xmm0
ff
mov    %eax,%edi
mov    $0x1,%al
call   1070 <CircularSectorArea@plt>
cvtsi2sd %eax,%xmm0
addsd  -0x2a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x2a0(%rbp)
ff
jmp    2033 <intersection_area_circle_triangle+0xec3>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1f3f <intersection_area_circle_triangle+0xdcf>
movsd  -0x2a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x8(%rbp)
movsd  -0x8(%rbp),%xmm0
add    $0x2c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<intersection_area_circle_triangle>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2a8,%rsp
mov    %rdx,(%rsp)
mov    %rsi,%r15
mov    %rdi,%r12
xorps  %xmm3,%xmm3
movaps %xmm3,0xa0(%rsp)
movsd  0xe62(%rip),%xmm1
movsd  %xmm0,0x38(%rsp)
divsd  %xmm0,%xmm1
movapd %xmm1,0x20(%rsp)
movsd  (%rdi),%xmm0
movsd  0x8(%rdi),%xmm1
movupd (%rsi),%xmm4
movapd %xmm0,%xmm2
addsd  %xmm4,%xmm2
movapd %xmm2,0x90(%rsp)
movupd (%rdx),%xmm2
movaps %xmm3,0x240(%rsp)
movapd %xmm4,0x250(%rsp)
unpckhpd %xmm4,%xmm4
addsd  %xmm1,%xmm4
movapd %xmm4,0x70(%rsp)
movapd %xmm0,%xmm3
addsd  %xmm2,%xmm3
movapd %xmm3,0x10(%rsp)
movapd %xmm2,0x260(%rsp)
unpckhpd %xmm2,%xmm2
addsd  %xmm1,%xmm2
movapd %xmm2,0x80(%rsp)
movapd %xmm0,0x190(%rsp)
movapd %xmm1,0x180(%rsp)
mov    $0x2,%al
call   1040 <pythag2@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x130(%rsp)
xor    %ebx,%ebx
movsd  0xdb0(%rip),%xmm1
ucomisd %xmm0,%xmm1
setae  %bl
movaps 0x90(%rsp),%xmm0
movaps 0x70(%rsp),%xmm1
mov    $0x2,%al
call   1040 <pythag2@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x20(%rsp),%xmm0
xor    %eax,%eax
movsd  0xd7e(%rip),%xmm1
ucomisd %xmm0,%xmm1
setae  %al
movsd  %xmm0,0x138(%rsp)
lea    (%rbx,%rax,2),%ebx
movaps 0x10(%rsp),%xmm0
movaps 0x80(%rsp),%xmm1
mov    $0x2,%al
call   1040 <pythag2@plt>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x20(%rsp),%xmm0
xor    %ebp,%ebp
movsd  0xd40(%rip),%xmm1
ucomisd %xmm0,%xmm1
setae  %bpl
movsd  %xmm0,0x140(%rsp)
lea    (%rbx,%rbp,4),%r14d
xor    %r13d,%r13d
lea    0xa0(%rsp),%rcx
mov    %r12,%rdi
mov    %r15,%rsi
mov    (%rsp),%rdx
xor    %eax,%eax
call   1030 <TriangleContainsPoint@plt>
test   %eax,%eax
lea    0x8(%rbx,%rbp,4),%ecx
cmove  %r14d,%ecx
mov    %ecx,%r12d
not    %r12d
test   $0x7,%r12b
jne    1347 <intersection_area_circle_triangle+0x1d7>
lea    0xa0(%rsp),%rdi
mov    %r15,%rsi
mov    (%rsp),%rdx
xor    %eax,%eax
call   1060 <LeftTurn@plt>
cvtsi2sd %eax,%xmm5
andpd  0xd07(%rip),%xmm5
mulsd  0xcdf(%rip),%xmm5
movapd %xmm5,%xmm0
add    $0x2a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsd  0x38(%rsp),%xmm0
mulsd  %xmm0,%xmm0
movsd  0xca7(%rip),%xmm1
divsd  %xmm0,%xmm1
movapd %xmm1,0x170(%rsp)
movupd (%r15),%xmm0
movapd %xmm0,0x160(%rsp)
movapd %xmm0,0x270(%rsp)
mov    (%rsp),%rax
movupd (%rax),%xmm2
movapd %xmm2,%xmm1
subpd  %xmm0,%xmm1
movapd %xmm1,0x50(%rsp)
movapd %xmm1,0x280(%rsp)
xorpd  0xc7c(%rip),%xmm2
movapd %xmm2,0x60(%rsp)
movapd %xmm2,0x290(%rsp)
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
mov    $0x2,%al
mov    %ecx,(%rsp)
call   1040 <pythag2@plt>
mov    %eax,%r14d
movaps 0x50(%rsp),%xmm0
movaps %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
mov    $0x2,%al
call   1040 <pythag2@plt>
movd   %r14d,%xmm0
movd   %eax,%xmm1
punpckldq %xmm1,%xmm0
cvtdq2pd %xmm0,%xmm0
movapd 0x20(%rsp),%xmm1
unpcklpd %xmm1,%xmm1
mulpd  %xmm0,%xmm1
movapd %xmm1,0x220(%rsp)
movdqa 0x60(%rsp),%xmm0
pshufd $0xee,%xmm0,%xmm1
movdqa %xmm1,0x150(%rsp)
mov    $0x2,%al
call   1040 <pythag2@plt>
mov    (%rsp),%r9d
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0x20(%rsp),%xmm0
movsd  %xmm0,0x230(%rsp)
movapd 0x180(%rsp),%xmm1
unpcklpd 0x70(%rsp),%xmm1
movapd 0x160(%rsp),%xmm2
movapd %xmm2,%xmm0
movapd 0x50(%rsp),%xmm3
unpckhpd %xmm3,%xmm0
mulpd  %xmm1,%xmm0
movapd 0x190(%rsp),%xmm1
unpcklpd 0x90(%rsp),%xmm1
unpcklpd %xmm3,%xmm2
mulpd  %xmm1,%xmm2
addpd  %xmm0,%xmm2
movapd %xmm2,%xmm1
movapd 0x170(%rsp),%xmm2
movapd %xmm2,%xmm0
unpcklpd %xmm2,%xmm0
mulpd  %xmm1,%xmm0
movapd %xmm0,0x200(%rsp)
movapd 0x80(%rsp),%xmm1
mulsd  0x150(%rsp),%xmm1
movapd 0x10(%rsp),%xmm0
mulsd  0x60(%rsp),%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x210(%rsp)
mov    $0x1,%ebp
mov    $0xaaaaaaab,%r15d
movsd  0xb24(%rip),%xmm5
movapd 0xb33(%rip),%xmm8
xorpd  %xmm9,%xmm9
xor    %ebx,%ebx
xor    %r14d,%r14d
jmp    151d <intersection_area_circle_triangle+0x3ad>
nopl   0x0(%rax)
movl   $0x0,0x44(%rsp,%rbx,1)
add    $0x4,%rbx
add    $0x1,%r13d
add    $0x1,%ebp
cmp    $0xc,%rbx
je     1784 <intersection_area_circle_triangle+0x614>
mov    %ebp,%eax
imul   %r15,%rax
shr    $0x21,%rax
lea    (%rax,%rax,2),%ecx
mov    %r13d,%eax
sub    %ecx,%eax
mov    $0x1,%edx
mov    %r13d,%ecx
shl    %cl,%edx
add    $0x1,%al
mov    $0x1,%esi
mov    %eax,%ecx
shl    %cl,%esi
mov    %esi,%eax
bts    %r13d,%eax
test   %r12d,%eax
je     1500 <intersection_area_circle_triangle+0x390>
test   %r9d,%esi
setne  %al
test   %r9d,%edx
sete   %cl
movsd  0x220(%rsp,%rbx,2),%xmm0
mulsd  %xmm0,%xmm0
movsd  0xa90(%rip),%xmm4
movapd %xmm4,%xmm1
divsd  %xmm0,%xmm1
movsd  0x200(%rsp,%rbx,2),%xmm7
movapd %xmm7,%xmm0
mulsd  %xmm7,%xmm0
movsd  0x130(%rsp,%rbx,2),%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm5,%xmm2
mulsd  %xmm1,%xmm0
subsd  %xmm2,%xmm0
mulsd  %xmm1,%xmm0
xorpd  %xmm8,%xmm7
mulsd  %xmm1,%xmm7
xor    %al,%cl
je     15e0 <intersection_area_circle_triangle+0x470>
ucomisd %xmm0,%xmm9
jae    1500 <intersection_area_circle_triangle+0x390>
ucomisd %xmm9,%xmm0
jb     16da <intersection_area_circle_triangle+0x56a>
sqrtsd %xmm0,%xmm0
jmp    170d <intersection_area_circle_triangle+0x59d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x1,0x44(%rsp,%rbx,1)
xorpd  %xmm1,%xmm1
maxsd  %xmm0,%xmm1
ucomisd %xmm9,%xmm1
jb     1600 <intersection_area_circle_triangle+0x490>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    1637 <intersection_area_circle_triangle+0x4c7>
movapd %xmm1,%xmm0
movapd %xmm7,0x20(%rsp)
call   1090 <sqrt@plt>
movapd 0x20(%rsp),%xmm7
xorpd  %xmm9,%xmm9
movapd 0x9fd(%rip),%xmm8
movsd  0x9dd(%rip),%xmm5
movsd  0x9cd(%rip),%xmm4
mov    (%rsp),%r9d
movapd %xmm7,%xmm1
addsd  %xmm0,%xmm1
subsd  %xmm0,%xmm7
movapd %xmm1,%xmm0
addsd  %xmm5,%xmm0
movsd  0x9bd(%rip),%xmm3
movapd %xmm3,%xmm2
cmpltsd %xmm1,%xmm2
andpd  %xmm2,%xmm0
andnpd %xmm1,%xmm2
orpd   %xmm0,%xmm2
movapd 0x9c0(%rip),%xmm6
andpd  %xmm6,%xmm2
movapd %xmm7,%xmm0
addsd  %xmm5,%xmm0
cmpltsd %xmm7,%xmm3
andpd  %xmm3,%xmm0
andnpd %xmm7,%xmm3
orpd   %xmm0,%xmm3
andpd  %xmm6,%xmm3
cmpltsd %xmm2,%xmm3
andpd  %xmm3,%xmm7
andnpd %xmm1,%xmm3
orpd   %xmm7,%xmm3
xorpd  %xmm0,%xmm0
maxsd  %xmm3,%xmm0
movapd %xmm4,%xmm1
minsd  %xmm0,%xmm1
unpcklpd %xmm1,%xmm1
mulpd  0x270(%rsp,%rbx,4),%xmm1
add    $0x1,%r14d
addpd  0x240(%rsp,%rbx,4),%xmm1
movapd %xmm1,0x1a0(%rsp,%rbx,8)
jmp    1508 <intersection_area_circle_triangle+0x398>
movapd %xmm7,0x20(%rsp)
call   1090 <sqrt@plt>
movapd 0x20(%rsp),%xmm7
xorpd  %xmm9,%xmm9
movapd 0x927(%rip),%xmm8
movsd  0x907(%rip),%xmm5
movsd  0x8f7(%rip),%xmm4
mov    (%rsp),%r9d
movl   $0x0,0x44(%rsp,%rbx,1)
movapd %xmm7,%xmm1
subsd  %xmm0,%xmm1
ucomisd %xmm9,%xmm1
jbe    1508 <intersection_area_circle_triangle+0x398>
ucomisd %xmm1,%xmm4
jbe    1508 <intersection_area_circle_triangle+0x398>
addsd  %xmm0,%xmm7
ucomisd %xmm9,%xmm7
jbe    1508 <intersection_area_circle_triangle+0x398>
ucomisd %xmm7,%xmm4
jbe    1508 <intersection_area_circle_triangle+0x398>
unpcklpd %xmm1,%xmm1
mulpd  0x270(%rsp,%rbx,4),%xmm1
addpd  0x240(%rsp,%rbx,4),%xmm1
movapd %xmm1,0x1a0(%rsp,%rbx,8)
movapd %xmm1,0x1b0(%rsp,%rbx,8)
movl   $0x2,0x44(%rsp,%rbx,1)
add    $0x2,%r14d
jmp    1508 <intersection_area_circle_triangle+0x398>
cmp    $0x2,%r14d
je     17bc <intersection_area_circle_triangle+0x64c>
test   %r14d,%r14d
jne    1878 <intersection_area_circle_triangle+0x708>
xorpd  %xmm5,%xmm5
test   $0x8,%r9b
movsd  0x38(%rsp),%xmm0
je     1331 <intersection_area_circle_triangle+0x1c1>
movsd  0x869(%rip),%xmm5
mulsd  %xmm0,%xmm5
mulsd  %xmm0,%xmm5
jmp    1331 <intersection_area_circle_triangle+0x1c1>
mov    0x44(%rsp),%esi
mov    0x48(%rsp),%edx
mov    0x4c(%rsp),%ecx
cmp    $0x1,%esi
jg     17db <intersection_area_circle_triangle+0x66b>
cmp    $0x1,%edx
jg     17db <intersection_area_circle_triangle+0x66b>
cmp    $0x2,%ecx
jl     1886 <intersection_area_circle_triangle+0x716>
xor    %eax,%eax
cmp    $0x1,%esi
jg     17fb <intersection_area_circle_triangle+0x68b>
mov    $0x4,%eax
cmp    $0x1,%edx
jg     17fb <intersection_area_circle_triangle+0x68b>
xor    %eax,%eax
cmp    $0x2,%ecx
setl   %al
lea    0x8(,%rax,4),%eax
mov    %eax,%ecx
or     $0x2,%ecx
movsd  0x1a0(%rsp,%rcx,8),%xmm0
mov    %eax,%ecx
subsd  0x1a0(%rsp,%rcx,8),%xmm0
mov    %eax,%ecx
or     $0x3,%ecx
movsd  0x1a0(%rsp,%rcx,8),%xmm1
or     $0x1,%eax
subsd  0x1a0(%rsp,%rax,8),%xmm1
mov    $0x2,%al
call   1040 <pythag2@plt>
movsd  0x38(%rsp),%xmm0
mov    %eax,%edi
mov    $0x1,%al
call   1070 <CircularSectorArea@plt>
xorps  %xmm5,%xmm5
cvtsi2sd %eax,%xmm5
testb  $0x8,(%rsp)
je     1331 <intersection_area_circle_triangle+0x1c1>
movsd  0x7bb(%rip),%xmm0
movsd  0x38(%rsp),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm1,%xmm0
subsd  %xmm5,%xmm0
movapd %xmm0,%xmm5
jmp    1331 <intersection_area_circle_triangle+0x1c1>
and    $0xfffffffd,%r14d
cmp    $0x4,%r14d
jne    1331 <intersection_area_circle_triangle+0x1c1>
lea    0x1c0(%rsp),%rbp
xor    %ebx,%ebx
mov    $0x1,%r15d
xor    %r13d,%r13d
jmp    18b9 <intersection_area_circle_triangle+0x749>
nopl   0x0(%rax,%rax,1)
add    %r12d,%r13d
add    $0x1,%rbx
add    $0x20,%rbp
add    $0x2,%r15
cmp    $0x3,%rbx
je     1ba5 <intersection_area_circle_triangle+0xa35>
bt     %ebx,%r9d
jae    18f2 <intersection_area_circle_triangle+0x782>
mov    %rbx,%rax
shl    $0x4,%rax
lea    0x0(%r13,%r13,1),%ecx
movslq %ecx,%rcx
movapd 0x240(%rsp,%rax,1),%xmm0
movapd %xmm0,0xb0(%rsp,%rcx,8)
movslq %r13d,%rax
add    $0x1,%r13d
movl   $0x1,0x110(%rsp,%rax,4)
mov    0x44(%rsp,%rbx,4),%r12d
test   %r12d,%r12d
jle    18a3 <intersection_area_circle_triangle+0x733>
lea    (%rbx,%rbx,1),%rax
mov    %rax,0x20(%rsp)
movslq %r13d,%r14
lea    (%rsp,%r14,4),%rdi
add    $0x110,%rdi
lea    0x0(,%r12,4),%rdx
xor    %esi,%esi
call   1050 <memset@plt>
cmp    $0x1,%r12d
mov    %r13,%r11
jne    1940 <intersection_area_circle_triangle+0x7d0>
xor    %eax,%eax
test   $0x1,%r12b
jne    1ae0 <intersection_area_circle_triangle+0x970>
mov    %rax,%rcx
jmp    1b10 <intersection_area_circle_triangle+0x9a0>
nop
mov    %rbp,0x10(%rsp)
lea    -0x1(%r12),%rbp
lea    0x0(%r13,%r13,1),%esi
mov    %ebp,%ecx
add    %ecx,%ecx
setb   %r8b
lea    (%rcx,%r13,2),%edi
mov    %rbp,%rax
mov    $0x10,%edx
mul    %rdx
seto   %dl
cmp    %esi,%edi
jl     1b77 <intersection_area_circle_triangle+0xa07>
test   %r8b,%r8b
jne    1b77 <intersection_area_circle_triangle+0xa07>
shr    $0x20,%rbp
jne    1b77 <intersection_area_circle_triangle+0xa07>
lea    0x1(%r13,%r13,1),%edi
lea    (%rcx,%r13,2),%ecx
add    $0x1,%ecx
cmp    %edi,%ecx
jl     1b77 <intersection_area_circle_triangle+0xa07>
test   %r8b,%r8b
jne    1b77 <intersection_area_circle_triangle+0xa07>
test   %rbp,%rbp
jne    1b77 <intersection_area_circle_triangle+0xa07>
movslq %esi,%rcx
lea    (%rsp,%rcx,8),%rdi
add    $0xb0,%rdi
lea    (%rdi,%rax,1),%rbp
cmp    %rdi,%rbp
jb     1b77 <intersection_area_circle_triangle+0xa07>
test   %dl,%dl
jne    1b77 <intersection_area_circle_triangle+0xa07>
lea    0xb8(%rsp),%rdi
lea    (%rdi,%rcx,8),%rcx
add    %rcx,%rax
cmp    %rcx,%rax
mov    0x10(%rsp),%rbp
jb     192b <intersection_area_circle_triangle+0x7bb>
test   %dl,%dl
jne    192b <intersection_area_circle_triangle+0x7bb>
mov    %r12d,%eax
and    $0xfffffffe,%eax
lea    -0x2(%rax),%rcx
mov    %rcx,%r8
shr    %r8
add    $0x1,%r8
test   %rcx,%rcx
je     1b8d <intersection_area_circle_triangle+0xa1d>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
add    $0x5,%esi
mov    %rbp,%rcx
xor    %edx,%edx
mov    (%rsp),%r9d
mov    %r11,%r13
cs nopw 0x0(%rax,%rax,1)
nop
movaps -0x20(%rcx),%xmm0
movaps -0x10(%rcx),%xmm1
lea    -0x4(%rsi),%ebp
movslq %ebp,%rbp
movaps %xmm1,0xb8(%rsp,%rbp,8)
movaps %xmm0,0xa8(%rsp,%rbp,8)
movapd (%rcx),%xmm0
movapd 0x10(%rcx),%xmm1
movslq %esi,%rsi
movapd %xmm1,0xb8(%rsp,%rsi,8)
movapd %xmm0,0xa8(%rsp,%rsi,8)
add    $0x4,%rdx
add    $0x8,%esi
add    $0x40,%rcx
add    $0xfffffffffffffffe,%rdi
jne    1a30 <intersection_area_circle_triangle+0x8c0>
test   $0x1,%r8b
je     1abc <intersection_area_circle_triangle+0x94c>
lea    (%rdx,%r13,1),%ecx
add    0x20(%rsp),%rdx
shl    $0x4,%rdx
movapd 0x1a0(%rsp,%rdx,1),%xmm0
movapd 0x1b0(%rsp,%rdx,1),%xmm1
add    %ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movapd %xmm1,0xb8(%rsp,%rcx,8)
movapd %xmm0,0xa8(%rsp,%rcx,8)
cmp    %r12,%rax
mov    0x10(%rsp),%rbp
je     18a0 <intersection_area_circle_triangle+0x730>
add    %rax,%r14
test   $0x1,%r12b
je     1937 <intersection_area_circle_triangle+0x7c7>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rdx
add    %rax,%rdx
shl    $0x4,%rdx
lea    (%r14,%r14,1),%ecx
movslq %ecx,%rcx
movapd 0x1a0(%rsp,%rdx,1),%xmm0
movapd %xmm0,0xb0(%rsp,%rcx,8)
add    $0x1,%r14
mov    %rax,%rcx
or     $0x1,%rcx
mov    (%rsp),%r9d
mov    %r11,%r13
not    %rax
add    %r12,%rax
je     18a0 <intersection_area_circle_triangle+0x730>
mov    %r12,%rax
sub    %rcx,%rax
add    %r14d,%r14d
add    %r15,%rcx
shl    $0x4,%rcx
add    %rsp,%rcx
add    $0x1a0,%rcx
nopl   (%rax)
movslq %r14d,%r14
movaps -0x10(%rcx),%xmm0
movaps %xmm0,0xb0(%rsp,%r14,8)
lea    0x2(%r14),%edx
movslq %edx,%rdx
movapd (%rcx),%xmm0
movapd %xmm0,0xb0(%rsp,%rdx,8)
add    $0x4,%r14d
add    $0x20,%rcx
add    $0xfffffffffffffffe,%rax
jne    1b40 <intersection_area_circle_triangle+0x9d0>
jmp    18a0 <intersection_area_circle_triangle+0x730>
xor    %eax,%eax
mov    0x10(%rsp),%rbp
test   $0x1,%r12b
jne    1ae0 <intersection_area_circle_triangle+0x970>
jmp    1937 <intersection_area_circle_triangle+0x7c7>
xor    %edx,%edx
mov    (%rsp),%r9d
mov    %r11,%r13
test   $0x1,%r8b
jne    1a83 <intersection_area_circle_triangle+0x913>
jmp    1abc <intersection_area_circle_triangle+0x94c>
cmp    $0x3,%r13d
jge    1bb8 <intersection_area_circle_triangle+0xa48>
movsd  0x455(%rip),%xmm5
jmp    1331 <intersection_area_circle_triangle+0x1c1>
xor    %ebx,%ebx
lea    0xb0(%rsp),%rsi
mov    %r13d,%edi
xor    %eax,%eax
call   1080 <polygon_area@plt>
mov    %r13,%rdx
xorps  %xmm5,%xmm5
cvtsi2sd %eax,%xmm5
mov    %edx,%r14d
lea    0xb8(%rsp),%rbp
jmp    1c01 <intersection_area_circle_triangle+0xa91>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
add    $0x10,%rbp
cmp    %rbx,%r14
je     1331 <intersection_area_circle_triangle+0x1c1>
test   %rbx,%rbx
mov    %ebx,%eax
cmove  %edx,%eax
movslq %eax,%rcx
cmpl   $0x0,0x10c(%rsp,%rcx,4)
jne    1bf0 <intersection_area_circle_triangle+0xa80>
cmpl   $0x0,0x110(%rsp,%rbx,4)
jne    1bf0 <intersection_area_circle_triangle+0xa80>
add    $0xffffffff,%eax
lea    (%rax,%rax,1),%ecx
movslq %ecx,%rcx
movsd  -0x8(%rbp),%xmm0
movsd  0x0(%rbp),%xmm1
subsd  0xb0(%rsp,%rcx,8),%xmm0
lea    0x1(%rax,%rax,1),%eax
cltq
subsd  0xb0(%rsp,%rax,8),%xmm1
mov    $0x2,%al
movapd %xmm5,(%rsp)
call   1040 <pythag2@plt>
movsd  0x38(%rsp),%xmm0
mov    %eax,%edi
mov    $0x1,%al
call   1070 <CircularSectorArea@plt>
movapd (%rsp),%xmm5
mov    %r13,%rdx
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm0,%xmm5
jmp    1bf0 <intersection_area_circle_triangle+0xa80>

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

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