#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*/ drawPixel4WaySymmetricUnclipped(char *, int, int, int, int,
                                                   char);
void vfdlib_drawOutlineEllipseUnclipped(char *buffer, int cX, int cY, int a,
                                        int b, char shade) {
  int d2, deltaS;
  int x = 0;
  int y = b;
  int a_2 = a * a;
  int b_2 = b * b;
  int a2_2 = a_2 << 1;
  int b2_2 = b_2 << 1;
  int a4_2 = a2_2 << 1;
  int b4_2 = b2_2 << 1;
  int a8_2 = a4_2 << 1;
  int b8_2 = b4_2 << 1;
  int a8_2plusb8_2 = a8_2 + b8_2;
  int d1 = b4_2 - (a4_2 * b) + a_2;
  int deltaE = 12 * b_2;
  int deltaSE = deltaE - a8_2 * b + a8_2;
  drawPixel4WaySymmetricUnclipped(buffer, cX, cY, x, y, shade);
  while (a2_2 * y - a_2 > b2_2 * (x + 1)) {
    if (d1 < 0) {
      d1 += deltaE;
      deltaE += b8_2;
      deltaSE += b8_2;
    } else {
      d1 += deltaSE;
      deltaE += b8_2;
      deltaSE += a8_2plusb8_2;
      y--;
    }
    x++;
    drawPixel4WaySymmetricUnclipped(buffer, cX, cY, x, y, shade);
  }
  d2 = (b4_2 * (x * x + x) + b_2) + (a4_2 * (y - 1) * (y - 1)) - (a4_2 * b_2);
  deltaS = a4_2 * (-2 * y + 3);
  deltaSE = b4_2 * (2 * x + 2) + deltaS;
  while (y > 0) {
    if (d2 < 0) {
      d2 += deltaSE;
      deltaSE += a8_2plusb8_2;
      deltaS += a8_2;
      x++;
    } else {
      d2 += deltaS;
      deltaSE += a8_2;
      deltaS += a8_2;
    }
    y--;
    drawPixel4WaySymmetricUnclipped(buffer, cX, cY, x, y, shade);
  }
}


x86 assembly (clang, -O0):
<vfdlib_drawOutlineEllipseUnclipped>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %r9b,%al
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %al,-0x19(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x40(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
imul   $0xc,-0x34(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x48(%rbp),%ecx
imul   -0x18(%rbp),%ecx
sub    %ecx,%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
movsbl -0x19(%rbp),%r9d
call   1030 <drawPixel4WaySymmetricUnclipped@plt>
mov    -0x38(%rbp),%eax
imul   -0x2c(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    -0x3c(%rbp),%ecx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
imul   %edx,%ecx
cmp    %ecx,%eax
jle    126a <vfdlib_drawOutlineEllipseUnclipped+0x15a>
cmpl   $0x0,-0x54(%rbp)
jge    121d <vfdlib_drawOutlineEllipseUnclipped+0x10d>
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
jmp    1241 <vfdlib_drawOutlineEllipseUnclipped+0x131>
mov    -0x5c(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
movsbl -0x19(%rbp),%r9d
call   1030 <drawPixel4WaySymmetricUnclipped@plt>
jmp    11d5 <vfdlib_drawOutlineEllipseUnclipped+0xc5>
mov    -0x44(%rbp),%eax
mov    -0x28(%rbp),%ecx
imul   -0x28(%rbp),%ecx
add    -0x28(%rbp),%ecx
imul   %ecx,%eax
add    -0x34(%rbp),%eax
mov    -0x40(%rbp),%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    -0x40(%rbp),%ecx
imul   -0x34(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x40(%rbp),%eax
imul   $0xfffffffe,-0x2c(%rbp),%ecx
add    $0x3,%ecx
imul   %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    $0x2,%ecx
imul   %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jle    1349 <vfdlib_drawOutlineEllipseUnclipped+0x239>
cmpl   $0x0,-0x20(%rbp)
jge    1305 <vfdlib_drawOutlineEllipseUnclipped+0x1f5>
mov    -0x5c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x50(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x48(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1320 <vfdlib_drawOutlineEllipseUnclipped+0x210>
mov    -0x24(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x48(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x48(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
movsbl -0x19(%rbp),%r9d
call   1030 <drawPixel4WaySymmetricUnclipped@plt>
jmp    12c8 <vfdlib_drawOutlineEllipseUnclipped+0x1b8>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<vfdlib_drawOutlineEllipseUnclipped>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8d,%r14d
mov    %ecx,%r15d
imul   %r15d,%r15d
mov    %r8d,%ebp
imul   %ebp,%ebp
lea    (%r15,%r15,1),%ebx
lea    0x0(%rbp,%rbp,1),%eax
mov    %eax,0x4(%rsp)
lea    0x0(,%r15,4),%eax
mov    %eax,0x10(%rsp)
lea    0x0(,%rbp,4),%eax
mov    %rax,0x38(%rsp)
lea    0x0(,%r15,8),%r12d
lea    (%r12,%rbp,8),%eax
mov    %eax,(%rsp)
mov    %rdi,0x30(%rsp)
mov    %esi,0xc(%rsp)
mov    %edx,0x8(%rsp)
xor    %ecx,%ecx
mov    %r9d,%r13d
call   1030 <drawPixel4WaySymmetricUnclipped@plt>
mov    %ebx,%edx
mov    %r14,%rbx
mov    %edx,%eax
imul   %ebx,%eax
mov    %r15,0x40(%rsp)
sub    %r15d,%eax
movsbl %r13b,%ecx
mov    %ecx,0x14(%rsp)
cmp    0x4(%rsp),%eax
mov    %r12,0x48(%rsp)
mov    %rbp,0x50(%rsp)
jle    126a <vfdlib_drawOutlineEllipseUnclipped+0x15a>
lea    0x0(,%rbp,8),%eax
mov    %eax,0x24(%rsp)
mov    0x38(%rsp),%rcx
lea    (%rcx,%rcx,2),%ebp
lea    (%r12,%rbp,1),%edi
mov    %r12d,%eax
imul   %ebx,%eax
sub    %eax,%edi
mov    0x40(%rsp),%rax
lea    (%rcx,%rax,1),%r15d
mov    0x10(%rsp),%eax
imul   %ebx,%eax
sub    %eax,%r15d
xor    %ecx,%ecx
mov    0x4(%rsp),%r13d
mov    0xc(%rsp),%r12d
mov    0x30(%rsp),%r14
mov    (%rsp),%r11d
mov    %edx,0x28(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%ecx
mov    %rcx,0x18(%rsp)
mov    %r15d,%eax
not    %eax
sar    $0x1f,%eax
add    %eax,%ebx
test   %r15d,%r15d
mov    %edi,%eax
cmovs  %ebp,%eax
mov    %r11d,%edx
mov    0x24(%rsp),%esi
cmovs  %esi,%edx
add    %edx,%edi
mov    %edi,0x2c(%rsp)
add    %esi,%ebp
add    %eax,%r15d
mov    %r14,%rdi
mov    %r12d,%esi
mov    0x8(%rsp),%edx
mov    %ebx,%r8d
mov    0x14(%rsp),%r9d
call   1030 <drawPixel4WaySymmetricUnclipped@plt>
mov    0x2c(%rsp),%edi
mov    0x28(%rsp),%eax
mov    (%rsp),%r11d
mov    0x18(%rsp),%rcx
imul   %ebx,%eax
sub    0x40(%rsp),%eax
add    0x4(%rsp),%r13d
cmp    %r13d,%eax
jg     1200 <vfdlib_drawOutlineEllipseUnclipped+0xf0>
jmp    127a <vfdlib_drawOutlineEllipseUnclipped+0x16a>
mov    0xc(%rsp),%r12d
mov    0x30(%rsp),%r14
mov    (%rsp),%r11d
xor    %ecx,%ecx
test   %ebx,%ebx
mov    0x8(%rsp),%edx
mov    0x48(%rsp),%r9
jle    1334 <vfdlib_drawOutlineEllipseUnclipped+0x224>
mov    $0x3,%ebp
sub    %ebx,%ebp
sub    %ebx,%ebp
mov    0x10(%rsp),%r8d
imul   %r8d,%ebp
lea    (%rcx,%rcx,1),%r15d
add    $0x2,%r15d
mov    0x38(%rsp),%rsi
imul   %esi,%r15d
add    %ebp,%r15d
mov    %ecx,%eax
imul   %ecx,%eax
add    %ecx,%eax
imul   %esi,%eax
mov    0x50(%rsp),%rsi
add    %esi,%eax
lea    -0x1(%rbx),%r13d
imul   %r13d,%r13d
sub    %esi,%r13d
imul   %r8d,%r13d
add    %eax,%r13d
add    $0x1,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r13d,%eax
shr    $0x1f,%eax
add    %eax,%ecx
mov    %rcx,0x18(%rsp)
test   %r13d,%r13d
mov    %ebp,%eax
cmovs  %r15d,%eax
mov    %r9d,%esi
cmovs  %r11d,%esi
add    %esi,%r15d
add    %eax,%r13d
add    %r9d,%ebp
lea    -0x2(%rbx),%r8d
mov    %r14,%rdi
mov    %r12d,%esi
mov    0x14(%rsp),%r9d
call   1030 <drawPixel4WaySymmetricUnclipped@plt>
mov    0x48(%rsp),%r9
mov    0x8(%rsp),%edx
mov    (%rsp),%r11d
mov    0x18(%rsp),%rcx
add    $0xffffffff,%ebx
cmp    $0x1,%ebx
ja     12e0 <vfdlib_drawOutlineEllipseUnclipped+0x1d0>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @vfdlib_drawOutlineEllipseUnclipped(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i8 signext %5) {
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
store i8* %0, i8** %7
store i32 %1, i32* %8
store i32 %2, i32* %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i8 %5, i8* %12
store i32 0, i32* %15
%29 = load i32, i32* %11
store i32 %29, i32* %16
%30 = load i32, i32* %10
%31 = load i32, i32* %10
%32 = mul nsw i32 %30, %31
store i32 %32, i32* %17
%33 = load i32, i32* %11
%34 = load i32, i32* %11
%35 = mul nsw i32 %33, %34
store i32 %35, i32* %18
%36 = load i32, i32* %17
%37 = shl i32 %36, 1
store i32 %37, i32* %19
%38 = load i32, i32* %18
%39 = shl i32 %38, 1
store i32 %39, i32* %20
%40 = load i32, i32* %19
%41 = shl i32 %40, 1
store i32 %41, i32* %21
%42 = load i32, i32* %20
%43 = shl i32 %42, 1
store i32 %43, i32* %22
%44 = load i32, i32* %21
%45 = shl i32 %44, 1
store i32 %45, i32* %23
%46 = load i32, i32* %22
%47 = shl i32 %46, 1
store i32 %47, i32* %24
%48 = load i32, i32* %23
%49 = load i32, i32* %24
%50 = add nsw i32 %48, %49
store i32 %50, i32* %25
%51 = load i32, i32* %22
%52 = load i32, i32* %21
%53 = load i32, i32* %11
%54 = mul nsw i32 %52, %53
%55 = sub nsw i32 %51, %54
%56 = load i32, i32* %17
%57 = add nsw i32 %55, %56
store i32 %57, i32* %26
%58 = load i32, i32* %18
%59 = mul nsw i32 12, %58
store i32 %59, i32* %27
%60 = load i32, i32* %27
%61 = load i32, i32* %23
%62 = load i32, i32* %11
%63 = mul nsw i32 %61, %62
%64 = sub nsw i32 %60, %63
%65 = load i32, i32* %23
%66 = add nsw i32 %64, %65
store i32 %66, i32* %28
%67 = load i8*, i8** %7
%68 = load i32, i32* %8
%69 = load i32, i32* %9
%70 = load i32, i32* %15
%71 = load i32, i32* %16
%72 = load i8, i8* %12
%73 = call i32 @drawPixel4WaySymmetricUnclipped(i8* %67, i32 %68, i32 %69, i32 %70, i32 %71, i8 signext %72)
br label %74
74: ; preds = %110, %6
%75 = load i32, i32* %19
%76 = load i32, i32* %16
%77 = mul nsw i32 %75, %76
%78 = load i32, i32* %17
%79 = sub nsw i32 %77, %78
%80 = load i32, i32* %20
%81 = load i32, i32* %15
%82 = add nsw i32 %81, 1
%83 = mul nsw i32 %80, %82
%84 = icmp sgt i32 %79, %83
br i1 %84, label %85, label %120
85: ; preds = %74
%86 = load i32, i32* %26
%87 = icmp slt i32 %86, 0
br i1 %87, label %88, label %98
88: ; preds = %85
%89 = load i32, i32* %27
%90 = load i32, i32* %26
%91 = add nsw i32 %90, %89
store i32 %91, i32* %26
%92 = load i32, i32* %24
%93 = load i32, i32* %27
%94 = add nsw i32 %93, %92
store i32 %94, i32* %27
%95 = load i32, i32* %24
%96 = load i32, i32* %28
%97 = add nsw i32 %96, %95
store i32 %97, i32* %28
br label %110
98: ; preds = %85
%99 = load i32, i32* %28
%100 = load i32, i32* %26
%101 = add nsw i32 %100, %99
store i32 %101, i32* %26
%102 = load i32, i32* %24
%103 = load i32, i32* %27
%104 = add nsw i32 %103, %102
store i32 %104, i32* %27
%105 = load i32, i32* %25
%106 = load i32, i32* %28
%107 = add nsw i32 %106, %105
store i32 %107, i32* %28
%108 = load i32, i32* %16
%109 = add nsw i32 %108, -1
store i32 %109, i32* %16
br label %110
110: ; preds = %98, %88
%111 = load i32, i32* %15
%112 = add nsw i32 %111, 1
store i32 %112, i32* %15
%113 = load i8*, i8** %7
%114 = load i32, i32* %8
%115 = load i32, i32* %9
%116 = load i32, i32* %15
%117 = load i32, i32* %16
%118 = load i8, i8* %12
%119 = call i32 @drawPixel4WaySymmetricUnclipped(i8* %113, i32 %114, i32 %115, i32 %116, i32 %117, i8 signext %118)
br label %74
120: ; preds = %74
%121 = load i32, i32* %22
%122 = load i32, i32* %15
%123 = load i32, i32* %15
%124 = mul nsw i32 %122, %123
%125 = load i32, i32* %15
%126 = add nsw i32 %124, %125
%127 = mul nsw i32 %121, %126
%128 = load i32, i32* %18
%129 = add nsw i32 %127, %128
%130 = load i32, i32* %21
%131 = load i32, i32* %16
%132 = sub nsw i32 %131, 1
%133 = mul nsw i32 %130, %132
%134 = load i32, i32* %16
%135 = sub nsw i32 %134, 1
%136 = mul nsw i32 %133, %135
%137 = add nsw i32 %129, %136
%138 = load i32, i32* %21
%139 = load i32, i32* %18
%140 = mul nsw i32 %138, %139
%141 = sub nsw i32 %137, %140
store i32 %141, i32* %13
%142 = load i32, i32* %21
%143 = load i32, i32* %16
%144 = mul nsw i32 -2, %143
%145 = add nsw i32 %144, 3
%146 = mul nsw i32 %142, %145
store i32 %146, i32* %14
%147 = load i32, i32* %22
%148 = load i32, i32* %15
%149 = mul nsw i32 2, %148
%150 = add nsw i32 %149, 2
%151 = mul nsw i32 %147, %150
%152 = load i32, i32* %14
%153 = add nsw i32 %151, %152
store i32 %153, i32* %28
br label %154
154: ; preds = %182, %120
%155 = load i32, i32* %16
%156 = icmp sgt i32 %155, 0
br i1 %156, label %157, label %192
157: ; preds = %154
%158 = load i32, i32* %13
%159 = icmp slt i32 %158, 0
br i1 %159, label %160, label %172
160: ; preds = %157
%161 = load i32, i32* %28
%162 = load i32, i32* %13
%163 = add nsw i32 %162, %161
store i32 %163, i32* %13
%164 = load i32, i32* %25
%165 = load i32, i32* %28
%166 = add nsw i32 %165, %164
store i32 %166, i32* %28
%167 = load i32, i32* %23
%168 = load i32, i32* %14
%169 = add nsw i32 %168, %167
store i32 %169, i32* %14
%170 = load i32, i32* %15
%171 = add nsw i32 %170, 1
store i32 %171, i32* %15
br label %182
172: ; preds = %157
%173 = load i32, i32* %14
%174 = load i32, i32* %13
%175 = add nsw i32 %174, %173
store i32 %175, i32* %13
%176 = load i32, i32* %23
%177 = load i32, i32* %28
%178 = add nsw i32 %177, %176
store i32 %178, i32* %28
%179 = load i32, i32* %23
%180 = load i32, i32* %14
%181 = add nsw i32 %180, %179
store i32 %181, i32* %14
br label %182
182: ; preds = %172, %160
%183 = load i32, i32* %16
%184 = add nsw i32 %183, -1
store i32 %184, i32* %16
%185 = load i8*, i8** %7
%186 = load i32, i32* %8
%187 = load i32, i32* %9
%188 = load i32, i32* %15
%189 = load i32, i32* %16
%190 = load i8, i8* %12
%191 = call i32 @drawPixel4WaySymmetricUnclipped(i8* %185, i32 %186, i32 %187, i32 %188, i32 %189, i8 signext %190)
br label %154
192: ; preds = %154
ret void
}

LLVM IR (-O2):
define void @vfdlib_drawOutlineEllipseUnclipped(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i8 signext %5) {
%7 = mul nsw i32 %3, %3
%8 = mul nsw i32 %4, %4
%9 = shl nuw i32 %7, 1
%10 = shl nuw i32 %8, 1
%11 = shl i32 %7, 2
%12 = shl i32 %8, 2
%13 = shl i32 %7, 3
%14 = shl i32 %8, 3
%15 = add nsw i32 %14, %13
%16 = mul nsw i32 %8, 12
%17 = tail call i32 @drawPixel4WaySymmetricUnclipped(i8* %0, i32 %1, i32 %2, i32 0, i32 %4, i8 signext %5)
%18 = mul nsw i32 %9, %4
%19 = sub nsw i32 %18, %7
%20 = icmp sgt i32 %19, %10
br i1 %20, label %21, label %49
21: ; preds = %6
%22 = add i32 %16, %13
%23 = mul nsw i32 %13, %4
%24 = sub i32 %22, %23
%25 = add i32 %12, %7
%26 = mul nsw i32 %11, %4
%27 = sub i32 %25, %26
br label %28
28: ; preds = %21, %28
%29 = phi i32 [ %46, %28 ], [ 1, %21 ]
%30 = phi i32 [ %40, %28 ], [ %24, %21 ]
%31 = phi i32 [ %41, %28 ], [ %16, %21 ]
%32 = phi i32 [ %42, %28 ], [ %27, %21 ]
%33 = phi i32 [ %37, %28 ], [ %4, %21 ]
%34 = icmp slt i32 %32, 0
%35 = xor i1 %34, true
%36 = sext i1 %35 to i32
%37 = add nsw i32 %33, %36
%38 = select i1 %34, i32 %31, i32 %30
%39 = select i1 %34, i32 %14, i32 %15
%40 = add nsw i32 %30, %39
%41 = add nsw i32 %31, %14
%42 = add nsw i32 %38, %32
%43 = tail call i32 @drawPixel4WaySymmetricUnclipped(i8* %0, i32 %1, i32 %2, i32 %29, i32 %37, i8 signext %5)
%44 = mul nsw i32 %9, %37
%45 = sub nsw i32 %44, %7
%46 = add nuw nsw i32 %29, 1
%47 = mul nsw i32 %10, %46
%48 = icmp sgt i32 %45, %47
br i1 %48, label %28, label %49
49: ; preds = %28, %6
%50 = phi i32 [ %4, %6 ], [ %37, %28 ]
%51 = phi i32 [ 0, %6 ], [ %29, %28 ]
%52 = mul nsw i32 %50, -2
%53 = add nsw i32 %52, 3
%54 = mul nsw i32 %53, %11
%55 = icmp sgt i32 %50, 0
br i1 %55, label %56, label %87
56: ; preds = %49
%57 = shl nuw nsw i32 %51, 1
%58 = add nuw nsw i32 %57, 2
%59 = mul nsw i32 %58, %12
%60 = add nsw i32 %59, %54
%61 = mul nsw i32 %51, %51
%62 = add nuw nsw i32 %61, %51
%63 = mul nsw i32 %62, %12
%64 = add i32 %63, %8
%65 = add nsw i32 %50, -1
%66 = mul i32 %65, %65
%67 = sub i32 %66, %8
%68 = mul i32 %67, %11
%69 = add i32 %64, %68
br label %70
70: ; preds = %56, %70
%71 = phi i32 [ %81, %70 ], [ %60, %56 ]
%72 = phi i32 [ %82, %70 ], [ %69, %56 ]
%73 = phi i32 [ %83, %70 ], [ %54, %56 ]
%74 = phi i32 [ %78, %70 ], [ %51, %56 ]
%75 = phi i32 [ %84, %70 ], [ %50, %56 ]
%76 = icmp slt i32 %72, 0
%77 = lshr i32 %72, 31
%78 = add nuw nsw i32 %77, %74
%79 = select i1 %76, i32 %71, i32 %73
%80 = select i1 %76, i32 %15, i32 %13
%81 = add nsw i32 %80, %71
%82 = add nsw i32 %79, %72
%83 = add nsw i32 %73, %13
%84 = add nsw i32 %75, -1
%85 = tail call i32 @drawPixel4WaySymmetricUnclipped(i8* %0, i32 %1, i32 %2, i32 %78, i32 %84, i8 signext %5)
%86 = icmp ugt i32 %75, 1
br i1 %86, label %70, label %87
87: ; preds = %70, %49
ret void
}