#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*/ setPixel(int, int);
void plotOptimizedEllipse(int xm, int ym, int a, int b) {
  long x = -a, y = 0;
  long e2 = b, dx = (1 + 2 * x) * e2 * e2;
  long dy = x * x, err = dx + dy;
  do {
    setPixel(xm - x, ym + y);
    setPixel(xm + x, ym + y);
    setPixel(xm + x, ym - y);
    setPixel(xm - x, ym - y);
    e2 = 2 * err;
    if (e2 >= dx) {
      x++;
      err += dx += 2 * (long)b * b;
    }
    if (e2 <= dy) {
      y++;
      err += dy += 2 * (long)a * a;
    }
  } while (x <= 0);
  while (y++ < b) {
    setPixel(xm, ym + y);
    setPixel(xm, ym - y);
  }
}


x86 assembly (clang, -O0):
<plotOptimizedEllipse>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
xor    %eax,%eax
sub    -0xc(%rbp),%eax
cltq
mov    %rax,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movslq -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
imul   -0x28(%rbp),%rax
imul   -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
imul   -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
movslq -0x4(%rbp),%rax
sub    -0x18(%rbp),%rax
mov    %eax,%edi
movslq -0x8(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %eax,%esi
call   1030 <setPixel@plt>
movslq -0x4(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %eax,%edi
movslq -0x8(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %eax,%esi
call   1030 <setPixel@plt>
movslq -0x4(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %eax,%edi
movslq -0x8(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %eax,%esi
call   1030 <setPixel@plt>
movslq -0x4(%rbp),%rax
sub    -0x18(%rbp),%rax
mov    %eax,%edi
movslq -0x8(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %eax,%esi
call   1030 <setPixel@plt>
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jl     121c <plotOptimizedEllipse+0x10c>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x1,%rax
movslq -0x10(%rbp),%rcx
imul   %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x38(%rbp),%rax
jg     1256 <plotOptimizedEllipse+0x146>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x1,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
add    -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    125b <plotOptimizedEllipse+0x14b>
cmpq   $0x0,-0x18(%rbp)
jle    1172 <plotOptimizedEllipse+0x62>
jmp    126b <plotOptimizedEllipse+0x15b>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
movslq -0x10(%rbp),%rcx
cmp    %rcx,%rax
jge    12b0 <plotOptimizedEllipse+0x1a0>
mov    -0x4(%rbp),%edi
movslq -0x8(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %eax,%esi
call   1030 <setPixel@plt>
mov    -0x4(%rbp),%edi
movslq -0x8(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %eax,%esi
call   1030 <setPixel@plt>
jmp    126b <plotOptimizedEllipse+0x15b>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<plotOptimizedEllipse>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rsi,0x10(%rsp)
mov    %edi,%r15d
movslq %edx,%rsi
neg    %edx
movslq %edx,%rdi
movslq %ecx,%rcx
lea    (%rdi,%rdi,1),%rax
add    $0x1,%rax
mov    %rcx,0x18(%rsp)
mov    %rcx,%rdx
imul   %rcx,%rdx
imul   %rdx,%rax
mov    %rdi,%rcx
imul   %rdi,%rcx
lea    (%rax,%rcx,1),%r14
add    %rdx,%rdx
mov    %rdx,0x20(%rsp)
imul   %rsi,%rsi
add    %rsi,%rsi
mov    %rsi,0x28(%rsp)
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %rax,0x40(%rsp)
mov    %rdi,0x8(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rdx,0x30(%rsp)
mov    %r15d,%ebx
sub    %edi,%ebx
mov    0x10(%rsp),%rbp
lea    (%rdx,%rbp,1),%r12d
mov    %ebx,%edi
mov    %r12d,%esi
call   1030 <setPixel@plt>
mov    0x8(%rsp),%rax
lea    (%rax,%r15,1),%r13d
mov    %r13d,%edi
mov    %r12d,%esi
call   1030 <setPixel@plt>
mov    0x30(%rsp),%r12
sub    %r12d,%ebp
mov    %r13d,%edi
mov    %ebp,%esi
call   1030 <setPixel@plt>
mov    %ebx,%edi
mov    %ebp,%esi
call   1030 <setPixel@plt>
mov    0x38(%rsp),%rbx
mov    0x40(%rsp),%rax
lea    (%r14,%r14,1),%rbp
mov    0x20(%rsp),%rcx
lea    (%rax,%rcx,1),%rsi
xor    %edi,%edi
cmp    %rax,%rbp
setge  %dil
cmovge %rsi,%rax
mov    $0x0,%r8d
cmovl  %r8,%rsi
add    %r14,%rsi
mov    0x28(%rsp),%rcx
lea    (%rbx,%rcx,1),%r14
xor    %edx,%edx
cmp    %rbx,%rbp
mov    %r14,%rcx
cmovg  %rbx,%rcx
cmovg  %r8,%r14
setle  %dl
add    %r12,%rdx
add    %rsi,%r14
add    %rdi,0x8(%rsp)
mov    0x8(%rsp),%rdi
jle    1170 <plotOptimizedEllipse+0x60>
mov    0x18(%rsp),%r14
cmp    %r14,%rdx
jge    1290 <plotOptimizedEllipse+0x180>
cmp    %rbx,%rbp
setg   %al
add    $0x1,%al
movzbl %al,%eax
mov    %eax,%ecx
and    $0x1,%ecx
add    %r12,%rcx
sub    %rcx,%r14
and    $0x1,%eax
mov    0x10(%rsp),%rdx
mov    %edx,%ecx
sub    %eax,%ecx
mov    %r12d,%ebp
not    %ebp
add    %ecx,%ebp
add    %edx,%eax
lea    (%r12,%rax,1),%ebx
add    $0x1,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r15d,%edi
mov    %ebx,%esi
call   1030 <setPixel@plt>
mov    %r15d,%edi
mov    %ebp,%esi
call   1030 <setPixel@plt>
add    $0xffffffff,%ebp
add    $0x1,%ebx
add    $0xffffffffffffffff,%r14
jne    1270 <plotOptimizedEllipse+0x160>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @plotOptimizedEllipse(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
store i32 %0, i32* %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%15 = load i32, i32* %7
%16 = sub nsw i32 0, %15
%17 = sext i32 %16 to i64
store i64 %17, i64* %9
store i64 0, i64* %10
%18 = load i32, i32* %8
%19 = sext i32 %18 to i64
store i64 %19, i64* %11
%20 = load i64, i64* %9
%21 = mul nsw i64 2, %20
%22 = add nsw i64 1, %21
%23 = load i64, i64* %11
%24 = mul nsw i64 %22, %23
%25 = load i64, i64* %11
%26 = mul nsw i64 %24, %25
store i64 %26, i64* %12
%27 = load i64, i64* %9
%28 = load i64, i64* %9
%29 = mul nsw i64 %27, %28
store i64 %29, i64* %13
%30 = load i64, i64* %12
%31 = load i64, i64* %13
%32 = add nsw i64 %30, %31
store i64 %32, i64* %14
br label %33
33: ; preds = %114, %4
%34 = load i32, i32* %5
%35 = sext i32 %34 to i64
%36 = load i64, i64* %9
%37 = sub nsw i64 %35, %36
%38 = trunc i64 %37 to i32
%39 = load i32, i32* %6
%40 = sext i32 %39 to i64
%41 = load i64, i64* %10
%42 = add nsw i64 %40, %41
%43 = trunc i64 %42 to i32
%44 = call i32 @setPixel(i32 %38, i32 %43)
%45 = load i32, i32* %5
%46 = sext i32 %45 to i64
%47 = load i64, i64* %9
%48 = add nsw i64 %46, %47
%49 = trunc i64 %48 to i32
%50 = load i32, i32* %6
%51 = sext i32 %50 to i64
%52 = load i64, i64* %10
%53 = add nsw i64 %51, %52
%54 = trunc i64 %53 to i32
%55 = call i32 @setPixel(i32 %49, i32 %54)
%56 = load i32, i32* %5
%57 = sext i32 %56 to i64
%58 = load i64, i64* %9
%59 = add nsw i64 %57, %58
%60 = trunc i64 %59 to i32
%61 = load i32, i32* %6
%62 = sext i32 %61 to i64
%63 = load i64, i64* %10
%64 = sub nsw i64 %62, %63
%65 = trunc i64 %64 to i32
%66 = call i32 @setPixel(i32 %60, i32 %65)
%67 = load i32, i32* %5
%68 = sext i32 %67 to i64
%69 = load i64, i64* %9
%70 = sub nsw i64 %68, %69
%71 = trunc i64 %70 to i32
%72 = load i32, i32* %6
%73 = sext i32 %72 to i64
%74 = load i64, i64* %10
%75 = sub nsw i64 %73, %74
%76 = trunc i64 %75 to i32
%77 = call i32 @setPixel(i32 %71, i32 %76)
%78 = load i64, i64* %14
%79 = mul nsw i64 2, %78
store i64 %79, i64* %11
%80 = load i64, i64* %11
%81 = load i64, i64* %12
%82 = icmp sge i64 %80, %81
br i1 %82, label %83, label %96
83: ; preds = %33
%84 = load i64, i64* %9
%85 = add nsw i64 %84, 1
store i64 %85, i64* %9
%86 = load i32, i32* %8
%87 = sext i32 %86 to i64
%88 = mul nsw i64 2, %87
%89 = load i32, i32* %8
%90 = sext i32 %89 to i64
%91 = mul nsw i64 %88, %90
%92 = load i64, i64* %12
%93 = add nsw i64 %92, %91
store i64 %93, i64* %12
%94 = load i64, i64* %14
%95 = add nsw i64 %94, %93
store i64 %95, i64* %14
br label %96
96: ; preds = %83, %33
%97 = load i64, i64* %11
%98 = load i64, i64* %13
%99 = icmp sle i64 %97, %98
br i1 %99, label %100, label %113
100: ; preds = %96
%101 = load i64, i64* %10
%102 = add nsw i64 %101, 1
store i64 %102, i64* %10
%103 = load i32, i32* %7
%104 = sext i32 %103 to i64
%105 = mul nsw i64 2, %104
%106 = load i32, i32* %7
%107 = sext i32 %106 to i64
%108 = mul nsw i64 %105, %107
%109 = load i64, i64* %13
%110 = add nsw i64 %109, %108
store i64 %110, i64* %13
%111 = load i64, i64* %14
%112 = add nsw i64 %111, %110
store i64 %112, i64* %14
br label %113
113: ; preds = %100, %96
br label %114
114: ; preds = %113
%115 = load i64, i64* %9
%116 = icmp sle i64 %115, 0
br i1 %116, label %33, label %117
117: ; preds = %114
br label %118
118: ; preds = %124, %117
%119 = load i64, i64* %10
%120 = add nsw i64 %119, 1
store i64 %120, i64* %10
%121 = load i32, i32* %8
%122 = sext i32 %121 to i64
%123 = icmp slt i64 %119, %122
br i1 %123, label %124, label %139
124: ; preds = %118
%125 = load i32, i32* %5
%126 = load i32, i32* %6
%127 = sext i32 %126 to i64
%128 = load i64, i64* %10
%129 = add nsw i64 %127, %128
%130 = trunc i64 %129 to i32
%131 = call i32 @setPixel(i32 %125, i32 %130)
%132 = load i32, i32* %5
%133 = load i32, i32* %6
%134 = sext i32 %133 to i64
%135 = load i64, i64* %10
%136 = sub nsw i64 %134, %135
%137 = trunc i64 %136 to i32
%138 = call i32 @setPixel(i32 %132, i32 %137)
br label %118
139: ; preds = %118
ret void
}

LLVM IR (-O2):
define void @plotOptimizedEllipse(i32 %0, i32 %1, i32 %2, i32 %3) {
%5 = sub nsw i32 0, %2
%6 = sext i32 %5 to i64
%7 = sext i32 %3 to i64
%8 = shl nsw i64 %6, 1
%9 = or i64 %8, 1
%10 = mul nsw i64 %7, %7
%11 = mul i64 %10, %9
%12 = mul nsw i64 %6, %6
%13 = add nsw i64 %11, %12
%14 = shl nsw i64 %7, 1
%15 = mul nsw i64 %14, %7
%16 = sext i32 %2 to i64
%17 = shl nsw i64 %16, 1
%18 = mul nsw i64 %17, %16
br label %19
19: ; preds = %19, %4
%20 = phi i64 [ %6, %4 ], [ %40, %19 ]
%21 = phi i64 [ 0, %4 ], [ %48, %19 ]
%22 = phi i64 [ %11, %4 ], [ %41, %19 ]
%23 = phi i64 [ %12, %4 ], [ %49, %19 ]
%24 = phi i64 [ %13, %4 ], [ %51, %19 ]
%25 = trunc i64 %20 to i32
%26 = sub i32 %0, %25
%27 = trunc i64 %21 to i32
%28 = add i32 %27, %1
%29 = tail call i32 @setPixel(i32 %26, i32 %28)
%30 = add i32 %25, %0
%31 = tail call i32 @setPixel(i32 %30, i32 %28)
%32 = sub i32 %1, %27
%33 = tail call i32 @setPixel(i32 %30, i32 %32)
%34 = tail call i32 @setPixel(i32 %26, i32 %32)
%35 = shl nsw i64 %24, 1
%36 = icmp slt i64 %35, %22
%37 = add nsw i64 %22, %15
%38 = xor i1 %36, true
%39 = zext i1 %38 to i64
%40 = add nsw i64 %20, %39
%41 = select i1 %36, i64 %22, i64 %37
%42 = select i1 %36, i64 0, i64 %37
%43 = add nsw i64 %24, %42
%44 = icmp sgt i64 %35, %23
%45 = add nsw i64 %23, %18
%46 = xor i1 %44, true
%47 = zext i1 %46 to i64
%48 = add nuw nsw i64 %21, %47
%49 = select i1 %44, i64 %23, i64 %45
%50 = select i1 %44, i64 0, i64 %45
%51 = add nsw i64 %43, %50
%52 = icmp slt i64 %40, 1
br i1 %52, label %19, label %53
53: ; preds = %19
%54 = icmp slt i64 %48, %7
br i1 %54, label %55, label %64
55: ; preds = %53, %55
%56 = phi i64 [ %57, %55 ], [ %48, %53 ]
%57 = add nuw nsw i64 %56, 1
%58 = trunc i64 %57 to i32
%59 = add i32 %58, %1
%60 = tail call i32 @setPixel(i32 %0, i32 %59)
%61 = sub i32 %1, %58
%62 = tail call i32 @setPixel(i32 %0, i32 %61)
%63 = icmp eq i64 %57, %7
br i1 %63, label %64, label %55
64: ; preds = %55, %53
ret void
}