#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*/ asin(double);
double cos(int /*<<< orphan*/);
int /*<<< orphan*/ line(int, int, int, int);
int /*<<< orphan*/ line_pixel(int, int);
void circulo(int relleno, int x0, int y0, int x1, int y1) {
  int p[2048];
  double cx, rx;
  int an, al;
  double y, ymed, nsin;
  int n, xa, xb, ya, yb;
  an = x1 - x0 + 1;
  al = y1 - y0 + 1;
  if (al > 1024)
    return;
  rx = (double)(an - 1) / 2.0;
  cx = rx + x0 + 0.5;
  y = (double)y0 + 0.5;
  ymed = (double)(y1 + y0 + 1) / 2.0;
  n = 0;
  do {
    nsin = 1 - (y - y0) / (ymed - y0);
    xb = cx + cos(asin(nsin)) * rx;
    xa = x0 + (x1 - xb);
    ya = y;
    yb = y1 - (ya - y0);
    if (!(n && p[n - 2] == ya)) {
      p[n++] = xa;
      p[n++] = xb;
      p[n++] = ya;
      p[n++] = yb;
    }
  } while (y++ < ymed);
  if (n > 4)
    if (p[n - 1] == p[n - 6])
      n -= 4;
  if (al > 2 && an > 2 && p[0] == p[4] && p[0] + 1 < p[1]) {
    p[0] = p[4] + 1;
    p[1] = p[5] - 1;
  }
  if (al == 2) {
    p[0] = x0;
    p[1] = x1;
    p[4] = x0;
    p[5] = x1;
  }
  if (relleno) {
    do {
      yb = p[--n];
      ya = p[--n];
      xb = p[--n];
      xa = p[--n];
      line(xa, ya, xb, ya);
      if (yb != ya)
        line(xa, yb, xb, yb);
    } while (n);
  } else {
    do {
      yb = p[--n];
      ya = p[--n];
      xb = p[--n];
      xa = p[--n];
      if (n) {
        if (p[n - 3] + 1 >= xb) {
          line_pixel(xa, ya);
          if (xb != xa)
            line_pixel(xb, ya);
          if (yb != ya) {
            line_pixel(xa, yb);
            if (xb != xa)
              line_pixel(xb, yb);
          }
        } else {
          line(xa, ya, p[n - 4], ya);
          line(p[n - 3] + 1, ya, xb, ya);
          if (yb != ya) {
            line(xa, yb, p[n - 4], yb);
            line(p[n - 3] + 1, yb, xb, yb);
          }
        }
      } else {
        line(xa, ya, xb, ya);
        if (yb != ya)
          line(xa, yb, xb, yb);
      }
    } while (n);
  }
}


x86 assembly (clang, -O0):
<circulo>:
push   %rbp
mov    %rsp,%rbp
sub    $0x2070,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    -0x10(%rbp),%eax
sub    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2034(%rbp)
mov    -0x14(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2038(%rbp)
cmpl   $0x400,-0x2038(%rbp)
jle    118e <circulo+0x4e>
jmp    17d2 <circulo+0x692>
mov    -0x2034(%rbp),%eax
sub    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0xe5d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2030(%rbp)
ff
movsd  -0x2030(%rbp),%xmm0
ff
cvtsi2sdl -0x8(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  0xe40(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2028(%rbp)
ff
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  0xe27(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x2040(%rbp)
ff
mov    -0x14(%rbp),%eax
add    -0xc(%rbp),%eax
add    $0x1,%eax
cvtsi2sd %eax,%xmm0
movsd  0xdfe(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x2048(%rbp)
ff
movl   $0x0,-0x2054(%rbp)
movsd  -0x2040(%rbp),%xmm1
ff
cvtsi2sdl -0xc(%rbp),%xmm0
subsd  %xmm0,%xmm1
movsd  -0x2048(%rbp),%xmm0
ff
cvtsi2sdl -0xc(%rbp),%xmm2
subsd  %xmm2,%xmm0
divsd  %xmm0,%xmm1
movsd  0xdca(%rip),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x2050(%rbp)
ff
movsd  -0x2028(%rbp),%xmm0
ff
movsd  %xmm0,-0x2070(%rbp)
ff
movsd  -0x2050(%rbp),%xmm0
ff
call   1040 <asin@plt>
mov    %eax,%edi
call   1050 <cos@plt>
movsd  -0x2070(%rbp),%xmm1
ff
movsd  -0x2030(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x205c(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    -0x205c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x2058(%rbp)
cvttsd2si -0x2040(%rbp),%eax
ff
mov    %eax,-0x2060(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x2060(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x2064(%rbp)
cmpl   $0x0,-0x2054(%rbp)
je     12f9 <circulo+0x1b9>
mov    -0x2054(%rbp),%eax
sub    $0x2,%eax
cltq
mov    -0x2020(%rbp,%rax,4),%eax
cmp    -0x2060(%rbp),%eax
je     1379 <circulo+0x239>
mov    -0x2058(%rbp),%ecx
mov    -0x2054(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x2054(%rbp)
cltq
mov    %ecx,-0x2020(%rbp,%rax,4)
mov    -0x205c(%rbp),%ecx
mov    -0x2054(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x2054(%rbp)
cltq
mov    %ecx,-0x2020(%rbp,%rax,4)
mov    -0x2060(%rbp),%ecx
mov    -0x2054(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x2054(%rbp)
cltq
mov    %ecx,-0x2020(%rbp,%rax,4)
mov    -0x2064(%rbp),%ecx
mov    -0x2054(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x2054(%rbp)
cltq
mov    %ecx,-0x2020(%rbp,%rax,4)
jmp    137e <circulo+0x23e>
movsd  -0x2040(%rbp),%xmm1
ff
movsd  0xc82(%rip),%xmm2
movaps %xmm1,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,-0x2040(%rbp)
ff
movsd  -0x2048(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
ja     1218 <circulo+0xd8>
cmpl   $0x4,-0x2054(%rbp)
jle    13fb <circulo+0x2bb>
mov    -0x2054(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    -0x2054(%rbp),%ecx
sub    $0x6,%ecx
movslq %ecx,%rcx
cmp    -0x2020(%rbp,%rcx,4),%eax
jne    13f6 <circulo+0x2b6>
mov    -0x2054(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x2054(%rbp)
jmp    13fb <circulo+0x2bb>
cmpl   $0x2,-0x2038(%rbp)
jle    145a <circulo+0x31a>
cmpl   $0x2,-0x2034(%rbp)
jle    145a <circulo+0x31a>
mov    -0x2020(%rbp),%eax
cmp    -0x2010(%rbp),%eax
jne    145a <circulo+0x31a>
mov    -0x2020(%rbp),%eax
add    $0x1,%eax
cmp    -0x201c(%rbp),%eax
jge    145a <circulo+0x31a>
mov    -0x2010(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2020(%rbp)
mov    -0x200c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x201c(%rbp)
cmpl   $0x2,-0x2038(%rbp)
jne    148b <circulo+0x34b>
mov    -0x8(%rbp),%eax
mov    %eax,-0x2020(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x201c(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x2010(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x200c(%rbp)
cmpl   $0x0,-0x4(%rbp)
je     1575 <circulo+0x435>
jmp    149a <circulo+0x35a>
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x2064(%rbp)
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x2060(%rbp)
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x205c(%rbp)
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x2058(%rbp)
mov    -0x2058(%rbp),%edi
mov    -0x2060(%rbp),%esi
mov    -0x205c(%rbp),%edx
mov    -0x2060(%rbp),%ecx
call   1060 <line@plt>
mov    -0x2064(%rbp),%eax
cmp    -0x2060(%rbp),%eax
je     155e <circulo+0x41e>
mov    -0x2058(%rbp),%edi
mov    -0x2064(%rbp),%esi
mov    -0x205c(%rbp),%edx
mov    -0x2064(%rbp),%ecx
call   1060 <line@plt>
jmp    1563 <circulo+0x423>
cmpl   $0x0,-0x2054(%rbp)
jne    149a <circulo+0x35a>
jmp    17d2 <circulo+0x692>
jmp    157a <circulo+0x43a>
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x2064(%rbp)
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x2060(%rbp)
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x205c(%rbp)
mov    -0x2054(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2054(%rbp)
cltq
mov    -0x2020(%rbp,%rax,4),%eax
mov    %eax,-0x2058(%rbp)
cmpl   $0x0,-0x2054(%rbp)
je     176a <circulo+0x62a>
mov    -0x2054(%rbp),%eax
sub    $0x3,%eax
cltq
mov    -0x2020(%rbp,%rax,4),%eax
add    $0x1,%eax
cmp    -0x205c(%rbp),%eax
jl     16a4 <circulo+0x564>
mov    -0x2058(%rbp),%edi
mov    -0x2060(%rbp),%esi
call   1030 <line_pixel@plt>
mov    -0x205c(%rbp),%eax
cmp    -0x2058(%rbp),%eax
je     1654 <circulo+0x514>
mov    -0x205c(%rbp),%edi
mov    -0x2060(%rbp),%esi
call   1030 <line_pixel@plt>
mov    -0x2064(%rbp),%eax
cmp    -0x2060(%rbp),%eax
je     169f <circulo+0x55f>
mov    -0x2058(%rbp),%edi
mov    -0x2064(%rbp),%esi
call   1030 <line_pixel@plt>
mov    -0x205c(%rbp),%eax
cmp    -0x2058(%rbp),%eax
je     169a <circulo+0x55a>
mov    -0x205c(%rbp),%edi
mov    -0x2064(%rbp),%esi
call   1030 <line_pixel@plt>
jmp    169f <circulo+0x55f>
jmp    1765 <circulo+0x625>
mov    -0x2058(%rbp),%edi
mov    -0x2060(%rbp),%esi
mov    -0x2054(%rbp),%eax
sub    $0x4,%eax
cltq
mov    -0x2020(%rbp,%rax,4),%edx
mov    -0x2060(%rbp),%ecx
call   1060 <line@plt>
mov    -0x2054(%rbp),%eax
sub    $0x3,%eax
cltq
mov    -0x2020(%rbp,%rax,4),%edi
add    $0x1,%edi
mov    -0x2060(%rbp),%esi
mov    -0x205c(%rbp),%edx
mov    -0x2060(%rbp),%ecx
call   1060 <line@plt>
mov    -0x2064(%rbp),%eax
cmp    -0x2060(%rbp),%eax
je     1760 <circulo+0x620>
mov    -0x2058(%rbp),%edi
mov    -0x2064(%rbp),%esi
mov    -0x2054(%rbp),%eax
sub    $0x4,%eax
cltq
mov    -0x2020(%rbp,%rax,4),%edx
mov    -0x2064(%rbp),%ecx
call   1060 <line@plt>
mov    -0x2054(%rbp),%eax
sub    $0x3,%eax
cltq
mov    -0x2020(%rbp,%rax,4),%edi
add    $0x1,%edi
mov    -0x2064(%rbp),%esi
mov    -0x205c(%rbp),%edx
mov    -0x2064(%rbp),%ecx
call   1060 <line@plt>
jmp    1765 <circulo+0x625>
jmp    17bb <circulo+0x67b>
mov    -0x2058(%rbp),%edi
mov    -0x2060(%rbp),%esi
mov    -0x205c(%rbp),%edx
mov    -0x2060(%rbp),%ecx
call   1060 <line@plt>
mov    -0x2064(%rbp),%eax
cmp    -0x2060(%rbp),%eax
je     17b6 <circulo+0x676>
mov    -0x2058(%rbp),%edi
mov    -0x2064(%rbp),%esi
mov    -0x205c(%rbp),%edx
mov    -0x2064(%rbp),%ecx
call   1060 <line@plt>
jmp    17bb <circulo+0x67b>
jmp    17c0 <circulo+0x680>
cmpl   $0x0,-0x2054(%rbp)
jne    157a <circulo+0x43a>
jmp    17d2 <circulo+0x692>
add    $0x2070,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<circulo>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x2048,%rsp
mov    %r8d,%ebp
sub    %edx,%ebp
cmp    $0x3ff,%ebp
jle    1170 <circulo+0x30>
add    $0x2048,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8d,%ebx
mov    %esi,%r12d
mov    %edi,0xc(%rsp)
mov    %ecx,%r14d
sub    %esi,%r14d
cvtsi2sd %r14d,%xmm1
movsd  0xe73(%rip),%xmm0
mulsd  %xmm0,%xmm1
cvtsi2sd %esi,%xmm2
movsd  %xmm1,0x28(%rsp)
addsd  %xmm1,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,0x20(%rsp)
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm1,%xmm2
addsd  %xmm0,%xmm2
lea    0x1(%rbx,%rdx,1),%eax
cvtsi2sd %eax,%xmm3
mulsd  %xmm0,%xmm3
movsd  %xmm3,0x38(%rsp)
movsd  %xmm1,0x10(%rsp)
subsd  %xmm1,%xmm3
movsd  %xmm3,0x30(%rsp)
mov    %rcx,0x18(%rsp)
lea    (%rcx,%r12,1),%r15d
add    %edx,%ebx
xor    %r13d,%r13d
movsd  0xe18(%rip),%xmm0
jmp    1245 <circulo+0x105>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mulsd  0x28(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
cvttsd2si %xmm0,%edx
mov    %r15d,%esi
sub    %edx,%esi
mov    %ebx,%edi
sub    %ecx,%edi
mov    %esi,0x40(%rsp,%rax,4)
mov    %edx,0x44(%rsp,%rax,4)
mov    %ecx,0x48(%rsp,%rax,4)
lea    0x4(%rax),%r13d
mov    %edi,0x4c(%rsp,%rax,4)
movsd  0x38(%rsp),%xmm0
ucomisd %xmm2,%xmm0
movsd  0xdc9(%rip),%xmm0
addsd  %xmm0,%xmm2
jbe    1287 <circulo+0x147>
movsd  %xmm2,(%rsp)
movapd %xmm2,%xmm1
subsd  0x10(%rsp),%xmm1
divsd  0x30(%rsp),%xmm1
subsd  %xmm1,%xmm0
call   1040 <asin@plt>
mov    %eax,%edi
call   1050 <cos@plt>
movsd  (%rsp),%xmm2
cvttsd2si %xmm2,%ecx
movslq %r13d,%rax
test   %r13d,%r13d
je     1200 <circulo+0xc0>
cmp    %ecx,0x38(%rsp,%rax,4)
jne    1200 <circulo+0xc0>
jmp    122d <circulo+0xed>
cmp    $0x5,%r13d
jl     12a7 <circulo+0x167>
lea    -0x1(%r13),%eax
mov    0x40(%rsp,%rax,4),%eax
movslq %r13d,%rcx
lea    -0x4(%r13),%edx
cmp    0x28(%rsp,%rcx,4),%eax
cmovne %r13d,%edx
mov    %edx,%r13d
cmp    $0x2,%ebp
jl     12da <circulo+0x19a>
cmp    $0x2,%r14d
jl     12da <circulo+0x19a>
mov    0x40(%rsp),%eax
cmp    0x50(%rsp),%eax
mov    0xc(%rsp),%ecx
jne    12fa <circulo+0x1ba>
add    $0x1,%eax
cmp    0x44(%rsp),%eax
jge    12fa <circulo+0x1ba>
mov    %eax,0x40(%rsp)
mov    0x54(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x44(%rsp)
jmp    12fa <circulo+0x1ba>
cmp    $0x1,%ebp
mov    0xc(%rsp),%ecx
jne    12fa <circulo+0x1ba>
mov    %r12d,0x40(%rsp)
mov    0x18(%rsp),%rax
mov    %eax,0x44(%rsp)
mov    %r12d,0x50(%rsp)
mov    %eax,0x54(%rsp)
test   %ecx,%ecx
je     1366 <circulo+0x226>
movslq %r13d,%rax
lea    (%rsp,%rax,4),%r13
add    $0x3c,%r13
neg    %eax
mov    %rax,(%rsp)
xor    %r12d,%r12d
jmp    132e <circulo+0x1ee>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xfffffffffffffffc,%r12
cmp    %r12d,(%rsp)
je     115e <circulo+0x1e>
mov    0x0(%r13,%r12,4),%ebx
mov    -0x4(%r13,%r12,4),%ebp
mov    -0xc(%r13,%r12,4),%r15d
mov    -0x8(%r13,%r12,4),%r14d
mov    %r15d,%edi
mov    %ebp,%esi
mov    %r14d,%edx
mov    %ebp,%ecx
call   1060 <line@plt>
cmp    %ebp,%ebx
je     1320 <circulo+0x1e0>
mov    %r15d,%edi
mov    %ebx,%esi
mov    %r14d,%edx
mov    %ebx,%ecx
call   1060 <line@plt>
jmp    1320 <circulo+0x1e0>
movslq %r13d,%rax
mov    0x3c(%rsp,%rax,4),%ecx
mov    %ecx,(%rsp)
mov    0x38(%rsp,%rax,4),%ebx
mov    0x30(%rsp,%rax,4),%r15d
mov    0x34(%rsp,%rax,4),%r12d
cmp    $0x4,%r13d
je     1490 <circulo+0x350>
add    $0xfffffffffffffffc,%rax
add    $0xfffffff8,%r13d
lea    (%rsp,%rax,4),%r14
add    $0x3c,%r14
jmp    13c4 <circulo+0x284>
nopw   0x0(%rax,%rax,1)
mov    (%r14),%eax
mov    %eax,(%rsp)
mov    -0x4(%r14),%ebx
mov    -0xc(%r14),%r15d
mov    -0x8(%r14),%r12d
add    $0xfffffffc,%r13d
add    $0xfffffffffffffff0,%r14
cmp    $0xfffffffc,%r13d
je     1490 <circulo+0x350>
lea    0x1(%r13),%eax
cltq
mov    0x40(%rsp,%rax,4),%ebp
add    $0x1,%ebp
cmp    %r12d,%ebp
jge    1430 <circulo+0x2f0>
movslq %r13d,%rax
mov    0x40(%rsp,%rax,4),%edx
mov    %r15d,%edi
mov    %ebx,%esi
mov    %edx,0x10(%rsp)
mov    %ebx,%ecx
call   1060 <line@plt>
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r12d,%edx
mov    %ebx,%ecx
call   1060 <line@plt>
mov    (%rsp),%eax
cmp    %ebx,%eax
je     13a0 <circulo+0x260>
mov    %eax,%ebx
mov    %r15d,%edi
mov    %eax,%esi
mov    0x10(%rsp),%edx
mov    %eax,%ecx
call   1060 <line@plt>
mov    %ebp,%edi
mov    %ebx,%esi
mov    %r12d,%edx
mov    %ebx,%ecx
call   1060 <line@plt>
jmp    13a0 <circulo+0x260>
nopw   0x0(%rax,%rax,1)
mov    %r15d,%edi
mov    %ebx,%esi
call   1030 <line_pixel@plt>
cmp    %r15d,%r12d
jne    1460 <circulo+0x320>
mov    (%rsp),%esi
cmp    %ebx,%esi
je     13a0 <circulo+0x260>
mov    %r15d,%edi
call   1030 <line_pixel@plt>
jmp    13a0 <circulo+0x260>
nopw   0x0(%rax,%rax,1)
mov    %r12d,%edi
mov    %ebx,%esi
call   1030 <line_pixel@plt>
mov    (%rsp),%eax
cmp    %ebx,%eax
je     13a0 <circulo+0x260>
mov    %eax,%ebx
mov    %r15d,%edi
mov    %eax,%esi
call   1030 <line_pixel@plt>
mov    %r12d,%edi
mov    %ebx,%esi
call   1030 <line_pixel@plt>
jmp    13a0 <circulo+0x260>
mov    %r15d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
mov    %ebx,%ecx
call   1060 <line@plt>
mov    (%rsp),%ecx
cmp    %ebx,%ecx
je     115e <circulo+0x1e>
mov    %r15d,%edi
mov    %ecx,%esi
mov    %r12d,%edx
add    $0x2048,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <line@plt>

LLVM IR (-O0):
define void @circulo(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [2048 x i32]
%12 = alloca double
%13 = alloca double
%14 = alloca i32
%15 = alloca i32
%16 = alloca double
%17 = alloca double
%18 = alloca double
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32 %4, i32* %10
%24 = load i32, i32* %9
%25 = load i32, i32* %7
%26 = sub nsw i32 %24, %25
%27 = add nsw i32 %26, 1
store i32 %27, i32* %14
%28 = load i32, i32* %10
%29 = load i32, i32* %8
%30 = sub nsw i32 %28, %29
%31 = add nsw i32 %30, 1
store i32 %31, i32* %15
%32 = load i32, i32* %15
%33 = icmp sgt i32 %32, 1024
br i1 %33, label %34, label %35
34: ; preds = %5
br label %351
35: ; preds = %5
%36 = load i32, i32* %14
%37 = sub nsw i32 %36, 1
%38 = sitofp i32 %37 to double
%39 = fdiv double %38, 2.000000e+00
store double %39, double* %13
%40 = load double, double* %13
%41 = load i32, i32* %7
%42 = sitofp i32 %41 to double
%43 = fadd double %40, %42
%44 = fadd double %43, 5.000000e-01
store double %44, double* %12
%45 = load i32, i32* %8
%46 = sitofp i32 %45 to double
%47 = fadd double %46, 5.000000e-01
store double %47, double* %16
%48 = load i32, i32* %10
%49 = load i32, i32* %8
%50 = add nsw i32 %48, %49
%51 = add nsw i32 %50, 1
%52 = sitofp i32 %51 to double
%53 = fdiv double %52, 2.000000e+00
store double %53, double* %17
store i32 0, i32* %19
br label %54
54: ; preds = %116, %35
%55 = load double, double* %16
%56 = load i32, i32* %8
%57 = sitofp i32 %56 to double
%58 = fsub double %55, %57
%59 = load double, double* %17
%60 = load i32, i32* %8
%61 = sitofp i32 %60 to double
%62 = fsub double %59, %61
%63 = fdiv double %58, %62
%64 = fsub double 1.000000e+00, %63
store double %64, double* %18
%65 = load double, double* %12
%66 = load double, double* %18
%67 = call i32 @asin(double %66)
%68 = call double @cos(i32 %67)
%69 = load double, double* %13
%70 = call double @llvm.fmuladd.f64(double %68, double %69, double %65)
%71 = fptosi double %70 to i32
store i32 %71, i32* %21
%72 = load i32, i32* %7
%73 = load i32, i32* %9
%74 = load i32, i32* %21
%75 = sub nsw i32 %73, %74
%76 = add nsw i32 %72, %75
store i32 %76, i32* %20
%77 = load double, double* %16
%78 = fptosi double %77 to i32
store i32 %78, i32* %22
%79 = load i32, i32* %10
%80 = load i32, i32* %22
%81 = load i32, i32* %8
%82 = sub nsw i32 %80, %81
%83 = sub nsw i32 %79, %82
store i32 %83, i32* %23
%84 = load i32, i32* %19
%85 = icmp ne i32 %84, 0
br i1 %85, label %86, label %94
86: ; preds = %54
%87 = load i32, i32* %19
%88 = sub nsw i32 %87, 2
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %89
%91 = load i32, i32* %90
%92 = load i32, i32* %22
%93 = icmp eq i32 %91, %92
br i1 %93, label %115, label %94
94: ; preds = %86, %54
%95 = load i32, i32* %20
%96 = load i32, i32* %19
%97 = add nsw i32 %96, 1
store i32 %97, i32* %19
%98 = sext i32 %96 to i64
%99 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %98
store i32 %95, i32* %99
%100 = load i32, i32* %21
%101 = load i32, i32* %19
%102 = add nsw i32 %101, 1
store i32 %102, i32* %19
%103 = sext i32 %101 to i64
%104 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %103
store i32 %100, i32* %104
%105 = load i32, i32* %22
%106 = load i32, i32* %19
%107 = add nsw i32 %106, 1
store i32 %107, i32* %19
%108 = sext i32 %106 to i64
%109 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %108
store i32 %105, i32* %109
%110 = load i32, i32* %23
%111 = load i32, i32* %19
%112 = add nsw i32 %111, 1
store i32 %112, i32* %19
%113 = sext i32 %111 to i64
%114 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %113
store i32 %110, i32* %114
br label %115
115: ; preds = %94, %86
br label %116
116: ; preds = %115
%117 = load double, double* %16
%118 = fadd double %117, 1.000000e+00
store double %118, double* %16
%119 = load double, double* %17
%120 = fcmp olt double %117, %119
br i1 %120, label %54, label %121
121: ; preds = %116
%122 = load i32, i32* %19
%123 = icmp sgt i32 %122, 4
br i1 %123, label %124, label %140
124: ; preds = %121
%125 = load i32, i32* %19
%126 = sub nsw i32 %125, 1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %127
%129 = load i32, i32* %128
%130 = load i32, i32* %19
%131 = sub nsw i32 %130, 6
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %132
%134 = load i32, i32* %133
%135 = icmp eq i32 %129, %134
br i1 %135, label %136, label %139
136: ; preds = %124
%137 = load i32, i32* %19
%138 = sub nsw i32 %137, 4
store i32 %138, i32* %19
br label %139
139: ; preds = %136, %124
br label %140
140: ; preds = %139, %121
%141 = load i32, i32* %15
%142 = icmp sgt i32 %141, 2
br i1 %142, label %143, label %168
143: ; preds = %140
%144 = load i32, i32* %14
%145 = icmp sgt i32 %144, 2
br i1 %145, label %146, label %168
146: ; preds = %143
%147 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 0
%148 = load i32, i32* %147
%149 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 4
%150 = load i32, i32* %149
%151 = icmp eq i32 %148, %150
br i1 %151, label %152, label %168
152: ; preds = %146
%153 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 0
%154 = load i32, i32* %153
%155 = add nsw i32 %154, 1
%156 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 1
%157 = load i32, i32* %156
%158 = icmp slt i32 %155, %157
br i1 %158, label %159, label %168
159: ; preds = %152
%160 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 4
%161 = load i32, i32* %160
%162 = add nsw i32 %161, 1
%163 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 0
store i32 %162, i32* %163
%164 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 5
%165 = load i32, i32* %164
%166 = sub nsw i32 %165, 1
%167 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 1
store i32 %166, i32* %167
br label %168
168: ; preds = %159, %152, %146, %143, %140
%169 = load i32, i32* %15
%170 = icmp eq i32 %169, 2
br i1 %170, label %171, label %180
171: ; preds = %168
%172 = load i32, i32* %7
%173 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 0
store i32 %172, i32* %173
%174 = load i32, i32* %9
%175 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 1
store i32 %174, i32* %175
%176 = load i32, i32* %7
%177 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 4
store i32 %176, i32* %177
%178 = load i32, i32* %9
%179 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 5
store i32 %178, i32* %179
br label %180
180: ; preds = %171, %168
%181 = load i32, i32* %6
%182 = icmp ne i32 %181, 0
br i1 %182, label %183, label %224
183: ; preds = %180
br label %184
184: ; preds = %220, %183
%185 = load i32, i32* %19
%186 = add nsw i32 %185, -1
store i32 %186, i32* %19
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %187
%189 = load i32, i32* %188
store i32 %189, i32* %23
%190 = load i32, i32* %19
%191 = add nsw i32 %190, -1
store i32 %191, i32* %19
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %192
%194 = load i32, i32* %193
store i32 %194, i32* %22
%195 = load i32, i32* %19
%196 = add nsw i32 %195, -1
store i32 %196, i32* %19
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %197
%199 = load i32, i32* %198
store i32 %199, i32* %21
%200 = load i32, i32* %19
%201 = add nsw i32 %200, -1
store i32 %201, i32* %19
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %202
%204 = load i32, i32* %203
store i32 %204, i32* %20
%205 = load i32, i32* %20
%206 = load i32, i32* %22
%207 = load i32, i32* %21
%208 = load i32, i32* %22
%209 = call i32 @line(i32 %205, i32 %206, i32 %207, i32 %208)
%210 = load i32, i32* %23
%211 = load i32, i32* %22
%212 = icmp ne i32 %210, %211
br i1 %212, label %213, label %219
213: ; preds = %184
%214 = load i32, i32* %20
%215 = load i32, i32* %23
%216 = load i32, i32* %21
%217 = load i32, i32* %23
%218 = call i32 @line(i32 %214, i32 %215, i32 %216, i32 %217)
br label %219
219: ; preds = %213, %184
br label %220
220: ; preds = %219
%221 = load i32, i32* %19
%222 = icmp ne i32 %221, 0
br i1 %222, label %184, label %223
223: ; preds = %220
br label %351
224: ; preds = %180
br label %225
225: ; preds = %347, %224
%226 = load i32, i32* %19
%227 = add nsw i32 %226, -1
store i32 %227, i32* %19
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %228
%230 = load i32, i32* %229
store i32 %230, i32* %23
%231 = load i32, i32* %19
%232 = add nsw i32 %231, -1
store i32 %232, i32* %19
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %233
%235 = load i32, i32* %234
store i32 %235, i32* %22
%236 = load i32, i32* %19
%237 = add nsw i32 %236, -1
store i32 %237, i32* %19
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %238
%240 = load i32, i32* %239
store i32 %240, i32* %21
%241 = load i32, i32* %19
%242 = add nsw i32 %241, -1
store i32 %242, i32* %19
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %243
%245 = load i32, i32* %244
store i32 %245, i32* %20
%246 = load i32, i32* %19
%247 = icmp ne i32 %246, 0
br i1 %247, label %248, label %330
248: ; preds = %225
%249 = load i32, i32* %19
%250 = sub nsw i32 %249, 3
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %251
%253 = load i32, i32* %252
%254 = add nsw i32 %253, 1
%255 = load i32, i32* %21
%256 = icmp sge i32 %254, %255
br i1 %256, label %257, label %285
257: ; preds = %248
%258 = load i32, i32* %20
%259 = load i32, i32* %22
%260 = call i32 @line_pixel(i32 %258, i32 %259)
%261 = load i32, i32* %21
%262 = load i32, i32* %20
%263 = icmp ne i32 %261, %262
br i1 %263, label %264, label %268
264: ; preds = %257
%265 = load i32, i32* %21
%266 = load i32, i32* %22
%267 = call i32 @line_pixel(i32 %265, i32 %266)
br label %268
268: ; preds = %264, %257
%269 = load i32, i32* %23
%270 = load i32, i32* %22
%271 = icmp ne i32 %269, %270
br i1 %271, label %272, label %284
272: ; preds = %268
%273 = load i32, i32* %20
%274 = load i32, i32* %23
%275 = call i32 @line_pixel(i32 %273, i32 %274)
%276 = load i32, i32* %21
%277 = load i32, i32* %20
%278 = icmp ne i32 %276, %277
br i1 %278, label %279, label %283
279: ; preds = %272
%280 = load i32, i32* %21
%281 = load i32, i32* %23
%282 = call i32 @line_pixel(i32 %280, i32 %281)
br label %283
283: ; preds = %279, %272
br label %284
284: ; preds = %283, %268
br label %329
285: ; preds = %248
%286 = load i32, i32* %20
%287 = load i32, i32* %22
%288 = load i32, i32* %19
%289 = sub nsw i32 %288, 4
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %290
%292 = load i32, i32* %291
%293 = load i32, i32* %22
%294 = call i32 @line(i32 %286, i32 %287, i32 %292, i32 %293)
%295 = load i32, i32* %19
%296 = sub nsw i32 %295, 3
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %297
%299 = load i32, i32* %298
%300 = add nsw i32 %299, 1
%301 = load i32, i32* %22
%302 = load i32, i32* %21
%303 = load i32, i32* %22
%304 = call i32 @line(i32 %300, i32 %301, i32 %302, i32 %303)
%305 = load i32, i32* %23
%306 = load i32, i32* %22
%307 = icmp ne i32 %305, %306
br i1 %307, label %308, label %328
308: ; preds = %285
%309 = load i32, i32* %20
%310 = load i32, i32* %23
%311 = load i32, i32* %19
%312 = sub nsw i32 %311, 4
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %313
%315 = load i32, i32* %314
%316 = load i32, i32* %23
%317 = call i32 @line(i32 %309, i32 %310, i32 %315, i32 %316)
%318 = load i32, i32* %19
%319 = sub nsw i32 %318, 3
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds [2048 x i32], [2048 x i32]* %11, i64 0, i64 %320
%322 = load i32, i32* %321
%323 = add nsw i32 %322, 1
%324 = load i32, i32* %23
%325 = load i32, i32* %21
%326 = load i32, i32* %23
%327 = call i32 @line(i32 %323, i32 %324, i32 %325, i32 %326)
br label %328
328: ; preds = %308, %285
br label %329
329: ; preds = %328, %284
br label %346
330: ; preds = %225
%331 = load i32, i32* %20
%332 = load i32, i32* %22
%333 = load i32, i32* %21
%334 = load i32, i32* %22
%335 = call i32 @line(i32 %331, i32 %332, i32 %333, i32 %334)
%336 = load i32, i32* %23
%337 = load i32, i32* %22
%338 = icmp ne i32 %336, %337
br i1 %338, label %339, label %345
339: ; preds = %330
%340 = load i32, i32* %20
%341 = load i32, i32* %23
%342 = load i32, i32* %21
%343 = load i32, i32* %23
%344 = call i32 @line(i32 %340, i32 %341, i32 %342, i32 %343)
br label %345
345: ; preds = %339, %330
br label %346
346: ; preds = %345, %329
br label %347
347: ; preds = %346
%348 = load i32, i32* %19
%349 = icmp ne i32 %348, 0
br i1 %349, label %225, label %350
350: ; preds = %347
br label %351
351: ; preds = %34, %350, %223
ret void
}

LLVM IR (-O2):
define void @circulo(i32 %0, i32 %1, i32 %2, i32 %3, i32 %4) {
%6 = alloca [2048 x i32]
%7 = bitcast [2048 x i32]* %6 to i8*
%8 = sub nsw i32 %3, %1
%9 = sub nsw i32 %4, %2
%10 = icmp sgt i32 %9, 1023
br i1 %10, label %209, label %11
11: ; preds = %5
%12 = sitofp i32 %8 to double
%13 = fmul double %12, 5.000000e-01
%14 = sitofp i32 %1 to double
%15 = fadd double %13, %14
%16 = fadd double %15, 5.000000e-01
%17 = sitofp i32 %2 to double
%18 = fadd double %17, 5.000000e-01
%19 = add i32 %2, 1
%20 = add i32 %19, %4
%21 = sitofp i32 %20 to double
%22 = fmul double %21, 5.000000e-01
%23 = fsub double %22, %17
%24 = add i32 %3, %1
%25 = add i32 %4, %2
br label %26
26: ; preds = %59, %11
%27 = phi double [ %18, %11 ], [ %61, %59 ]
%28 = phi i32 [ 0, %11 ], [ %60, %59 ]
%29 = fsub double %27, %17
%30 = fdiv double %29, %23
%31 = fsub double 1.000000e+00, %30
%32 = tail call i32 @asin(double %31)
%33 = tail call double @cos(i32 %32)
%34 = tail call double @llvm.fmuladd.f64(double %33, double %13, double %16)
%35 = fptosi double %34 to i32
%36 = sub i32 %24, %35
%37 = fptosi double %27 to i32
%38 = sub i32 %25, %37
%39 = icmp eq i32 %28, 0
br i1 %39, label %46, label %40
40: ; preds = %26
%41 = add nsw i32 %28, -2
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %42
%44 = load i32, i32* %43
%45 = icmp eq i32 %44, %37
br i1 %45, label %59, label %46
46: ; preds = %40, %26
%47 = add nsw i32 %28, 1
%48 = sext i32 %28 to i64
%49 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %48
store i32 %36, i32* %49
%50 = add nsw i32 %28, 2
%51 = sext i32 %47 to i64
%52 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %51
store i32 %35, i32* %52
%53 = add nsw i32 %28, 3
%54 = sext i32 %50 to i64
%55 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %54
store i32 %37, i32* %55
%56 = add nsw i32 %28, 4
%57 = sext i32 %53 to i64
%58 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %57
store i32 %38, i32* %58
br label %59
59: ; preds = %40, %46
%60 = phi i32 [ %28, %40 ], [ %56, %46 ]
%61 = fadd double %27, 1.000000e+00
%62 = fcmp olt double %27, %22
br i1 %62, label %26, label %63
63: ; preds = %59
%64 = icmp sgt i32 %60, 4
br i1 %64, label %65, label %77
65: ; preds = %63
%66 = add nsw i32 %60, -1
%67 = zext i32 %66 to i64
%68 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %67
%69 = load i32, i32* %68
%70 = add nsw i32 %60, -6
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %71
%73 = load i32, i32* %72
%74 = icmp eq i32 %69, %73
%75 = add nsw i32 %60, -4
%76 = select i1 %74, i32 %75, i32 %60
br label %77
77: ; preds = %65, %63
%78 = phi i32 [ %60, %63 ], [ %76, %65 ]
%79 = icmp sgt i32 %9, 1
%80 = icmp sgt i32 %8, 1
%81 = select i1 %79, i1 %80, i1 false
br i1 %81, label %82, label %97
82: ; preds = %77
%83 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 0
%84 = load i32, i32* %83
%85 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 4
%86 = load i32, i32* %85
%87 = icmp eq i32 %84, %86
br i1 %87, label %88, label %104
88: ; preds = %82
%89 = add nsw i32 %84, 1
%90 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 1
%91 = load i32, i32* %90
%92 = icmp slt i32 %89, %91
br i1 %92, label %93, label %104
93: ; preds = %88
store i32 %89, i32* %83
%94 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 5
%95 = load i32, i32* %94
%96 = add nsw i32 %95, -1
store i32 %96, i32* %90
br label %104
97: ; preds = %77
%98 = icmp eq i32 %9, 1
br i1 %98, label %99, label %104
99: ; preds = %97
%100 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 0
store i32 %1, i32* %100
%101 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 1
store i32 %3, i32* %101
%102 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 4
store i32 %1, i32* %102
%103 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 5
store i32 %3, i32* %103
br label %104
104: ; preds = %82, %88, %93, %99, %97
%105 = icmp eq i32 %0, 0
br i1 %105, label %108, label %106
106: ; preds = %104
%107 = sext i32 %78 to i64
br label %126
108: ; preds = %104
%109 = add nsw i32 %78, -1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %110
%112 = load i32, i32* %111
%113 = add nsw i32 %78, -2
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %114
%116 = load i32, i32* %115
%117 = add nsw i32 %78, -3
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %118
%120 = load i32, i32* %119
%121 = add nsw i32 %78, -4
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %122
%124 = load i32, i32* %123
%125 = icmp eq i32 %121, 0
br i1 %125, label %184, label %147
126: ; preds = %106, %144
%127 = phi i64 [ %107, %106 ], [ %137, %144 ]
%128 = add nsw i64 %127, -1
%129 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %128
%130 = load i32, i32* %129
%131 = add nsw i64 %127, -2
%132 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %131
%133 = load i32, i32* %132
%134 = add nsw i64 %127, -3
%135 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %134
%136 = load i32, i32* %135
%137 = add i64 %127, -4
%138 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %137
%139 = load i32, i32* %138
%140 = tail call i32 @line(i32 %139, i32 %133, i32 %136, i32 %133)
%141 = icmp eq i32 %130, %133
br i1 %141, label %144, label %142
142: ; preds = %126
%143 = tail call i32 @line(i32 %139, i32 %130, i32 %136, i32 %130)
br label %144
144: ; preds = %126, %142
%145 = trunc i64 %137 to i32
%146 = icmp eq i32 %145, 0
br i1 %146, label %209, label %126
147: ; preds = %108, %193
%148 = phi i64 [ %203, %193 ], [ %122, %108 ]
%149 = phi i32 [ %205, %193 ], [ %124, %108 ]
%150 = phi i32 [ %202, %193 ], [ %120, %108 ]
%151 = phi i32 [ %199, %193 ], [ %116, %108 ]
%152 = phi i32 [ %196, %193 ], [ %112, %108 ]
%153 = phi i32 [ %208, %193 ], [ %78, %108 ]
%154 = add nsw i32 %153, -7
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %155
%157 = load i32, i32* %156
%158 = add nsw i32 %157, 1
%159 = icmp slt i32 %158, %150
br i1 %159, label %173, label %160
160: ; preds = %147
%161 = tail call i32 @line_pixel(i32 %149, i32 %151)
%162 = icmp eq i32 %150, %149
br i1 %162, label %163, label %165
163: ; preds = %160
%164 = icmp eq i32 %152, %151
br i1 %164, label %193, label %168
165: ; preds = %160
%166 = tail call i32 @line_pixel(i32 %150, i32 %151)
%167 = icmp eq i32 %152, %151
br i1 %167, label %193, label %170
168: ; preds = %163
%169 = tail call i32 @line_pixel(i32 %149, i32 %152)
br label %193
170: ; preds = %165
%171 = tail call i32 @line_pixel(i32 %149, i32 %152)
%172 = tail call i32 @line_pixel(i32 %150, i32 %152)
br label %193
173: ; preds = %147
%174 = add nsw i32 %153, -8
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %175
%177 = load i32, i32* %176
%178 = tail call i32 @line(i32 %149, i32 %151, i32 %177, i32 %151)
%179 = tail call i32 @line(i32 %158, i32 %151, i32 %150, i32 %151)
%180 = icmp eq i32 %152, %151
br i1 %180, label %193, label %181
181: ; preds = %173
%182 = tail call i32 @line(i32 %149, i32 %152, i32 %177, i32 %152)
%183 = tail call i32 @line(i32 %158, i32 %152, i32 %150, i32 %152)
br label %193
184: ; preds = %193, %108
%185 = phi i32 [ %112, %108 ], [ %196, %193 ]
%186 = phi i32 [ %116, %108 ], [ %199, %193 ]
%187 = phi i32 [ %120, %108 ], [ %202, %193 ]
%188 = phi i32 [ %124, %108 ], [ %205, %193 ]
%189 = tail call i32 @line(i32 %188, i32 %186, i32 %187, i32 %186)
%190 = icmp eq i32 %185, %186
br i1 %190, label %209, label %191
191: ; preds = %184
%192 = tail call i32 @line(i32 %188, i32 %185, i32 %187, i32 %185)
br label %209
193: ; preds = %168, %165, %173, %181, %163, %170
%194 = add nsw i64 %148, -1
%195 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %194
%196 = load i32, i32* %195
%197 = add nsw i64 %148, -2
%198 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %197
%199 = load i32, i32* %198
%200 = add nsw i64 %148, -3
%201 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %200
%202 = load i32, i32* %201
%203 = add i64 %148, -4
%204 = getelementptr inbounds [2048 x i32], [2048 x i32]* %6, i64 0, i64 %203
%205 = load i32, i32* %204
%206 = trunc i64 %203 to i32
%207 = icmp eq i32 %206, 0
%208 = trunc i64 %148 to i32
br i1 %207, label %184, label %147
209: ; preds = %144, %184, %191, %5
ret void
}