#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);
int floor(int);
void plotEllipseRect(int, int, int, int);
int /*<<< orphan*/ plotQuadRationalBezierSeg(int, int, int, int, int, int,
                                             float);
void plotRotatedEllipseRect(int x0, int y0, int x1, int y1, long zd) {
  int xd = x1 - x0, yd = y1 - y0;
  float w = xd * (long)yd;
  if (zd == 0)
    return plotEllipseRect(x0, y0, x1, y1);
  if (w != 0.0)
    w = (w - zd) / (w + w);
  assert(w <= 1.0 && w >= 0.0);
  xd = floor(xd * w + 0.5);
  yd = floor(yd * w + 0.5);
  plotQuadRationalBezierSeg(x0, y0 + yd, x0, y0, x0 + xd, y0, 1.0 - w);
  plotQuadRationalBezierSeg(x0, y0 + yd, x0, y1, x1 - xd, y1, w);
  plotQuadRationalBezierSeg(x1, y1 - yd, x1, y1, x1 - xd, y1, 1.0 - w);
  plotQuadRationalBezierSeg(x1, y1 - yd, x1, y0, x0 + xd, y0, w);
}


x86 assembly (clang, -O0):
<plotRotatedEllipseRect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x20(%rbp)
movslq -0x1c(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   %rcx,%rax
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0x24(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    11a1 <plotRotatedEllipseRect+0x61>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1050 <plotEllipseRect@plt>
jmp    132f <plotRotatedEllipseRect+0x1ef>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11c2 <plotRotatedEllipseRect+0x82>
jp     11c2 <plotRotatedEllipseRect+0x82>
jmp    11e4 <plotRotatedEllipseRect+0xa4>
movss  -0x24(%rbp),%xmm0
cvtsi2ssq -0x18(%rbp),%xmm1
subss  %xmm1,%xmm0
movss  -0x24(%rbp),%xmm1
addss  -0x24(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
xor    %eax,%eax
movsd  0xe09(%rip),%xmm0
ucomisd %xmm1,%xmm0
mov    %al,-0x25(%rbp)
jb     121a <plotRotatedEllipseRect+0xda>
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
setae  %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
cvtsi2ssl -0x1c(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xdcb(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <floor@plt>
mov    %eax,-0x1c(%rbp)
cvtsi2ssl -0x20(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xda5(%rip),%xmm1
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%edi
call   1060 <floor@plt>
mov    %eax,-0x20(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
add    -0x20(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x8(%rbp),%ecx
mov    -0x4(%rbp),%r8d
add    -0x1c(%rbp),%r8d
mov    -0x8(%rbp),%r9d
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd61(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1040 <plotQuadRationalBezierSeg@plt>
mov    -0x4(%rbp),%edi
mov    -0x8(%rbp),%esi
add    -0x20(%rbp),%esi
mov    -0x4(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0xc(%rbp),%r8d
sub    -0x1c(%rbp),%r8d
mov    -0x10(%rbp),%r9d
movss  -0x24(%rbp),%xmm0
call   1040 <plotQuadRationalBezierSeg@plt>
mov    -0xc(%rbp),%edi
mov    -0x10(%rbp),%esi
sub    -0x20(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x10(%rbp),%ecx
mov    -0xc(%rbp),%r8d
sub    -0x1c(%rbp),%r8d
mov    -0x10(%rbp),%r9d
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd03(%rip),%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1040 <plotQuadRationalBezierSeg@plt>
mov    -0xc(%rbp),%edi
mov    -0x10(%rbp),%esi
sub    -0x20(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x8(%rbp),%ecx
mov    -0x4(%rbp),%r8d
add    -0x1c(%rbp),%r8d
mov    -0x8(%rbp),%r9d
movss  -0x24(%rbp),%xmm0
call   1040 <plotQuadRationalBezierSeg@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<plotRotatedEllipseRect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %esi,%r12d
mov    %edi,%ebp
test   %r8,%r8
je     12a9 <plotRotatedEllipseRect+0x169>
mov    %edx,%ebx
sub    %ebp,%ebx
mov    %ecx,0x8(%rsp)
mov    %ecx,%r15d
sub    %r12d,%r15d
movslq %ebx,%rax
movslq %r15d,%rcx
imul   %rax,%rcx
cvtsi2ss %rcx,%xmm2
mov    %edx,%r14d
test   %rcx,%rcx
je     1198 <plotRotatedEllipseRect+0x58>
cvtsi2ss %r8,%xmm0
movaps %xmm2,%xmm1
subss  %xmm0,%xmm1
addss  %xmm2,%xmm2
divss  %xmm2,%xmm1
movaps %xmm1,%xmm2
movss  %xmm2,(%rsp)
movss  0xe5b(%rip),%xmm0
ucomiss %xmm2,%xmm0
setae  %al
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm2
setae  %cl
and    %al,%cl
movzbl %cl,%edi
call   1030 <assert@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %ebx,%xmm0
mulss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xe32(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1060 <floor@plt>
mov    %eax,%r13d
xorps  %xmm0,%xmm0
cvtsi2ss %r15d,%xmm0
mulss  (%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  0xe0d(%rip),%xmm0
cvttsd2si %xmm0,%edi
call   1060 <floor@plt>
mov    %rax,0x10(%rsp)
lea    (%rax,%r12,1),%ebx
lea    0x0(%r13,%rbp,1),%r8d
mov    %r8d,0xc(%rsp)
movss  0xde1(%rip),%xmm0
subss  (%rsp),%xmm0
movss  %xmm0,0x4(%rsp)
mov    %ebp,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    %r12d,%ecx
mov    %r12d,%r9d
call   1040 <plotQuadRationalBezierSeg@plt>
mov    %r14d,%r15d
sub    %r13d,%r14d
mov    %ebp,%edi
mov    %ebx,%esi
mov    %ebp,%edx
mov    0x8(%rsp),%ebp
mov    %ebp,%ecx
mov    %r14d,%r8d
mov    %ebp,%r9d
movss  (%rsp),%xmm0
call   1040 <plotQuadRationalBezierSeg@plt>
mov    %ebp,%ebx
sub    0x10(%rsp),%ebx
mov    %r15d,%edi
mov    %ebx,%esi
mov    %r15d,%edx
mov    %ebp,%ecx
mov    %r14d,%r8d
mov    %ebp,%r9d
movss  0x4(%rsp),%xmm0
call   1040 <plotQuadRationalBezierSeg@plt>
mov    %r15d,%edi
mov    %ebx,%esi
mov    %r15d,%edx
mov    %r12d,%ecx
mov    0xc(%rsp),%r8d
mov    %r12d,%r9d
movss  (%rsp),%xmm0
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <plotQuadRationalBezierSeg@plt>
mov    %ebp,%edi
mov    %r12d,%esi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <plotEllipseRect@plt>

LLVM IR (-O0):
define void @plotRotatedEllipseRect(i32 %0, i32 %1, i32 %2, i32 %3, i64 %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i64
%11 = alloca i32
%12 = alloca i32
%13 = alloca float
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i64 %4, i64* %10
%14 = load i32, i32* %8
%15 = load i32, i32* %6
%16 = sub nsw i32 %14, %15
store i32 %16, i32* %11
%17 = load i32, i32* %9
%18 = load i32, i32* %7
%19 = sub nsw i32 %17, %18
store i32 %19, i32* %12
%20 = load i32, i32* %11
%21 = sext i32 %20 to i64
%22 = load i32, i32* %12
%23 = sext i32 %22 to i64
%24 = mul nsw i64 %21, %23
%25 = sitofp i64 %24 to float
store float %25, float* %13
%26 = load i64, i64* %10
%27 = icmp eq i64 %26, 0
br i1 %27, label %28, label %33
28: ; preds = %5
%29 = load i32, i32* %6
%30 = load i32, i32* %7
%31 = load i32, i32* %8
%32 = load i32, i32* %9
br label %128
33: ; preds = %5
%34 = load float, float* %13
%35 = fpext float %34 to double
%36 = fcmp une double %35, 0.000000e+00
br i1 %36, label %37, label %46
37: ; preds = %33
%38 = load float, float* %13
%39 = load i64, i64* %10
%40 = sitofp i64 %39 to float
%41 = fsub float %38, %40
%42 = load float, float* %13
%43 = load float, float* %13
%44 = fadd float %42, %43
%45 = fdiv float %41, %44
store float %45, float* %13
br label %46
46: ; preds = %37, %33
%47 = load float, float* %13
%48 = fpext float %47 to double
%49 = fcmp ole double %48, 1.000000e+00
br i1 %49, label %50, label %54
50: ; preds = %46
%51 = load float, float* %13
%52 = fpext float %51 to double
%53 = fcmp oge double %52, 0.000000e+00
br label %54
54: ; preds = %50, %46
%55 = phi i1 [ false, %46 ], [ %53, %50 ]
%56 = zext i1 %55 to i32
%57 = call i32 @assert(i32 %56)
%58 = load i32, i32* %11
%59 = sitofp i32 %58 to float
%60 = load float, float* %13
%61 = fmul float %59, %60
%62 = fpext float %61 to double
%63 = fadd double %62, 5.000000e-01
%64 = fptosi double %63 to i32
%65 = call i32 @floor(i32 %64)
store i32 %65, i32* %11
%66 = load i32, i32* %12
%67 = sitofp i32 %66 to float
%68 = load float, float* %13
%69 = fmul float %67, %68
%70 = fpext float %69 to double
%71 = fadd double %70, 5.000000e-01
%72 = fptosi double %71 to i32
%73 = call i32 @floor(i32 %72)
store i32 %73, i32* %12
%74 = load i32, i32* %6
%75 = load i32, i32* %7
%76 = load i32, i32* %12
%77 = add nsw i32 %75, %76
%78 = load i32, i32* %6
%79 = load i32, i32* %7
%80 = load i32, i32* %6
%81 = load i32, i32* %11
%82 = add nsw i32 %80, %81
%83 = load i32, i32* %7
%84 = load float, float* %13
%85 = fpext float %84 to double
%86 = fsub double 1.000000e+00, %85
%87 = fptrunc double %86 to float
%88 = call i32 @plotQuadRationalBezierSeg(i32 %74, i32 %77, i32 %78, i32 %79, i32 %82, i32 %83, float %87)
%89 = load i32, i32* %6
%90 = load i32, i32* %7
%91 = load i32, i32* %12
%92 = add nsw i32 %90, %91
%93 = load i32, i32* %6
%94 = load i32, i32* %9
%95 = load i32, i32* %8
%96 = load i32, i32* %11
%97 = sub nsw i32 %95, %96
%98 = load i32, i32* %9
%99 = load float, float* %13
%100 = call i32 @plotQuadRationalBezierSeg(i32 %89, i32 %92, i32 %93, i32 %94, i32 %97, i32 %98, float %99)
%101 = load i32, i32* %8
%102 = load i32, i32* %9
%103 = load i32, i32* %12
%104 = sub nsw i32 %102, %103
%105 = load i32, i32* %8
%106 = load i32, i32* %9
%107 = load i32, i32* %8
%108 = load i32, i32* %11
%109 = sub nsw i32 %107, %108
%110 = load i32, i32* %9
%111 = load float, float* %13
%112 = fpext float %111 to double
%113 = fsub double 1.000000e+00, %112
%114 = fptrunc double %113 to float
%115 = call i32 @plotQuadRationalBezierSeg(i32 %101, i32 %104, i32 %105, i32 %106, i32 %109, i32 %110, float %114)
%116 = load i32, i32* %8
%117 = load i32, i32* %9
%118 = load i32, i32* %12
%119 = sub nsw i32 %117, %118
%120 = load i32, i32* %8
%121 = load i32, i32* %7
%122 = load i32, i32* %6
%123 = load i32, i32* %11
%124 = add nsw i32 %122, %123
%125 = load i32, i32* %7
%126 = load float, float* %13
%127 = call i32 @plotQuadRationalBezierSeg(i32 %116, i32 %119, i32 %120, i32 %121, i32 %124, i32 %125, float %126)
br label %128
128: ; preds = %54, %28
ret void
}

LLVM IR (-O2):
define void @plotRotatedEllipseRect(i32 %0, i32 %1, i32 %2, i32 %3, i64 %4) {
%6 = sub nsw i32 %2, %0
%7 = sub nsw i32 %3, %1
%8 = sext i32 %6 to i64
%9 = sext i32 %7 to i64
%10 = mul nsw i64 %9, %8
%11 = sitofp i64 %10 to float
%12 = icmp eq i64 %4, 0
br i1 %12, label %13, label %14
13: ; preds = %5
tail call void @plotEllipseRect(i32 %0, i32 %1, i32 %2, i32 %3)
br label %49
14: ; preds = %5
%15 = icmp eq i64 %10, 0
br i1 %15, label %21, label %16
16: ; preds = %14
%17 = sitofp i64 %4 to float
%18 = fsub float %11, %17
%19 = fadd float %11, %11
%20 = fdiv float %18, %19
br label %21
21: ; preds = %16, %14
%22 = phi float [ %20, %16 ], [ %11, %14 ]
%23 = fcmp ole float %22, 1.000000e+00
%24 = fcmp oge float %22, 0.000000e+00
%25 = and i1 %23, %24
%26 = zext i1 %25 to i32
%27 = tail call i32 @assert(i32 %26)
%28 = sitofp i32 %6 to float
%29 = fmul float %22, %28
%30 = fpext float %29 to double
%31 = fadd double %30, 5.000000e-01
%32 = fptosi double %31 to i32
%33 = tail call i32 @floor(i32 %32)
%34 = sitofp i32 %7 to float
%35 = fmul float %22, %34
%36 = fpext float %35 to double
%37 = fadd double %36, 5.000000e-01
%38 = fptosi double %37 to i32
%39 = tail call i32 @floor(i32 %38)
%40 = add nsw i32 %39, %1
%41 = add nsw i32 %33, %0
%42 = fsub float 1.000000e+00, %22
%43 = tail call i32 @plotQuadRationalBezierSeg(i32 %0, i32 %40, i32 %0, i32 %1, i32 %41, i32 %1, float %42)
%44 = sub nsw i32 %2, %33
%45 = tail call i32 @plotQuadRationalBezierSeg(i32 %0, i32 %40, i32 %0, i32 %3, i32 %44, i32 %3, float %22)
%46 = sub nsw i32 %3, %39
%47 = tail call i32 @plotQuadRationalBezierSeg(i32 %2, i32 %46, i32 %2, i32 %3, i32 %44, i32 %3, float %42)
%48 = tail call i32 @plotQuadRationalBezierSeg(i32 %2, i32 %46, i32 %2, i32 %1, i32 %41, i32 %1, float %22)
br label %49
49: ; preds = %21, %13
ret void
}