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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
float fabs(int);
int floor(int);
int /*<<< orphan*/ plotLine(int, int, int, int);
void plotQuadBezierSeg(int, int, int, int, int, int);
int /*<<< orphan*/ setPixel(int, int);
int sqrt(int);
void plotCubicBezierSeg(int x0, int y0, float x1, float y1, float x2, float y2,
                        int x3, int y3) {
  int f, fx, fy, leg = 1;
  int sx = x0 < x3 ? 1 : -1, sy = y0 < y3 ? 1 : -1;
  float xc = -fabs(x0 + x1 - x2 - x3), xa = xc - 4 * sx * (x1 - x2),
        xb = sx * (x0 - x1 - x2 + x3);
  float yc = -fabs(y0 + y1 - y2 - y3), ya = yc - 4 * sy * (y1 - y2),
        yb = sy * (y0 - y1 - y2 + y3);
  double ab, ac, bc, cb, xx, xy, yy, dx, dy, ex, *pxy, EP = 0.01;
  assert((x1 - x0) * (x2 - x3) < EP &&
         ((x3 - x0) * (x1 - x2) < EP || xb * xb < xa * xc + EP));
  assert((y1 - y0) * (y2 - y3) < EP &&
         ((y3 - y0) * (y1 - y2) < EP || yb * yb < ya * yc + EP));
  if (xa == 0 && ya == 0) {
    sx = floor((3 * x1 - x0 + 1) / 2);
    sy = floor((3 * y1 - y0 + 1) / 2);
    return plotQuadBezierSeg(x0, y0, sx, sy, x3, y3);
  }
  x1 = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0) + 1;
  x2 = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3) + 1;
  do {
    ab = xa * yb - xb * ya;
    ac = xa * yc - xc * ya;
    bc = xb * yc - xc * yb;
    ex = ab * (ab + ac - 3 * bc) + ac * ac;
    f = ex > 0 ? 1 : sqrt(1 + 1024 / x1);
    ab *= f;
    ac *= f;
    bc *= f;
    ex *= f * f;
    xy = 9 * (ab + ac + bc) / 8;
    cb = 8 * (xa - ya);
    dx = 27 * (8 * ab * (yb * yb - ya * yc) + ex * (ya + 2 * yb + yc)) / 64 -
         ya * ya * (xy - ya);
    dy = 27 * (8 * ab * (xb * xb - xa * xc) - ex * (xa + 2 * xb + xc)) / 64 -
         xa * xa * (xy + xa);
    xx = 3 *
         (3 * ab * (3 * yb * yb - ya * ya - 2 * ya * yc) -
          ya * (3 * ac * (ya + yb) + ya * cb)) /
         4;
    yy = 3 *
         (3 * ab * (3 * xb * xb - xa * xa - 2 * xa * xc) -
          xa * (3 * ac * (xa + xb) + xa * cb)) /
         4;
    xy = xa * ya * (6 * ab + 6 * ac - 3 * bc + cb);
    ac = ya * ya;
    cb = xa * xa;
    xy = 3 * (xy + 9 * f * (cb * yb * yc - xb * xc * ac) - 18 * xb * yb * ab) /
         8;
    if (ex < 0) {
      dx = -dx;
      dy = -dy;
      xx = -xx;
      yy = -yy;
      xy = -xy;
      ac = -ac;
      cb = -cb;
    }
    ab = 6 * ya * ac;
    ac = -6 * xa * ac;
    bc = 6 * ya * cb;
    cb = -6 * xa * cb;
    dx += xy;
    ex = dx + dy;
    dy += xy;
    for (pxy = &xy, fx = fy = f; x0 != x3 && y0 != y3;) {
      setPixel(x0, y0);
      do {
        if (dx > *pxy || dy < *pxy)
          goto exit;
        y1 = 2 * ex - dy;
        if (2 * ex >= dx) {
          fx--;
          ex += dx += xx;
          dy += xy += ac;
          yy += bc;
          xx += ab;
        }
        if (y1 <= 0) {
          fy--;
          ex += dy += yy;
          dx += xy += bc;
          xx += ac;
          yy += cb;
        }
      } while (fx > 0 && fy > 0);
      if (2 * fx <= f) {
        x0 += sx;
        fx += f;
      }
      if (2 * fy <= f) {
        y0 += sy;
        fy += f;
      }
      if (pxy == &xy && dx < 0 && dy > 0)
        pxy = &EP;
    }
  exit:
    xx = x0;
    x0 = x3;
    x3 = xx;
    sx = -sx;
    xb = -xb;
    yy = y0;
    y0 = y3;
    y3 = yy;
    sy = -sy;
    yb = -yb;
    x1 = x2;
  } while (leg--);
  plotLine(x0, y0, x3, y3);
}


x86 assembly (clang, -O0):
<plotCubicBezierSeg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movss  %xmm0,-0xc(%rbp)
movss  %xmm1,-0x10(%rbp)
movss  %xmm2,-0x14(%rbp)
movss  %xmm3,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x4(%rbp),%edx
mov    -0x1c(%rbp),%esi
mov    $0xffffffff,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%edx
mov    -0x20(%rbp),%esi
mov    $0xffffffff,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmovl  %ecx,%eax
mov    %eax,-0x38(%rbp)
cvtsi2ssl -0x4(%rbp),%xmm0
addss  -0xc(%rbp),%xmm0
subss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x1c(%rbp),%xmm1
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1050 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm1
mov    -0x34(%rbp),%eax
shl    $0x2,%eax
cvtsi2ss %eax,%xmm0
movss  -0xc(%rbp),%xmm2
subss  -0x14(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
cvtsi2ssl -0x34(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
subss  -0xc(%rbp),%xmm1
subss  -0x14(%rbp),%xmm1
cvtsi2ssl -0x1c(%rbp),%xmm2
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
cvtsi2ssl -0x8(%rbp),%xmm0
addss  -0x10(%rbp),%xmm0
subss  -0x18(%rbp),%xmm0
cvtsi2ssl -0x20(%rbp),%xmm1
subss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1050 <fabs@plt>
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x48(%rbp),%xmm1
mov    -0x38(%rbp),%eax
shl    $0x2,%eax
cvtsi2ss %eax,%xmm0
movss  -0x10(%rbp),%xmm2
subss  -0x18(%rbp),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
cvtsi2ssl -0x38(%rbp),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
subss  -0x10(%rbp),%xmm1
subss  -0x18(%rbp),%xmm1
cvtsi2ssl -0x20(%rbp),%xmm2
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movsd  0x1d0e(%rip),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movss  -0xc(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  -0x14(%rbp),%xmm1
cvtsi2ssl -0x1c(%rbp),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0xb1(%rbp)
jbe    13ab <plotCubicBezierSeg+0x23b>
mov    -0x1c(%rbp),%eax
sub    -0x4(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  -0xc(%rbp),%xmm1
subss  -0x14(%rbp),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0xb2(%rbp)
ja     139f <plotCubicBezierSeg+0x22f>
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
mulss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xb2(%rbp)
mov    -0xb2(%rbp),%al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
movss  -0x10(%rbp),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  -0x18(%rbp),%xmm1
cvtsi2ssl -0x20(%rbp),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
xor    %eax,%eax
ucomisd %xmm1,%xmm0
mov    %al,-0xb3(%rbp)
jbe    146c <plotCubicBezierSeg+0x2fc>
mov    -0x20(%rbp),%eax
sub    -0x8(%rbp),%eax
cvtsi2ss %eax,%xmm0
movss  -0x10(%rbp),%xmm1
subss  -0x18(%rbp),%xmm1
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mov    $0x1,%al
ucomisd %xmm1,%xmm0
mov    %al,-0xb4(%rbp)
ja     1460 <plotCubicBezierSeg+0x2f0>
movss  -0x50(%rbp),%xmm0
mulss  -0x50(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mulss  -0x48(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0xb0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
seta   %al
mov    %al,-0xb4(%rbp)
mov    -0xb4(%rbp),%al
mov    %al,-0xb3(%rbp)
mov    -0xb3(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1060 <assert@plt>
movss  -0x40(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    155e <plotCubicBezierSeg+0x3ee>
jp     155e <plotCubicBezierSeg+0x3ee>
movss  -0x4c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    155e <plotCubicBezierSeg+0x3ee>
jp     155e <plotCubicBezierSeg+0x3ee>
movss  -0xc(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0x1b97(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x1b77(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0x1b77(%rip),%xmm1
divss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1090 <floor@plt>
mov    %eax,-0x34(%rbp)
movss  -0x10(%rbp),%xmm0
cvtsi2ssl -0x8(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
movss  0x1b4c(%rip),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x1b2c(%rip),%xmm1
addss  %xmm1,%xmm0
movss  0x1b2c(%rip),%xmm1
divss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1090 <floor@plt>
mov    %eax,-0x38(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x34(%rbp),%edx
mov    -0x38(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x20(%rbp),%r9d
call   1030 <plotQuadBezierSeg@plt>
jmp    215d <plotCubicBezierSeg+0xfed>
movss  -0xc(%rbp),%xmm0
cvtsi2ssl -0x4(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  -0xc(%rbp),%xmm2
cvtsi2ssl -0x4(%rbp),%xmm1
subss  %xmm1,%xmm2
movss  -0x10(%rbp),%xmm1
cvtsi2ssl -0x8(%rbp),%xmm3
subss  %xmm3,%xmm1
movss  -0x10(%rbp),%xmm3
cvtsi2ssl -0x8(%rbp),%xmm4
subss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x1aa6(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xc(%rbp)
movss  -0x14(%rbp),%xmm0
cvtsi2ssl -0x1c(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  -0x14(%rbp),%xmm2
cvtsi2ssl -0x1c(%rbp),%xmm1
subss  %xmm1,%xmm2
movss  -0x18(%rbp),%xmm1
cvtsi2ssl -0x20(%rbp),%xmm3
subss  %xmm3,%xmm1
movss  -0x18(%rbp),%xmm3
cvtsi2ssl -0x20(%rbp),%xmm4
subss  %xmm4,%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  0x1a51(%rip),%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm2
movsd  0x194e(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1701 <plotCubicBezierSeg+0x591>
mov    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1729 <plotCubicBezierSeg+0x5b9>
movss  0x194b(%rip),%xmm1
divss  -0xc(%rbp),%xmm1
movss  0x193a(%rip),%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
call   1080 <sqrt@plt>
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    %eax,-0x24(%rbp)
cvtsi2sdl -0x24(%rbp),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
cvtsi2sdl -0x24(%rbp),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
cvtsi2sdl -0x24(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x24(%rbp),%eax
imul   -0x24(%rbp),%eax
cvtsi2sd %eax,%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
addsd  -0x68(%rbp),%xmm1
movsd  0x18af(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x1873(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movss  -0x40(%rbp),%xmm1
subss  -0x4c(%rbp),%xmm1
movss  0x18ac(%rip),%xmm0
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  0x1843(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
movss  -0x50(%rbp),%xmm3
movss  -0x4c(%rbp),%xmm2
mulss  -0x48(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
movss  -0x4c(%rbp),%xmm4
movss  -0x50(%rbp),%xmm3
addss  %xmm3,%xmm3
addss  %xmm4,%xmm3
addss  -0x48(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1802(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x17ee(%rip),%xmm0
divsd  %xmm0,%xmm1
movss  -0x4c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x80(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
subsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  0x177b(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movss  -0x44(%rbp),%xmm1
movss  -0x44(%rbp),%xmm3
movss  -0x40(%rbp),%xmm2
mulss  -0x3c(%rbp),%xmm2
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm2
movsd  -0xa0(%rbp),%xmm1
ff
movss  -0x40(%rbp),%xmm4
movss  -0x44(%rbp),%xmm3
addss  %xmm3,%xmm3
addss  %xmm4,%xmm3
addss  -0x3c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0x1723(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x170f(%rip),%xmm0
divsd  %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x80(%rbp),%xmm2
movss  -0x40(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm3,%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0x16a4(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
movss  0x16df(%rip),%xmm2
mulss  -0x50(%rbp),%xmm2
movss  -0x50(%rbp),%xmm3
movss  -0x4c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
movss  0x16aa(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  -0x48(%rbp),%xmm3
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm2
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x1632(%rip),%xmm3
mulsd  -0x60(%rbp),%xmm3
movss  -0x4c(%rbp),%xmm4
addss  -0x50(%rbp),%xmm4
cvtss2sd %xmm4,%xmm5
movss  -0x4c(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  -0x70(%rbp),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x15de(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x15e2(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  0x15c1(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
movss  0x15fc(%rip),%xmm2
mulss  -0x44(%rbp),%xmm2
movss  -0x44(%rbp),%xmm3
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
movss  0x15c7(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm3
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm3,%xmm0
addss  %xmm2,%xmm0
cvtss2sd %xmm0,%xmm2
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x154f(%rip),%xmm3
mulsd  -0x60(%rbp),%xmm3
movss  -0x40(%rbp),%xmm4
addss  -0x44(%rbp),%xmm4
cvtss2sd %xmm4,%xmm5
movss  -0x40(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
mulsd  -0x70(%rbp),%xmm4
mulsd  %xmm5,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm3,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x14fb(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x14ff(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movss  -0x40(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  -0x58(%rbp),%xmm2
movsd  0x14d0(%rip),%xmm1
mulsd  -0x60(%rbp),%xmm1
movsd  0x14c3(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x68(%rbp),%xmm1
movsd  0x1496(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
addsd  -0x70(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movss  -0x4c(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  -0x40(%rbp),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm1
imul   $0x9,-0x24(%rbp),%eax
cvtsi2sd %eax,%xmm0
movsd  -0x70(%rbp),%xmm2
movss  -0x50(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm3,%xmm2
movss  -0x48(%rbp),%xmm3
cvtss2sd %xmm3,%xmm4
movss  -0x44(%rbp),%xmm3
mulss  -0x3c(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  -0x60(%rbp),%xmm3
movq   %xmm3,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movss  0x1440(%rip),%xmm1
mulss  -0x44(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
movsd  -0x58(%rbp),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x13c6(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  0x13b2(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    1d71 <plotCubicBezierSeg+0xc01>
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movss  0x12f3(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movss  0x12d4(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movss  0x12bd(%rip),%xmm0
mulss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movss  0x129e(%rip),%xmm0
mulss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x80(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
lea    -0x80(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%ecx
xor    %eax,%eax
cmp    -0x1c(%rbp),%ecx
mov    %al,-0xb9(%rbp)
je     1e56 <plotCubicBezierSeg+0xce6>
mov    -0x8(%rbp),%eax
cmp    -0x20(%rbp),%eax
setne  %al
mov    %al,-0xb9(%rbp)
mov    -0xb9(%rbp),%al
test   $0x1,%al
jne    1e69 <plotCubicBezierSeg+0xcf9>
jmp    20b5 <plotCubicBezierSeg+0xf45>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
call   1040 <setPixel@plt>
movsd  -0x90(%rbp),%xmm0
ff
mov    -0xa8(%rbp),%rax
ucomisd (%rax),%xmm0
ja     1eaa <plotCubicBezierSeg+0xd3a>
movsd  -0x98(%rbp),%xmm1
ff
mov    -0xa8(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1eaf <plotCubicBezierSeg+0xd3f>
jmp    20ba <plotCubicBezierSeg+0xf4a>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  -0x98(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10(%rbp)
movsd  0x1159(%rip),%xmm0
mulsd  -0xa0(%rbp),%xmm0
ff
ucomisd -0x90(%rbp),%xmm0
ff
jb     1f76 <plotCubicBezierSeg+0xe06>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
movsd  -0x78(%rbp),%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
ucomiss -0x10(%rbp),%xmm0
jb     1ff7 <plotCubicBezierSeg+0xe87>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
addsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
addsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x70(%rbp),%xmm0
addsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
jmp    1ffc <plotCubicBezierSeg+0xe8c>
xor    %eax,%eax
cmpl   $0x0,-0x28(%rbp)
mov    %al,-0xba(%rbp)
jle    201b <plotCubicBezierSeg+0xeab>
cmpl   $0x0,-0x2c(%rbp)
setg   %al
mov    %al,-0xba(%rbp)
mov    -0xba(%rbp),%al
test   $0x1,%al
jne    1e74 <plotCubicBezierSeg+0xd04>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
cmp    -0x24(%rbp),%eax
jg     204a <plotCubicBezierSeg+0xeda>
mov    -0x34(%rbp),%eax
add    -0x4(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
cmp    -0x24(%rbp),%eax
jg     206b <plotCubicBezierSeg+0xefb>
mov    -0x38(%rbp),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x24(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
lea    -0x80(%rbp),%rax
cmp    %rax,-0xa8(%rbp)
jne    20b0 <plotCubicBezierSeg+0xf40>
xorps  %xmm0,%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    20b0 <plotCubicBezierSeg+0xf40>
movsd  -0x98(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    20b0 <plotCubicBezierSeg+0xf40>
lea    -0xb0(%rbp),%rax
mov    %rax,-0xa8(%rbp)
jmp    1e33 <plotCubicBezierSeg+0xcc3>
jmp    20ba <plotCubicBezierSeg+0xf4a>
cvtsi2sdl -0x4(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
cvttsd2si -0x78(%rbp),%eax
mov    %eax,-0x1c(%rbp)
xor    %eax,%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x44(%rbp)
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%eax
mov    %eax,-0x8(%rbp)
cvttsd2si -0x88(%rbp),%eax
ff
mov    %eax,-0x20(%rbp)
xor    %eax,%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
movss  -0x50(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0xc(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cmp    $0x0,%eax
jne    1608 <plotCubicBezierSeg+0x498>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
call   1070 <plotLine@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<plotCubicBezierSeg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x218,%rsp
movdqa %xmm3,0x20(%rsp)
movaps %xmm2,0x80(%rsp)
movaps %xmm1,0x50(%rsp)
movaps %xmm0,0xc0(%rsp)
mov    %esi,%r12d
mov    %edi,%ebx
xor    %eax,%eax
mov    %edx,%r15d
sub    %edi,%r15d
setg   %al
xor    %esi,%esi
mov    %ecx,%r14d
sub    %r12d,%r14d
setg   %sil
movd   %esi,%xmm1
pinsrw $0x2,%eax,%xmm1
pslld  $0x1f,%xmm1
psrad  $0x1f,%xmm1
pcmpeqd %xmm3,%xmm3
pxor   %xmm1,%xmm3
psrld  $0x1f,%xmm1
por    %xmm3,%xmm1
movdqa %xmm1,0x90(%rsp)
movd   %edi,%xmm3
movd   %r12d,%xmm1
punpckldq %xmm3,%xmm1
cvtdq2ps %xmm1,%xmm3
movaps %xmm3,0x10(%rsp)
shufps $0x55,%xmm3,%xmm3
movaps %xmm3,0x70(%rsp)
addss  %xmm0,%xmm3
subss  %xmm2,%xmm3
mov    %edx,0xb0(%rsp)
movd   %edx,%xmm1
mov    %ecx,%r13d
movd   %ecx,%xmm2
punpckldq %xmm1,%xmm2
cvtdq2ps %xmm2,%xmm0
movaps %xmm0,0x30(%rsp)
shufps $0x55,%xmm0,%xmm0
movaps %xmm0,0x40(%rsp)
subss  %xmm0,%xmm3
cvttss2si %xmm3,%edi
call   1050 <fabs@plt>
movaps %xmm0,0xe0(%rsp)
movaps 0x10(%rsp),%xmm0
addss  0x50(%rsp),%xmm0
subss  0x20(%rsp),%xmm0
subss  0x30(%rsp),%xmm0
cvttss2si %xmm0,%edi
call   1050 <fabs@plt>
unpcklps 0xe0(%rsp),%xmm0
movaps 0xd89(%rip),%xmm8
movaps %xmm0,%xmm9
xorps  %xmm8,%xmm9
movaps 0x50(%rsp),%xmm3
movaps 0xc0(%rsp),%xmm7
unpcklps %xmm7,%xmm3
movaps 0x20(%rsp),%xmm2
movaps 0x80(%rsp),%xmm6
unpcklps %xmm6,%xmm2
movaps 0x10(%rsp),%xmm5
subps  %xmm3,%xmm5
subps  %xmm2,%xmm3
movaps 0x90(%rsp),%xmm4
cvtdq2ps %xmm4,%xmm1
subps  %xmm2,%xmm5
addps  0x30(%rsp),%xmm5
mulps  %xmm1,%xmm5
movaps %xmm7,%xmm1
subss  0x70(%rsp),%xmm1
movaps %xmm6,%xmm2
subss  0x40(%rsp),%xmm2
movaps %xmm1,0x100(%rsp)
movaps %xmm2,0x80(%rsp)
mulss  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
xor    %ebp,%ebp
movsd  0xd8c(%rip),%xmm6
ucomisd %xmm1,%xmm6
movaps %xmm4,%xmm1
pslld  $0x2,%xmm1
cvtdq2ps %xmm1,%xmm2
xorps  %xmm8,%xmm2
mulps  %xmm3,%xmm2
movaps %xmm0,0x140(%rsp)
subps  %xmm0,%xmm2
movabs $0x3f847ae147ae147b,%rax
7a 84 3f
mov    %rax,0x138(%rsp)
mov    $0x0,%edi
jbe    1382 <plotCubicBezierSeg+0x212>
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
mulss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mov    $0x1,%edi
ucomisd %xmm0,%xmm6
ja     1382 <plotCubicBezierSeg+0x212>
movaps %xmm5,%xmm0
mulps  %xmm5,%xmm0
shufps $0x55,%xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movaps %xmm2,%xmm1
mulps  %xmm9,%xmm1
shufps $0x55,%xmm1,%xmm1
cvtss2sd %xmm1,%xmm1
addsd  0xd08(%rip),%xmm1
xor    %edi,%edi
ucomisd %xmm0,%xmm1
seta   %dil
movaps %xmm3,0xf0(%rsp)
movaps %xmm2,0x40(%rsp)
movaps %xmm5,0xa0(%rsp)
movaps %xmm9,0xd0(%rsp)
call   1060 <assert@plt>
movsd  0xcd3(%rip),%xmm2
movaps 0x50(%rsp),%xmm0
subss  0x10(%rsp),%xmm0
movaps 0x20(%rsp),%xmm1
subss  0x30(%rsp),%xmm1
movaps %xmm0,0x30(%rsp)
movaps %xmm1,0x20(%rsp)
mulss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm0,%xmm2
jbe    1435 <plotCubicBezierSeg+0x2c5>
xorps  %xmm0,%xmm0
cvtsi2ss %r14d,%xmm0
movaps 0xf0(%rsp),%xmm1
mulss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mov    $0x1,%ebp
ucomisd %xmm0,%xmm2
ja     1435 <plotCubicBezierSeg+0x2c5>
movaps 0xa0(%rsp),%xmm0
mulss  %xmm0,%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x40(%rsp),%xmm1
mulss  0xd0(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  0xc55(%rip),%xmm1
xor    %ebp,%ebp
ucomisd %xmm0,%xmm1
seta   %bpl
mov    %ebp,%edi
call   1060 <assert@plt>
movaps 0x40(%rsp),%xmm10
movaps %xmm10,%xmm0
shufps $0x55,%xmm10,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    14f4 <plotCubicBezierSeg+0x384>
jp     14f4 <plotCubicBezierSeg+0x384>
ucomiss %xmm1,%xmm10
jne    14f4 <plotCubicBezierSeg+0x384>
jp     14f4 <plotCubicBezierSeg+0x384>
movaps 0xc0(%rsp),%xmm0
mulss  0xc53(%rip),%xmm0
subss  0x70(%rsp),%xmm0
addss  0xc39(%rip),%xmm0
mulss  0xc41(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1090 <floor@plt>
mov    %eax,%ebp
movaps 0x50(%rsp),%xmm0
mulss  0xc25(%rip),%xmm0
subss  0x10(%rsp),%xmm0
addss  0xc0b(%rip),%xmm0
mulss  0xc13(%rip),%xmm0
cvttss2si %xmm0,%edi
call   1090 <floor@plt>
mov    %ebx,%edi
mov    %r12d,%esi
mov    %ebp,%edx
mov    %eax,%ecx
mov    0xb0(%rsp),%r8d
mov    %r13d,%r9d
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <plotQuadBezierSeg@plt>
movaps 0x30(%rsp),%xmm1
mulss  %xmm1,%xmm1
movaps 0x100(%rsp),%xmm5
mulss  %xmm5,%xmm5
addss  %xmm1,%xmm5
movaps 0x20(%rsp),%xmm2
mulss  %xmm2,%xmm2
movaps 0x80(%rsp),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
movaps %xmm1,0x80(%rsp)
movaps 0xe0(%rsp),%xmm1
mulss  %xmm10,%xmm1
movaps %xmm0,%xmm2
movaps 0xd0(%rsp),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm1,%xmm2
cvtss2sd %xmm2,%xmm15
movaps %xmm15,%xmm2
movaps %xmm0,%xmm1
subss  %xmm10,%xmm1
mulss  0xb51(%rip),%xmm1
mulsd  %xmm15,%xmm2
movsd  %xmm2,0x130(%rsp)
cvtss2sd %xmm1,%xmm1
movaps 0x140(%rsp),%xmm2
mulps  %xmm10,%xmm2
movaps %xmm2,0x1e0(%rsp)
movaps %xmm10,%xmm2
mulps  %xmm10,%xmm2
cvtps2pd %xmm2,%xmm3
cvtps2pd %xmm10,%xmm6
movapd 0xa6b(%rip),%xmm8
xorpd  %xmm3,%xmm8
xorps  0xa4f(%rip),%xmm2
movaps %xmm2,0x1d0(%rsp)
movaps 0xa60(%rip),%xmm2
mulps  %xmm10,%xmm2
movaps %xmm1,0x1f0(%rsp)
movlhps %xmm1,%xmm1
movapd %xmm6,0x1c0(%rsp)
mulpd  %xmm6,%xmm1
movapd %xmm1,0x1a0(%rsp)
movaps %xmm0,%xmm1
mulss  %xmm10,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  %xmm1,0x128(%rsp)
xorps  %xmm1,%xmm1
cvtss2sd %xmm4,%xmm1
movsd  %xmm1,0x120(%rsp)
movss  0xaaa(%rip),%xmm1
mulss  %xmm10,%xmm1
cvtss2sd %xmm1,%xmm1
mulss  0xa9d(%rip),%xmm0
xorps  %xmm6,%xmm6
cvtss2sd %xmm0,%xmm6
movdqa 0x90(%rsp),%xmm0
movd   %xmm0,%r14d
pshufd $0x55,%xmm0,%xmm0
movd   %xmm0,%r15d
movlhps %xmm6,%xmm6
movaps %xmm6,0x170(%rsp)
movlhps %xmm1,%xmm1
movaps %xmm1,0x180(%rsp)
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm0,0x190(%rsp)
movl   $0x1,0x68(%rsp)
mulps  %xmm4,%xmm2
movaps %xmm2,0x1b0(%rsp)
xorpd  %xmm12,%xmm12
movapd 0x986(%rip),%xmm14
movaps 0x96f(%rip),%xmm7
movaps 0xa0(%rsp),%xmm9
mov    %r13d,%ebp
mov    0xb0(%rsp),%r8d
movsd  %xmm15,0x10(%rsp)
movapd %xmm3,0x160(%rsp)
movapd %xmm8,0x150(%rsp)
jmp    1707 <plotCubicBezierSeg+0x597>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%ebp
mov    %r13d,%r8d
neg    %r15d
neg    %r14d
xorps  %xmm7,%xmm9
unpcklps 0xc0(%rsp),%xmm9
movaps 0x80(%rsp),%xmm5
subl   $0x1,0x68(%rsp)
mov    0x90(%rsp),%r12d
mov    0x30(%rsp),%ebx
jb     1cec <plotCubicBezierSeg+0xb7c>
mov    %ebx,%r13d
mov    %r12d,%edx
mov    %ebp,%r12d
mov    %r8d,%ebx
movaps %xmm9,%xmm0
shufps $0x55,%xmm9,%xmm0
movaps %xmm0,0x20(%rsp)
xorps  %xmm7,%xmm0
movaps %xmm0,0xc0(%rsp)
movaps 0xe0(%rsp),%xmm1
movlhps %xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
movaps %xmm9,%xmm1
unpcklps %xmm10,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm10,%xmm0
shufps $0x11,%xmm9,%xmm0
shufps $0xe2,%xmm9,%xmm0
movaps 0xd0(%rsp),%xmm2
unpcklps %xmm9,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
cvtps2pd %xmm2,%xmm3
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm0,%xmm1
addsd  %xmm15,%xmm1
movapd %xmm3,%xmm11
mulsd  0x900(%rip),%xmm11
addsd  %xmm1,%xmm11
mulsd  %xmm0,%xmm11
addsd  0x130(%rsp),%xmm11
ucomisd %xmm12,%xmm11
mov    $0x1,%eax
movaps %xmm9,0xa0(%rsp)
ja     181d <plotCubicBezierSeg+0x6ad>
movss  0x90b(%rip),%xmm1
addss  %xmm1,%xmm5
movss  0x903(%rip),%xmm0
divss  %xmm5,%xmm0
addss  %xmm1,%xmm0
cvttss2si %xmm0,%edi
mov    %edx,%ebp
movapd %xmm11,0x50(%rsp)
movapd %xmm3,0x70(%rsp)
call   1080 <sqrt@plt>
movapd 0x70(%rsp),%xmm3
mov    %ebp,%edx
movapd 0x81a(%rip),%xmm14
movapd 0x50(%rsp),%xmm11
movapd 0x150(%rsp),%xmm8
movsd  0x10(%rsp),%xmm15
movaps 0x40(%rsp),%xmm10
movaps 0xa0(%rsp),%xmm9
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm15,%xmm1
mulsd  %xmm0,%xmm1
unpcklpd %xmm0,%xmm0
mov    %eax,%ecx
imul   %eax,%ecx
xorps  %xmm2,%xmm2
cvtsi2sd %ecx,%xmm2
mulpd  %xmm3,%xmm0
mulsd  %xmm2,%xmm11
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
movapd %xmm2,%xmm3
mulsd  0x846(%rip),%xmm3
movaps %xmm9,%xmm4
mulps  %xmm9,%xmm4
addps  0x1e0(%rsp),%xmm4
cvtps2pd %xmm4,%xmm4
movapd %xmm11,%xmm5
xorpd  %xmm14,%xmm5
movapd %xmm11,%xmm6
unpcklpd %xmm5,%xmm6
movaps %xmm9,%xmm5
addps  %xmm9,%xmm5
addps  %xmm10,%xmm5
subps  0x140(%rsp),%xmm5
cvtps2pd %xmm5,%xmm5
mulpd  %xmm5,%xmm6
unpcklpd %xmm3,%xmm3
mulpd  %xmm4,%xmm3
movapd %xmm2,%xmm13
movapd %xmm2,%xmm4
addsd  %xmm1,%xmm4
addsd  %xmm0,%xmm4
mulsd  0x7d4(%rip),%xmm4
movsd  0x7d3(%rip),%xmm12
mulsd  %xmm12,%xmm4
addpd  %xmm6,%xmm3
mulpd  0x75a(%rip),%xmm3
mulpd  0x762(%rip),%xmm3
movapd %xmm4,%xmm5
unpcklpd %xmm4,%xmm5
movapd 0x1c0(%rsp),%xmm12
subpd  %xmm12,%xmm4
addpd  %xmm12,%xmm5
movsd  %xmm4,%xmm5
mulpd  %xmm8,%xmm5
addpd  %xmm3,%xmm5
movsd  0x798(%rip),%xmm15
mulsd  %xmm15,%xmm13
movapd %xmm1,%xmm3
mulsd  %xmm15,%xmm3
addps  %xmm9,%xmm10
cvtps2pd %xmm10,%xmm4
unpcklpd %xmm3,%xmm3
mulpd  %xmm4,%xmm3
movaps %xmm9,%xmm4
mulps  0x717(%rip),%xmm4
mulps  %xmm9,%xmm4
addps  0x1d0(%rsp),%xmm4
addps  0x1b0(%rsp),%xmm4
cvtps2pd %xmm4,%xmm4
unpcklpd %xmm13,%xmm13
mulpd  %xmm4,%xmm13
movapd 0x160(%rsp),%xmm10
movaps 0x20(%rsp),%xmm4
mulss  0x75b(%rip),%xmm4
mulss  %xmm9,%xmm4
xorps  %xmm6,%xmm6
cvtss2sd %xmm4,%xmm6
mulsd  %xmm2,%xmm6
addpd  0x1a0(%rsp),%xmm3
mulpd  %xmm12,%xmm3
movaps 0xd0(%rsp),%xmm7
movsd  0x6e9(%rip),%xmm4
xorpd  %xmm12,%xmm12
subpd  %xmm3,%xmm13
movsd  0x6ff(%rip),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm4,%xmm0
lea    (%rax,%rax,8),%ecx
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
addsd  %xmm2,%xmm0
xorps  %xmm2,%xmm2
cvtss2sd %xmm9,%xmm2
mulsd  0x190(%rsp),%xmm2
mulsd  0x120(%rsp),%xmm2
movaps %xmm9,%xmm3
mulps  %xmm7,%xmm3
shufps $0x55,%xmm3,%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm10,%xmm3
subsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm2
addsd  0x1f0(%rsp),%xmm0
mulsd  0x128(%rsp),%xmm0
addsd  %xmm0,%xmm2
addsd  %xmm2,%xmm6
ucomisd %xmm11,%xmm12
mulpd  0x633(%rip),%xmm13
mulpd  0x63a(%rip),%xmm13
mulsd  %xmm15,%xmm6
mulsd  0x655(%rip),%xmm6
jbe    1a60 <plotCubicBezierSeg+0x8f0>
xorpd  %xmm14,%xmm5
xorpd  %xmm14,%xmm13
xorpd  %xmm14,%xmm6
movapd %xmm8,%xmm4
jmp    1a69 <plotCubicBezierSeg+0x8f9>
nopl   0x0(%rax,%rax,1)
movapd 0x160(%rsp),%xmm4
movsd  0x10(%rsp),%xmm15
movaps 0x40(%rsp),%xmm10
movaps 0x583(%rip),%xmm7
movsd  %xmm6,0x8(%rsp)
cmp    %ebx,%r13d
mov    %r12d,0x90(%rsp)
mov    %ebx,0x30(%rsp)
je     16d0 <plotCubicBezierSeg+0x560>
cmp    %r12d,%edx
je     16d0 <plotCubicBezierSeg+0x560>
movapd %xmm4,%xmm0
mulpd  0x180(%rsp),%xmm0
mulpd  0x170(%rsp),%xmm4
movapd %xmm6,%xmm3
addsd  %xmm5,%xmm3
unpckhpd %xmm5,%xmm5
addsd  %xmm5,%xmm6
addsd  %xmm3,%xmm5
movapd %xmm0,0x20(%rsp)
unpckhpd %xmm0,%xmm0
movapd %xmm0,0x50(%rsp)
lea    0x8(%rsp),%r12
mov    %r13d,%r8d
mov    %edx,%ebp
mov    %eax,%ebx
mov    %rax,0x118(%rsp)
mov    %rax,%r13
mov    %r15d,0x6c(%rsp)
movapd %xmm4,0x200(%rsp)
movsd  %xmm3,0xf0(%rsp)
movapd %xmm6,0x100(%rsp)
movapd %xmm5,0xb0(%rsp)
movapd %xmm13,0x70(%rsp)
mov    %r8d,%edi
mov    %ebp,%esi
mov    %r14d,%r15d
mov    %r8d,%r14d
call   1040 <setPixel@plt>
movsd  0xf0(%rsp),%xmm3
movapd 0x200(%rsp),%xmm4
movapd 0xb0(%rsp),%xmm5
movapd 0x70(%rsp),%xmm13
movapd 0x4b3(%rip),%xmm14
xorpd  %xmm12,%xmm12
movapd 0x100(%rsp),%xmm6
movapd 0x150(%rsp),%xmm8
movsd  0x10(%rsp),%xmm15
mov    %r14d,%r8d
mov    %r15d,%r14d
mov    0x6c(%rsp),%r15d
movaps 0x40(%rsp),%xmm10
movaps 0xa0(%rsp),%xmm9
movaps 0x463(%rip),%xmm7
xorpd  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r12),%xmm0
ucomisd %xmm0,%xmm3
ja     16d5 <plotCubicBezierSeg+0x565>
ucomisd %xmm6,%xmm0
ja     16d5 <plotCubicBezierSeg+0x565>
movapd %xmm5,%xmm0
addsd  %xmm5,%xmm0
ucomisd %xmm3,%xmm0
jae    1be0 <plotCubicBezierSeg+0xa70>
movapd %xmm6,%xmm1
jmp    1c08 <plotCubicBezierSeg+0xa98>
xchg   %ax,%ax
add    $0xffffffff,%r13d
addsd  %xmm13,%xmm3
addsd  %xmm3,%xmm5
movsd  0x8(%rsp),%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,0x8(%rsp)
addsd  %xmm6,%xmm1
addpd  0x20(%rsp),%xmm13
subsd  %xmm6,%xmm0
cvtsd2ss %xmm0,%xmm0
ucomiss %xmm0,%xmm2
jae    1c20 <plotCubicBezierSeg+0xab0>
movapd %xmm1,%xmm6
test   %r13d,%r13d
jg     1c60 <plotCubicBezierSeg+0xaf0>
jmp    1c68 <plotCubicBezierSeg+0xaf8>
add    $0xffffffff,%ebx
movapd %xmm4,%xmm0
addpd  %xmm13,%xmm0
unpckhpd %xmm13,%xmm13
addsd  %xmm1,%xmm13
addsd  %xmm13,%xmm5
movsd  0x8(%rsp),%xmm1
addsd  0x50(%rsp),%xmm1
movsd  %xmm1,0x8(%rsp)
addsd  %xmm1,%xmm3
movapd %xmm13,%xmm6
movapd %xmm0,%xmm13
test   %r13d,%r13d
jle    1c68 <plotCubicBezierSeg+0xaf8>
test   %ebx,%ebx
jg     1bb0 <plotCubicBezierSeg+0xa40>
lea    0x0(%r13,%r13,1),%eax
mov    0x118(%rsp),%rdx
cmp    %edx,%eax
mov    %edx,%eax
mov    $0x0,%esi
cmovg  %esi,%eax
mov    %r15d,%ecx
cmovg  %esi,%ecx
add    %ecx,%r8d
lea    (%rbx,%rbx,1),%ecx
cmp    %edx,%ecx
mov    %edx,%ecx
cmovg  %esi,%ecx
mov    %r14d,%edx
cmovg  %esi,%edx
add    %edx,%ebp
ucomisd %xmm12,%xmm6
mov    %r12,%rdx
lea    0x138(%rsp),%rsi
cmova  %rsi,%rdx
ucomisd %xmm3,%xmm12
cmovbe %r12,%rdx
lea    0x8(%rsp),%rsi
cmp    %rsi,%r12
cmove  %rdx,%r12
cmp    0x30(%rsp),%r8d
je     16d5 <plotCubicBezierSeg+0x565>
add    %r13d,%eax
add    %ebx,%ecx
mov    %ecx,%ebx
mov    %eax,%r13d
cmp    0x90(%rsp),%ebp
jne    1b00 <plotCubicBezierSeg+0x990>
jmp    16d5 <plotCubicBezierSeg+0x565>
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r8d,%edx
mov    %ebp,%ecx
call   1070 <plotLine@plt>
add    $0x218,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @plotCubicBezierSeg(i32 %0, i32 %1, float %2, float %3, float %4, float %5, i32 %6, i32 %7) {
%9 = alloca double
%10 = alloca double
%11 = icmp sgt i32 %6, %0
%12 = icmp sgt i32 %7, %1
%13 = insertelement <2 x i1> poison, i1 %12, i64 0
%14 = insertelement <2 x i1> %13, i1 %11, i64 1
%15 = select <2 x i1> %14, <2 x i32> <i32 1, i32 1>, <2 x i32> <i32 -1, i32 -1>
%16 = insertelement <2 x i32> poison, i32 %1, i64 0
%17 = insertelement <2 x i32> %16, i32 %0, i64 1
%18 = sitofp <2 x i32> %17 to <2 x float>
%19 = extractelement <2 x float> %18, i64 1
%20 = fadd float %19, %2
%21 = fsub float %20, %4
%22 = insertelement <2 x i32> poison, i32 %7, i64 0
%23 = insertelement <2 x i32> %22, i32 %6, i64 1
%24 = sitofp <2 x i32> %23 to <2 x float>
%25 = extractelement <2 x float> %24, i64 1
%26 = fsub float %21, %25
%27 = fptosi float %26 to i32
%28 = tail call float @fabs(i32 %27)
%29 = extractelement <2 x float> %18, i64 0
%30 = fadd float %29, %3
%31 = fsub float %30, %5
%32 = extractelement <2 x float> %24, i64 0
%33 = fsub float %31, %32
%34 = fptosi float %33 to i32
%35 = tail call float @fabs(i32 %34)
%36 = insertelement <2 x float> poison, float %35, i64 0
%37 = insertelement <2 x float> %36, float %28, i64 1
%38 = fneg <2 x float> %37
%39 = shl nsw <2 x i32> %15, <i32 2, i32 2>
%40 = sitofp <2 x i32> %39 to <2 x float>
%41 = insertelement <2 x float> poison, float %3, i64 0
%42 = insertelement <2 x float> %41, float %2, i64 1
%43 = insertelement <2 x float> poison, float %5, i64 0
%44 = insertelement <2 x float> %43, float %4, i64 1
%45 = fsub <2 x float> %42, %44
%46 = fneg <2 x float> %40
%47 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %46, <2 x float> %45, <2 x float> %38)
%48 = sitofp <2 x i32> %15 to <2 x float>
%49 = fsub <2 x float> %18, %42
%50 = fsub <2 x float> %49, %44
%51 = fadd <2 x float> %50, %24
%52 = fmul <2 x float> %51, %48
%53 = bitcast double* %9 to i8*
%54 = bitcast double* %10 to i8*
store double 1.000000e-02, double* %10
%55 = fsub float %2, %19
%56 = fsub float %4, %25
%57 = fmul float %55, %56
%58 = fpext float %57 to double
%59 = fcmp olt double %58, 1.000000e-02
br i1 %59, label %60, label %77
60: ; preds = %8
%61 = sub nsw i32 %6, %0
%62 = sitofp i32 %61 to float
%63 = extractelement <2 x float> %45, i64 1
%64 = fmul float %63, %62
%65 = fpext float %64 to double
%66 = fcmp olt double %65, 1.000000e-02
br i1 %66, label %77, label %67
67: ; preds = %60
%68 = fmul <2 x float> %52, %52
%69 = extractelement <2 x float> %68, i64 1
%70 = fpext float %69 to double
%71 = fmul <2 x float> %47, %38
%72 = extractelement <2 x float> %71, i64 1
%73 = fpext float %72 to double
%74 = fadd double %73, 1.000000e-02
%75 = fcmp ogt double %74, %70
%76 = zext i1 %75 to i32
br label %77
77: ; preds = %60, %67, %8
%78 = phi i32 [ 0, %8 ], [ 1, %60 ], [ %76, %67 ]
%79 = tail call i32 @assert(i32 %78)
%80 = fsub float %3, %29
%81 = fsub float %5, %32
%82 = fmul float %80, %81
%83 = fpext float %82 to double
%84 = fcmp olt double %83, 1.000000e-02
br i1 %84, label %85, label %102
85: ; preds = %77
%86 = sub nsw i32 %7, %1
%87 = sitofp i32 %86 to float
%88 = extractelement <2 x float> %45, i64 0
%89 = fmul float %88, %87
%90 = fpext float %89 to double
%91 = fcmp olt double %90, 1.000000e-02
br i1 %91, label %102, label %92
92: ; preds = %85
%93 = fmul <2 x float> %52, %52
%94 = extractelement <2 x float> %93, i64 0
%95 = fpext float %94 to double
%96 = fmul <2 x float> %47, %38
%97 = extractelement <2 x float> %96, i64 0
%98 = fpext float %97 to double
%99 = fadd double %98, 1.000000e-02
%100 = fcmp ogt double %99, %95
%101 = zext i1 %100 to i32
br label %102
102: ; preds = %85, %92, %77
%103 = phi i32 [ 0, %77 ], [ 1, %85 ], [ %101, %92 ]
%104 = tail call i32 @assert(i32 %103)
%105 = extractelement <2 x float> %47, i64 1
%106 = fcmp oeq float %105, 0.000000e+00
%107 = extractelement <2 x float> %47, i64 0
%108 = fcmp oeq float %107, 0.000000e+00
%109 = select i1 %106, i1 %108, i1 false
br i1 %109, label %110, label %123
110: ; preds = %102
%111 = fneg float %19
%112 = tail call float @llvm.fmuladd.f32(float %2, float 3.000000e+00, float %111)
%113 = fadd float %112, 1.000000e+00
%114 = fmul float %113, 5.000000e-01
%115 = fptosi float %114 to i32
%116 = tail call i32 @floor(i32 %115)
%117 = fneg float %29
%118 = tail call float @llvm.fmuladd.f32(float %3, float 3.000000e+00, float %117)
%119 = fadd float %118, 1.000000e+00
%120 = fmul float %119, 5.000000e-01
%121 = fptosi float %120 to i32
%122 = tail call i32 @floor(i32 %121)
tail call void @plotQuadBezierSeg(i32 %0, i32 %1, i32 %116, i32 %122, i32 %6, i32 %7)
br label %391
123: ; preds = %102
%124 = fmul float %80, %80
%125 = tail call float @llvm.fmuladd.f32(float %55, float %55, float %124)
%126 = fmul float %81, %81
%127 = tail call float @llvm.fmuladd.f32(float %56, float %56, float %126)
%128 = fmul float %28, %107
%129 = extractelement <2 x float> %38, i64 0
%130 = call float @llvm.fmuladd.f32(float %105, float %129, float %128)
%131 = fpext float %130 to double
%132 = fmul double %131, %131
%133 = fsub float %105, %107
%134 = fmul float %133, 8.000000e+00
%135 = fpext float %134 to double
%136 = fmul <2 x float> %37, %47
%137 = fmul <2 x float> %47, %47
%138 = fpext <2 x float> %137 to <2 x double>
%139 = fpext <2 x float> %47 to <2 x double>
%140 = fneg <2 x double> %138
%141 = fneg <2 x float> %137
%142 = fmul <2 x float> %47, <float -2.000000e+00, float -2.000000e+00>
%143 = insertelement <2 x double> poison, double %135, i64 0
%144 = shufflevector <2 x double> %143, <2 x double> poison, <2 x i32> zeroinitializer
%145 = fmul <2 x double> %144, %139
%146 = fmul float %105, %107
%147 = fpext float %146 to double
%148 = fpext float %129 to double
%149 = fmul float %107, 6.000000e+00
%150 = fpext float %149 to double
%151 = fmul float %105, -6.000000e+00
%152 = fpext float %151 to double
%153 = extractelement <2 x i32> %15, i64 0
%154 = extractelement <2 x i32> %15, i64 1
%155 = insertelement <2 x double> poison, double %152, i64 0
%156 = shufflevector <2 x double> %155, <2 x double> poison, <2 x i32> zeroinitializer
%157 = insertelement <2 x double> poison, double %150, i64 0
%158 = shufflevector <2 x double> %157, <2 x double> poison, <2 x i32> zeroinitializer
%159 = insertelement <2 x float> poison, float %28, i64 0
%160 = extractelement <2 x double> %138, i64 1
%161 = extractelement <2 x double> %138, i64 0
br label %162
162: ; preds = %379, %123
%163 = phi i32 [ %6, %123 ], [ %381, %379 ]
%164 = phi i32 [ %7, %123 ], [ %380, %379 ]
%165 = phi i32 [ 1, %123 ], [ %385, %379 ]
%166 = phi i32 [ %154, %123 ], [ %382, %379 ]
%167 = phi i32 [ %153, %123 ], [ %383, %379 ]
%168 = phi float [ %125, %123 ], [ %127, %379 ]
%169 = phi i32 [ %1, %123 ], [ %164, %379 ]
%170 = phi i32 [ %0, %123 ], [ %163, %379 ]
%171 = phi <2 x float> [ %52, %123 ], [ %388, %379 ]
%172 = extractelement <2 x float> %171, i64 1
%173 = fneg float %172
%174 = extractelement <2 x float> %171, i64 0
%175 = insertelement <2 x float> %159, float %173, i64 1
%176 = shufflevector <2 x float> %171, <2 x float> %47, <2 x i32> <i32 0, i32 2>
%177 = fmul <2 x float> %175, %176
%178 = shufflevector <2 x float> %171, <2 x float> %47, <2 x i32> <i32 1, i32 3>
%179 = shufflevector <2 x float> %38, <2 x float> %171, <2 x i32> <i32 0, i32 2>
%180 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %178, <2 x float> %179, <2 x float> %177)
%181 = fpext <2 x float> %180 to <2 x double>
%182 = extractelement <2 x double> %181, i64 1
%183 = fadd double %182, %131
%184 = extractelement <2 x double> %181, i64 0
%185 = call double @llvm.fmuladd.f64(double %184, double -3.000000e+00, double %183)
%186 = call double @llvm.fmuladd.f64(double %182, double %185, double %132)
%187 = fcmp ogt double %186, 0.000000e+00
br i1 %187, label %194, label %188
188: ; preds = %162
%189 = fadd float %168, 1.000000e+00
%190 = fdiv float 1.024000e+03, %189
%191 = fadd float %190, 1.000000e+00
%192 = fptosi float %191 to i32
%193 = call i32 @sqrt(i32 %192)
br label %194
194: ; preds = %162, %188
%195 = phi i32 [ %193, %188 ], [ 1, %162 ]
%196 = sitofp i32 %195 to double
%197 = fmul double %131, %196
%198 = insertelement <2 x double> poison, double %196, i64 0
%199 = shufflevector <2 x double> %198, <2 x double> poison, <2 x i32> zeroinitializer
%200 = fmul <2 x double> %199, %181
%201 = mul nsw i32 %195, %195
%202 = sitofp i32 %201 to double
%203 = fmul double %186, %202
%204 = extractelement <2 x double> %200, i64 1
%205 = fadd double %204, %197
%206 = extractelement <2 x double> %200, i64 0
%207 = fadd double %206, %205
%208 = fmul double %207, 9.000000e+00
%209 = fmul double %208, 1.250000e-01
%210 = fmul double %204, 8.000000e+00
%211 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %171, <2 x float> %171, <2 x float> %136)
%212 = fpext <2 x float> %211 to <2 x double>
%213 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %171, <2 x float> <float 2.000000e+00, float 2.000000e+00>, <2 x float> %47)
%214 = fsub <2 x float> %213, %37
%215 = fpext <2 x float> %214 to <2 x double>
%216 = fneg double %203
%217 = insertelement <2 x double> poison, double %203, i64 0
%218 = insertelement <2 x double> %217, double %216, i64 1
%219 = fmul <2 x double> %218, %215
%220 = insertelement <2 x double> poison, double %210, i64 0
%221 = shufflevector <2 x double> %220, <2 x double> poison, <2 x i32> zeroinitializer
%222 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %221, <2 x double> %212, <2 x double> %219)
%223 = fmul <2 x double> %222, <double 2.700000e+01, double 2.700000e+01>
%224 = fmul <2 x double> %223, <double 1.562500e-02, double 1.562500e-02>
%225 = insertelement <2 x double> poison, double %209, i64 0
%226 = shufflevector <2 x double> %225, <2 x double> poison, <2 x i32> zeroinitializer
%227 = fsub <2 x double> %226, %139
%228 = fadd <2 x double> %226, %139
%229 = shufflevector <2 x double> %227, <2 x double> %228, <2 x i32> <i32 0, i32 3>
%230 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %140, <2 x double> %229, <2 x double> %224)
%231 = fmul double %204, 3.000000e+00
%232 = fmul double %197, 3.000000e+00
%233 = fmul <2 x float> %171, <float 3.000000e+00, float 3.000000e+00>
%234 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %233, <2 x float> %171, <2 x float> %141)
%235 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %142, <2 x float> %38, <2 x float> %234)
%236 = fpext <2 x float> %235 to <2 x double>
%237 = fadd <2 x float> %47, %171
%238 = fpext <2 x float> %237 to <2 x double>
%239 = insertelement <2 x double> poison, double %232, i64 0
%240 = shufflevector <2 x double> %239, <2 x double> poison, <2 x i32> zeroinitializer
%241 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %240, <2 x double> %238, <2 x double> %145)
%242 = fneg <2 x double> %241
%243 = fmul <2 x double> %139, %242
%244 = insertelement <2 x double> poison, double %231, i64 0
%245 = shufflevector <2 x double> %244, <2 x double> poison, <2 x i32> zeroinitializer
%246 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %245, <2 x double> %236, <2 x double> %243)
%247 = fmul <2 x double> %246, <double 3.000000e+00, double 3.000000e+00>
%248 = fmul <2 x double> %247, <double 2.500000e-01, double 2.500000e-01>
%249 = fmul double %197, 6.000000e+00
%250 = call double @llvm.fmuladd.f64(double %204, double 6.000000e+00, double %249)
%251 = call double @llvm.fmuladd.f64(double %206, double -3.000000e+00, double %250)
%252 = fadd double %251, %135
%253 = fmul double %252, %147
%254 = mul nsw i32 %195, 9
%255 = sitofp i32 %254 to double
%256 = fpext float %174 to double
%257 = fmul double %160, %256
%258 = fmul <2 x float> %171, %38
%259 = extractelement <2 x float> %258, i64 1
%260 = fpext float %259 to double
%261 = fneg double %260
%262 = fmul double %161, %261
%263 = call double @llvm.fmuladd.f64(double %257, double %148, double %262)
%264 = call double @llvm.fmuladd.f64(double %255, double %263, double %253)
%265 = fmul float %172, 1.800000e+01
%266 = fmul float %265, %174
%267 = fpext float %266 to double
%268 = fneg double %267
%269 = call double @llvm.fmuladd.f64(double %268, double %204, double %264)
%270 = fmul double %269, 3.000000e+00
%271 = fmul double %270, 1.250000e-01
%272 = fcmp olt double %203, 0.000000e+00
br i1 %272, label %273, label %277
273: ; preds = %194
%274 = fneg <2 x double> %230
%275 = fneg <2 x double> %248
%276 = fneg double %271
br label %277
277: ; preds = %273, %194
%278 = phi double [ %276, %273 ], [ %271, %194 ]
%279 = phi <2 x double> [ %140, %273 ], [ %138, %194 ]
%280 = phi <2 x double> [ %275, %273 ], [ %248, %194 ]
%281 = phi <2 x double> [ %274, %273 ], [ %230, %194 ]
store double %278, double* %9
%282 = fmul <2 x double> %279, %158
%283 = fmul <2 x double> %279, %156
%284 = extractelement <2 x double> %281, i64 0
%285 = fadd double %278, %284
%286 = icmp ne i32 %170, %163
%287 = icmp ne i32 %169, %164
%288 = select i1 %286, i1 %287, i1 false
br i1 %288, label %289, label %379
289: ; preds = %277
%290 = extractelement <2 x double> %281, i64 1
%291 = fadd double %278, %290
%292 = fadd double %285, %290
%293 = extractelement <2 x double> %283, i64 0
%294 = extractelement <2 x double> %282, i64 1
br label %295
295: ; preds = %289, %357
%296 = phi double* [ %375, %357 ], [ %9, %289 ]
%297 = phi double [ %352, %357 ], [ %292, %289 ]
%298 = phi double [ %351, %357 ], [ %291, %289 ]
%299 = phi double [ %350, %357 ], [ %285, %289 ]
%300 = phi i32 [ %363, %357 ], [ %170, %289 ]
%301 = phi i32 [ %369, %357 ], [ %169, %289 ]
%302 = phi i32 [ %367, %357 ], [ %195, %289 ]
%303 = phi i32 [ %361, %357 ], [ %195, %289 ]
%304 = phi <2 x double> [ %353, %357 ], [ %280, %289 ]
%305 = call i32 @setPixel(i32 %300, i32 %301)
br label %306
306: ; preds = %348, %295
%307 = phi i32 [ %303, %295 ], [ %333, %348 ]
%308 = phi i32 [ %302, %295 ], [ %349, %348 ]
%309 = phi double [ %299, %295 ], [ %350, %348 ]
%310 = phi double [ %298, %295 ], [ %351, %348 ]
%311 = phi double [ %297, %295 ], [ %352, %348 ]
%312 = phi <2 x double> [ %304, %295 ], [ %353, %348 ]
%313 = load double, double* %296
%314 = fcmp ogt double %309, %313
%315 = fcmp olt double %310, %313
%316 = select i1 %314, i1 true, i1 %315
br i1 %316, label %379, label %317
317: ; preds = %306
%318 = fneg double %310
%319 = call double @llvm.fmuladd.f64(double %311, double 2.000000e+00, double %318)
%320 = fptrunc double %319 to float
%321 = fmul double %311, 2.000000e+00
%322 = fcmp ult double %321, %309
br i1 %322, label %332, label %323
323: ; preds = %317
%324 = add nsw i32 %307, -1
%325 = extractelement <2 x double> %312, i64 0
%326 = fadd double %325, %309
%327 = fadd double %326, %311
%328 = load double, double* %9
%329 = fadd double %293, %328
store double %329, double* %9
%330 = fadd double %310, %329
%331 = fadd <2 x double> %282, %312
br label %332
332: ; preds = %323, %317
%333 = phi i32 [ %324, %323 ], [ %307, %317 ]
%334 = phi double [ %326, %323 ], [ %309, %317 ]
%335 = phi double [ %330, %323 ], [ %310, %317 ]
%336 = phi double [ %327, %323 ], [ %311, %317 ]
%337 = phi <2 x double> [ %331, %323 ], [ %312, %317 ]
%338 = fcmp ugt float %320, 0.000000e+00
br i1 %338, label %348, label %339
339: ; preds = %332
%340 = add nsw i32 %308, -1
%341 = extractelement <2 x double> %337, i64 1
%342 = fadd double %341, %335
%343 = fadd double %336, %342
%344 = load double, double* %9
%345 = fadd double %294, %344
store double %345, double* %9
%346 = fadd double %334, %345
%347 = fadd <2 x double> %283, %337
br label %348
348: ; preds = %332, %339
%349 = phi i32 [ %340, %339 ], [ %308, %332 ]
%350 = phi double [ %346, %339 ], [ %334, %332 ]
%351 = phi double [ %342, %339 ], [ %335, %332 ]
%352 = phi double [ %343, %339 ], [ %336, %332 ]
%353 = phi <2 x double> [ %347, %339 ], [ %337, %332 ]
%354 = icmp sgt i32 %333, 0
%355 = icmp sgt i32 %349, 0
%356 = select i1 %354, i1 %355, i1 false
br i1 %356, label %306, label %357
357: ; preds = %348
%358 = shl nsw i32 %333, 1
%359 = icmp sgt i32 %358, %195
%360 = select i1 %359, i32 0, i32 %195
%361 = add nsw i32 %360, %333
%362 = select i1 %359, i32 0, i32 %166
%363 = add nsw i32 %362, %300
%364 = shl nsw i32 %349, 1
%365 = icmp sgt i32 %364, %195
%366 = select i1 %365, i32 0, i32 %195
%367 = add nsw i32 %366, %349
%368 = select i1 %365, i32 0, i32 %167
%369 = add nsw i32 %368, %301
%370 = icmp eq double* %296, %9
%371 = fcmp olt double %350, 0.000000e+00
%372 = select i1 %370, i1 %371, i1 false
%373 = fcmp ogt double %351, 0.000000e+00
%374 = select i1 %372, i1 %373, i1 false
%375 = select i1 %374, double* %10, double* %296
%376 = icmp ne i32 %363, %163
%377 = icmp ne i32 %369, %164
%378 = select i1 %376, i1 %377, i1 false
br i1 %378, label %295, label %379
379: ; preds = %357, %306, %277
%380 = phi i32 [ %169, %277 ], [ %301, %306 ], [ %369, %357 ]
%381 = phi i32 [ %170, %277 ], [ %300, %306 ], [ %363, %357 ]
%382 = sub nsw i32 0, %166
%383 = sub nsw i32 0, %167
%384 = fneg float %174
%385 = add nsw i32 %165, -1
%386 = icmp eq i32 %165, 0
%387 = insertelement <2 x float> poison, float %384, i64 0
%388 = insertelement <2 x float> %387, float %173, i64 1
br i1 %386, label %389, label %162
389: ; preds = %379
%390 = call i32 @plotLine(i32 %163, i32 %164, i32 %381, i32 %380)
br label %391
391: ; preds = %389, %110
ret void
}