#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int i4_min(int, int);
double sqrt(double);
int main(void) {
  int m = 2048;
  int n = 2048;
  int b[m][n];
  int c;
  int c_max;
  int count[m][n];
  int count_max = 2000;
  int g[m][n];
  int i;
  int ierror;
  int j;
  int jhi;
  int jlo;
  int k;
  char *output_filename = "mandelbrot.ppm";
  FILE *output_unit;
  int r[m][n];
  double x_max = 1.25;
  double x_min = -2.25;
  double x;
  double x1;
  double x2;
  double y_max = 1.75;
  double y_min = -1.75;
  double y;
  double y1;
  double y2;
#pragma omp parallel for shared(b, count, count_max, g, r, x_max, x_min,       \
                                y_max, y_min) private(i, j, k, x, x1, x2, y,   \
                                                      y1, y2) check
  for (i = 0; i < m; i++) {
    for (j = 0; j < n; j++) {
      x = ((double)(j - 1) * x_max + (double)(m - j) * x_min) / (double)(m - 1);
      y = ((double)(i - 1) * y_max + (double)(n - i) * y_min) / (double)(n - 1);
      count[i][j] = 0;
      x1 = x;
      y1 = y;
      for (k = 1; k <= count_max; k++) {
        x2 = x1 * x1 - y1 * y1 + x;
        y2 = 2 * x1 * y1 + y;
        if (x2 < -2.0 || 2.0 < x2 || y2 < -2.0 || 2.0 < y2) {
          count[i][j] = k;
          break;
        }
        x1 = x2;
        y1 = y2;
      }
      if ((count[i][j] % 2) == 1) {
        r[i][j] = 255;
        g[i][j] = 255;
        b[i][j] = 255;
      } else {
        c = (int)(255.0 * sqrt(sqrt(sqrt(
                              ((double)(count[i][j]) / (double)(count_max))))));
        r[i][j] = 3 * c / 5;
        g[i][j] = 3 * c / 5;
        b[i][j] = c;
      }
    }
  }
  output_unit = fopen(output_filename, "wt");
  fprintf(output_unit, "P3\n");
  fprintf(output_unit, "%d  %d\n", n, m);
  fprintf(output_unit, "%d\n", 255);
  for (i = 0; i < m; i++) {
    for (jlo = 0; jlo < n; jlo = jlo + 4) {
      jhi = i4_min(jlo + 4, n);
      for (j = jlo; j < jhi; j++) {
        fprintf(output_unit, "  %d  %d  %d", r[i][j], g[i][j], b[i][j]);
      }
      fprintf(output_unit, "\n");
    }
  }
  fclose(output_unit);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x800,-0x8(%rbp)
movl   $0x800,-0xc(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0x120(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x18(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x118(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x20(%rbp)
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0x110(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x108(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
movl   $0x7d0,-0x44(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0x100(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xf8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x50(%rbp)
mov    %rax,-0x58(%rbp)
lea    0xe05(%rip),%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
mov    -0xc(%rbp),%eax
mov    %rax,-0xf0(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xe8(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x88(%rbp)
mov    %rax,-0x90(%rbp)
movsd  0xd99(%rip),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  0xd81(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0xd69(%rip),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0xd51(%rip),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    16ad <main+0x55d>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    169a <main+0x54a>
mov    -0x108(%rbp),%rax
mov    -0x110(%rbp),%rdx
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
cvtsi2sd %ecx,%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mov    -0x8(%rbp),%ecx
sub    -0x64(%rbp),%ecx
cvtsi2sd %ecx,%xmm1
mulsd  -0xa0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x8(%rbp),%ecx
sub    $0x1,%ecx
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x5c(%rbp),%ecx
sub    $0x1,%ecx
cvtsi2sd %ecx,%xmm0
movsd  -0xc0(%rbp),%xmm2
ff
mov    -0xc(%rbp),%ecx
sub    -0x5c(%rbp),%ecx
cvtsi2sd %ecx,%xmm1
mulsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cvtsi2sd %ecx,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movslq -0x5c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     14f5 <main+0x3a5>
movsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xb0(%rbp),%xmm2
ff
movsd  -0xd8(%rbp),%xmm1
ff
mulsd  -0xd8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  0xc15(%rip),%xmm0
mulsd  -0xb0(%rbp),%xmm0
ff
movsd  -0xd8(%rbp),%xmm2
ff
movsd  -0xd0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  0xbdd(%rip),%xmm0
ucomisd -0xb8(%rbp),%xmm0
ff
ja     149b <main+0x34b>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  0xbc7(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     149b <main+0x34b>
movsd  0xbad(%rip),%xmm0
ucomisd -0xe0(%rbp),%xmm0
ff
ja     149b <main+0x34b>
movsd  -0xe0(%rbp),%xmm0
ff
movsd  0xb97(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    14c7 <main+0x377>
mov    -0x108(%rbp),%rax
mov    -0x110(%rbp),%rsi
mov    -0x70(%rbp),%edx
movslq -0x5c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    14f5 <main+0x3a5>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    13b0 <main+0x260>
mov    -0x108(%rbp),%rax
mov    -0x110(%rbp),%rdx
movslq -0x5c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    15a8 <main+0x458>
mov    -0x118(%rbp),%rax
mov    -0x120(%rbp),%rdx
mov    -0xf8(%rbp),%rcx
mov    -0x100(%rbp),%rdi
mov    -0xe8(%rbp),%rsi
mov    -0xf0(%rbp),%r9
movslq -0x5c(%rbp),%r8
imul   %r9,%r8
shl    $0x2,%r8
add    %r8,%rsi
movslq -0x64(%rbp),%r8
movl   $0xff,(%rsi,%r8,4)
movslq -0x5c(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x2,%rsi
add    %rsi,%rcx
movslq -0x64(%rbp),%rsi
movl   $0xff,(%rcx,%rsi,4)
movslq -0x5c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
movl   $0xff,(%rax,%rcx,4)
jmp    1687 <main+0x537>
mov    -0x108(%rbp),%rax
mov    -0x110(%rbp),%rdx
movslq -0x5c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
cvtsi2sdl -0x44(%rbp),%xmm1
divsd  %xmm1,%xmm0
call   1070 <sqrt@plt>
call   1070 <sqrt@plt>
call   1070 <sqrt@plt>
mov    -0xf0(%rbp),%r9
mov    -0x100(%rbp),%r8
mov    -0xf8(%rbp),%rcx
mov    -0x120(%rbp),%rsi
movaps %xmm0,%xmm1
movsd  0xa23(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x2c(%rbp)
imul   $0x3,-0x2c(%rbp),%eax
mov    $0x5,%edi
cltd
idiv   %edi
mov    %eax,%edi
mov    -0xe8(%rbp),%rax
movslq -0x5c(%rbp),%rdx
imul   %r9,%rdx
shl    $0x2,%rdx
add    %rdx,%rax
movslq -0x64(%rbp),%rdx
mov    %edi,(%rax,%rdx,4)
imul   $0x3,-0x2c(%rbp),%eax
mov    $0x5,%edi
cltd
idiv   %edi
mov    %eax,%edi
mov    -0x118(%rbp),%rax
movslq -0x5c(%rbp),%rdx
imul   %r8,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x64(%rbp),%rdx
mov    %edi,(%rcx,%rdx,4)
mov    -0x2c(%rbp),%edx
movslq -0x5c(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    168c <main+0x53c>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    12d1 <main+0x181>
jmp    169f <main+0x54f>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12be <main+0x16e>
mov    -0x78(%rbp),%rdi
lea    0x98f(%rip),%rsi
call   1060 <fopen@plt>
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rdi
lea    0x97e(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x80(%rbp),%rdi
mov    -0xc(%rbp),%edx
mov    -0x8(%rbp),%ecx
lea    0x96a(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x80(%rbp),%rdi
lea    0x95c(%rip),%rsi
mov    $0xff,%edx
mov    $0x0,%al
call   1040 <fprintf@plt>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    180b <main+0x6bb>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17f8 <main+0x6a8>
mov    -0x6c(%rbp),%edi
add    $0x4,%edi
mov    -0xc(%rbp),%esi
call   1050 <i4_min@plt>
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    17d8 <main+0x688>
mov    -0x118(%rbp),%rax
mov    -0x120(%rbp),%r8
mov    -0xf8(%rbp),%rcx
mov    -0x100(%rbp),%r9
mov    -0xe8(%rbp),%rdx
mov    -0xf0(%rbp),%r10
mov    -0x80(%rbp),%rdi
movslq -0x5c(%rbp),%rsi
imul   %r10,%rsi
shl    $0x2,%rsi
add    %rsi,%rdx
movslq -0x64(%rbp),%rsi
mov    (%rdx,%rsi,4),%edx
movslq -0x5c(%rbp),%rsi
imul   %r9,%rsi
shl    $0x2,%rsi
add    %rsi,%rcx
movslq -0x64(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
movslq -0x5c(%rbp),%rsi
imul   %r8,%rsi
shl    $0x2,%rsi
add    %rsi,%rax
movslq -0x64(%rbp),%rsi
mov    (%rax,%rsi,4),%r8d
lea    0x893(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    173f <main+0x5ef>
mov    -0x80(%rbp),%rdi
lea    0x869(%rip),%rsi
mov    $0x0,%al
call   1040 <fprintf@plt>
mov    -0x6c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x6c(%rbp)
jmp    171c <main+0x5cc>
jmp    17fd <main+0x6ad>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1709 <main+0x5b9>
mov    -0x80(%rbp),%rdi
call   1030 <fclose@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3000048,%rsp
xor    %r14d,%r14d
movsd  0xe9c(%rip),%xmm5
xorpd  %xmm8,%xmm8
movsd  0xe97(%rip),%xmm7
jmp    11b1 <main+0x41>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r14
cmp    $0x800,%r14
je     1399 <main+0x229>
lea    -0x1(%r14),%eax
xorps  %xmm6,%xmm6
cvtsi2sd %eax,%xmm6
mov    $0x800,%eax
sub    %r14d,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mulsd  0xe2d(%rip),%xmm0
mulsd  0xe2d(%rip),%xmm6
addsd  %xmm0,%xmm6
divsd  0xe29(%rip),%xmm6
mov    %r14,%rax
shl    $0xd,%rax
lea    (%rsp,%rax,1),%r15
add    $0x40,%r15
lea    (%rsp,%rax,1),%r12
add    $0x1000040,%r12
lea    (%rsp,%rax,1),%r13
add    $0x2000040,%r13
xor    %ebx,%ebx
movsd  %xmm6,(%rsp)
jmp    1282 <main+0x112>
cs nopw 0x0(%rax,%rax,1)
nop
call   1080 <sqrt@plt>
xorpd  %xmm8,%xmm8
movsd  0xdf6(%rip),%xmm5
movsd  0xdf6(%rip),%xmm7
movsd  (%rsp),%xmm6
mulsd  0xdf9(%rip),%xmm0
cvttsd2si %xmm0,%ecx
lea    (%rcx,%rcx,2),%eax
cltq
imul   $0x66666667,%rax,%rdx
mov    %rdx,%rax
shr    $0x3f,%rax
sar    $0x21,%rdx
add    %eax,%edx
mov    %edx,(%r15,%rbx,4)
mov    %edx,(%r12,%rbx,4)
mov    %ecx,0x0(%r13,%rbx,4)
add    $0x1,%rbx
cmp    $0x800,%rbx
je     11a0 <main+0x30>
lea    -0x1(%rbx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
mov    $0x800,%eax
sub    %ebx,%eax
xorps  %xmm1,%xmm1
cvtsi2sd %eax,%xmm1
mulsd  0xd76(%rip),%xmm1
mulsd  0xd76(%rip),%xmm0
addsd  %xmm1,%xmm0
divsd  0xd5a(%rip),%xmm0
mov    $0x1,%eax
movapd %xmm6,%xmm1
movapd %xmm0,%xmm3
movapd %xmm0,%xmm2
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm4
mulsd  %xmm1,%xmm4
mulsd  %xmm2,%xmm2
subsd  %xmm4,%xmm2
addsd  %xmm0,%xmm2
ucomisd %xmm2,%xmm5
ja     1320 <main+0x1b0>
ucomisd %xmm7,%xmm2
ja     1320 <main+0x1b0>
addsd  %xmm3,%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm6,%xmm1
ucomisd %xmm1,%xmm5
ja     1320 <main+0x1b0>
ucomisd %xmm7,%xmm1
ja     1320 <main+0x1b0>
add    $0x1,%eax
movapd %xmm2,%xmm3
cmp    $0x7d1,%eax
jne    12d0 <main+0x160>
xor    %eax,%eax
jmp    1332 <main+0x1c2>
nopw   0x0(%rax,%rax,1)
mov    $0xff,%edx
mov    $0xff,%ecx
test   $0x1,%al
jne    1264 <main+0xf4>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  0xcf7(%rip),%xmm0
ucomisd %xmm8,%xmm0
jb     1370 <main+0x200>
sqrtsd %xmm0,%xmm0
ucomisd %xmm8,%xmm0
jae    1381 <main+0x211>
call   1080 <sqrt@plt>
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm0
jb     1220 <main+0xb0>
jmp    1390 <main+0x220>
nopw   0x0(%rax,%rax,1)
call   1080 <sqrt@plt>
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm0
jb     1353 <main+0x1e3>
sqrtsd %xmm0,%xmm0
ucomisd %xmm8,%xmm0
jb     1220 <main+0xb0>
sqrtsd %xmm0,%xmm0
jmp    122a <main+0xba>
lea    0xca8(%rip),%rdi
lea    0xcb0(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,%r14
lea    0xca4(%rip),%rdi
mov    $0x3,%esi
mov    $0x1,%edx
mov    %rax,%rcx
call   1090 <fwrite@plt>
lea    0xc8f(%rip),%rsi
mov    %r14,%rdi
mov    $0x800,%edx
mov    $0x800,%ecx
xor    %eax,%eax
call   1050 <fprintf@plt>
lea    0xc78(%rip),%rsi
mov    %r14,%rdi
mov    $0xff,%edx
xor    %eax,%eax
call   1050 <fprintf@plt>
lea    0x2000040(%rsp),%r15
lea    0x1000040(%rsp),%r12
01
lea    0x40(%rsp),%rbp
xor    %eax,%eax
jmp    1459 <main+0x2e9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x18(%rsp),%rax
add    $0x1,%rax
mov    0x30(%rsp),%r15
add    $0x2000,%r15
mov    0x28(%rsp),%r12
add    $0x2000,%r12
mov    0x20(%rsp),%rbp
add    $0x2000,%rbp
cmp    $0x800,%rax
je     1532 <main+0x3c2>
mov    %rax,0x18(%rsp)
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    %rbp,0x20(%rsp)
mov    %r12,0x28(%rsp)
mov    %r12,%rax
mov    %r15,0x30(%rsp)
xor    %edi,%edi
jmp    14bc <main+0x34c>
nopl   0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r9,%r14
mov    %r9,%rsi
call   1040 <fputc@plt>
add    $0x10,%r15
mov    %rbp,%rax
add    $0x10,%rax
mov    (%rsp),%rbp
add    $0x10,%rbp
addq   $0xfffffffffffffffc,0x10(%rsp)
cmpl   $0x7fc,0xc(%rsp)
mov    0x38(%rsp),%rdi
jae    1420 <main+0x2b0>
mov    %rbp,(%rsp)
mov    %edi,%ebx
add    $0x4,%rdi
mov    %rdi,0x38(%rsp)
mov    $0x800,%esi
mov    %rax,%rbp
call   1060 <i4_min@plt>
mov    %ebx,0xc(%rsp)
cmp    %ebx,%eax
mov    %r14,%r9
lea    0xb7e(%rip),%r12
jle    1480 <main+0x310>
mov    %eax,%r14d
add    0x10(%rsp),%r14
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%rax
mov    (%rax,%r13,4),%edx
mov    0x0(%rbp,%r13,4),%ecx
mov    (%r15,%r13,4),%r8d
mov    %r9,%rdi
mov    %r9,%rbx
mov    %r12,%rsi
xor    %eax,%eax
call   1050 <fprintf@plt>
mov    %rbx,%r9
add    $0x1,%r13
cmp    %r13,%r14
jne    1500 <main+0x390>
jmp    1480 <main+0x310>
mov    %r14,%rdi
call   1030 <fclose@plt>
xor    %eax,%eax
add    $0x3000048,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [15 x i8] c"mandelbrot.ppm\00"
@.str.1 = [3 x i8] c"wt\00"
@.str.2 = [4 x i8] c"P3\0A\00"
@.str.3 = [8 x i8] c"%d %d\0A\00"
@.str.4 = [4 x i8] c"%d\0A\00"
@.str.5 = [13 x i8] c" %d %d %d\00"
define i32 @main() {
%1 = alloca [4194304 x i32]
%2 = alloca [4194304 x i32]
%3 = alloca [4194304 x i32]
br label %4
4: ; preds = %0, %72
%5 = phi i64 [ 0, %0 ], [ %73, %72 ]
%6 = trunc i64 %5 to i32
%7 = add i32 %6, -1
%8 = sitofp i32 %7 to double
%9 = trunc i64 %5 to i32
%10 = sub i32 2048, %9
%11 = sitofp i32 %10 to double
%12 = fmul double %11, -1.750000e+00
%13 = tail call double @llvm.fmuladd.f64(double %8, double 1.750000e+00, double %12)
%14 = fdiv double %13, 2.047000e+03
%15 = shl nuw nsw i64 %5, 11
%16 = getelementptr inbounds [4194304 x i32], [4194304 x i32]* %3, i64 0, i64 %15
%17 = getelementptr inbounds [4194304 x i32], [4194304 x i32]* %2, i64 0, i64 %15
%18 = getelementptr inbounds [4194304 x i32], [4194304 x i32]* %1, i64 0, i64 %15
br label %19
19: ; preds = %4, %64
%20 = phi i64 [ 0, %4 ], [ %70, %64 ]
%21 = trunc i64 %20 to i32
%22 = add i32 %21, -1
%23 = sitofp i32 %22 to double
%24 = trunc i64 %20 to i32
%25 = sub i32 2048, %24
%26 = sitofp i32 %25 to double
%27 = fmul double %26, -2.250000e+00
%28 = tail call double @llvm.fmuladd.f64(double %23, double 1.250000e+00, double %27)
%29 = fdiv double %28, 2.047000e+03
br label %30
30: ; preds = %19, %47
%31 = phi double [ %14, %19 ], [ %39, %47 ]
%32 = phi i32 [ 1, %19 ], [ %48, %47 ]
%33 = phi double [ %29, %19 ], [ %37, %47 ]
%34 = fneg double %31
%35 = fmul double %31, %34
%36 = tail call double @llvm.fmuladd.f64(double %33, double %33, double %35)
%37 = fadd double %29, %36
%38 = fmul double %33, 2.000000e+00
%39 = tail call double @llvm.fmuladd.f64(double %38, double %31, double %14)
%40 = fcmp olt double %37, -2.000000e+00
%41 = fcmp ogt double %37, 2.000000e+00
%42 = or i1 %40, %41
%43 = fcmp olt double %39, -2.000000e+00
%44 = select i1 %42, i1 true, i1 %43
%45 = fcmp ogt double %39, 2.000000e+00
%46 = select i1 %44, i1 true, i1 %45
br i1 %46, label %50, label %47
47: ; preds = %30
%48 = add nuw nsw i32 %32, 1
%49 = icmp eq i32 %48, 2001
br i1 %49, label %53, label %30
50: ; preds = %30
%51 = and i32 %32, 1
%52 = icmp eq i32 %51, 0
br i1 %52, label %53, label %64
53: ; preds = %47, %50
%54 = phi i32 [ %32, %50 ], [ 0, %47 ]
%55 = sitofp i32 %54 to double
%56 = fdiv double %55, 2.000000e+03
%57 = tail call double @sqrt(double %56)
%58 = tail call double @sqrt(double %57)
%59 = tail call double @sqrt(double %58)
%60 = fmul double %59, 2.550000e+02
%61 = fptosi double %60 to i32
%62 = mul nsw i32 %61, 3
%63 = sdiv i32 %62, 5
br label %64
64: ; preds = %50, %53
%65 = phi i32 [ %63, %53 ], [ 255, %50 ]
%66 = phi i32 [ %61, %53 ], [ 255, %50 ]
%67 = getelementptr inbounds i32, i32* %16, i64 %20
store i32 %65, i32* %67
%68 = getelementptr inbounds i32, i32* %17, i64 %20
store i32 %65, i32* %68
%69 = getelementptr inbounds i32, i32* %18, i64 %20
store i32 %66, i32* %69
%70 = add nuw nsw i64 %20, 1
%71 = icmp eq i64 %70, 2048
br i1 %71, label %72, label %19
72: ; preds = %64
%73 = add nuw nsw i64 %5, 1
%74 = icmp eq i64 %73, 2048
br i1 %74, label %75, label %4
75: ; preds = %72
%76 = tail call i32* @fopen(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%77 = tail call i64 @fwrite(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i64 3, i64 1, i32* %76)
%78 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %76, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0), i32 2048, i32 2048)
%79 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %76, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i64 0, i64 0), i32 255)
br label %80
80: ; preds = %75, %109
%81 = phi i64 [ 0, %75 ], [ %110, %109 ]
%82 = shl nuw nsw i64 %81, 11
%83 = getelementptr inbounds [4194304 x i32], [4194304 x i32]* %3, i64 0, i64 %82
%84 = getelementptr inbounds [4194304 x i32], [4194304 x i32]* %2, i64 0, i64 %82
%85 = getelementptr inbounds [4194304 x i32], [4194304 x i32]* %1, i64 0, i64 %82
br label %86
86: ; preds = %80, %106
%87 = phi i64 [ 0, %80 ], [ %89, %106 ]
%88 = trunc i64 %87 to i32
%89 = add nuw nsw i64 %87, 4
%90 = trunc i64 %89 to i32
%91 = tail call i32 @i4_min(i32 %90, i32 2048)
%92 = icmp sgt i32 %91, %88
br i1 %92, label %93, label %106
93: ; preds = %86
%94 = zext i32 %91 to i64
br label %95
95: ; preds = %93, %95
%96 = phi i64 [ %87, %93 ], [ %104, %95 ]
%97 = getelementptr inbounds i32, i32* %83, i64 %96
%98 = load i32, i32* %97
%99 = getelementptr inbounds i32, i32* %84, i64 %96
%100 = load i32, i32* %99
%101 = getelementptr inbounds i32, i32* %85, i64 %96
%102 = load i32, i32* %101
%103 = tail call i32 (i32*, i8*, ...) @fprintf(i32* %76, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.5, i64 0, i64 0), i32 %98, i32 %100, i32 %102)
%104 = add nuw nsw i64 %96, 1
%105 = icmp eq i64 %104, %94
br i1 %105, label %106, label %95
106: ; preds = %95, %86
%107 = tail call i32 @fputc(i32 10, i32* %76)
%108 = icmp ult i32 %88, 2044
br i1 %108, label %86, label %109
109: ; preds = %106
%110 = add nuw nsw i64 %81, 1
%111 = icmp eq i64 %110, 2048
br i1 %111, label %112, label %80
112: ; preds = %109
%113 = tail call i32 @fclose(i32* %76)
ret i32 0
}