#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*/ exit(int);
int fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fread(char *, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ fwrite(char *, int, int, int /*<<< orphan*/ *);
void *malloc(int);
int /*<<< orphan*/ memset(char *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ strcmp(char *, char *);
int main(int argc, char *argv[]) {
  FILE *fd, *ofd;
  int *remap;
  char *buf, *outbuf;
  char *ifn, *ofn;
  char head[18];
  int s, e, w, h;
  int i, j, k, l;
  int x, y, rx, ry;
  int cw, ch, csz, isz;
  remap = malloc(65536 * sizeof(int));
  for (i = 0; i < 65536; i++)
    remap[i] = i;
  isz = 256;
  ifn = NULL;
  ofn = NULL;
  for (i = 1; i < argc; i++) {
    if (argv[i][0] == '-') {
      if (!strcmp(argv[i], "-latin1")) {
        isz = 16;
      }
    } else {
      if (!ifn) {
        ifn = argv[i];
      } else if (!ofn) {
        ofn = argv[i];
      }
    }
  }
  fd = fopen(ifn, "rb");
  ofd = fopen(ofn, "wb");
  s = fgetc(fd);
  s += fgetc(fd) << 8;
  e = fgetc(fd);
  e += fgetc(fd) << 8;
  if (s == 0xBF00) {
    buf = malloc(16);
    fread(buf, 1, e, fd);
    cw = buf[1];
    ch = buf[2];
    csz = (cw * ch + 7) / 8;
  } else {
    printf("no header\n");
    exit(-1);
  }
  outbuf = malloc(65536 * cw * ch * 3);
  memset(outbuf, 0, 65536 * cw * ch * 3);
  w = isz * cw;
  h = isz * ch;
  memset(head, 0, 18);
  head[2] = 2;
  head[12] = w & 0xff;
  head[13] = w >> 8;
  head[14] = h & 0xff;
  head[15] = h >> 8;
  head[16] = 24;
  fwrite(head, 1, 18, ofd);
  while (1) {
    s = fgetc(fd);
    s += fgetc(fd) << 8;
    e = fgetc(fd);
    e += fgetc(fd) << 8;
    if (!s && !e)
      break;
    printf("chunk %d-%d\n", s, e);
    buf = malloc(((e - s) + 1) * csz);
    fread(buf, (e - s) + 1, csz, fd);
    for (i = 0; i < ((e - s) + 1); i++) {
      j = i + s;
      j = remap[j];
      if (j < 0)
        continue;
      if (j > 65536)
        continue;
      x = (j % isz) * cw;
      y = (j / isz) * ch;
      if (y >= (isz * ch))
        continue;
      for (k = 0; k < csz; k++)
        for (l = 0; l < 8; l++) {
          if (buf[(i * csz) + k] & (128 >> l)) {
            rx = ((k * 8) + l) % cw;
            ry = ((k * 8) + l) / cw;
            outbuf[(((h - (y + ry) - 1) * w) + (x + rx)) * 3] = 0xff;
            outbuf[(((h - (y + ry) - 1) * w) + (x + rx)) * 3 + 1] = 0xff;
            outbuf[(((h - (y + ry) - 1) * w) + (x + rx)) * 3 + 2] = 0xff;
          }
        }
    }
  }
  fwrite(outbuf, isz * ch, isz * cw * 3, ofd);
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x40000,%edi
call   1080 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x74(%rbp)
cmpl   $0x10000,-0x74(%rbp)
jge    11e7 <main+0x57>
mov    -0x74(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    11be <main+0x2e>
movl   $0x100,-0xa0(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12b4 <main+0x124>
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsbl (%rax),%eax
cmp    $0x2d,%eax
jne    125c <main+0xcc>
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
lea    0xdc1(%rip),%rsi
call   1070 <strcmp@plt>
cmp    $0x0,%eax
jne    1257 <main+0xc7>
movl   $0x10,-0xa0(%rbp)
jmp    12a1 <main+0x111>
cmpq   $0x0,-0x40(%rbp)
jne    127c <main+0xec>
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
jmp    129c <main+0x10c>
cmpq   $0x0,-0x48(%rbp)
jne    1297 <main+0x107>
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x48(%rbp)
jmp    129c <main+0x10c>
jmp    12a1 <main+0x111>
jmp    12a6 <main+0x116>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1208 <main+0x78>
mov    -0x40(%rbp),%rdi
lea    0xd49(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x48(%rbp),%rdi
lea    0xd38(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
shl    $0x8,%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
shl    $0x8,%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
cmpl   $0xbf00,-0x64(%rbp)
jne    1387 <main+0x1f7>
mov    $0x10,%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x68(%rbp),%edx
mov    -0x18(%rbp),%rcx
mov    $0x1,%esi
call   1030 <fread@plt>
mov    -0x30(%rbp),%rax
movsbl 0x1(%rax),%eax
mov    %eax,-0x94(%rbp)
mov    -0x30(%rbp),%rax
movsbl 0x2(%rax),%eax
mov    %eax,-0x98(%rbp)
mov    -0x94(%rbp),%eax
imul   -0x98(%rbp),%eax
add    $0x7,%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,-0x9c(%rbp)
jmp    139f <main+0x20f>
lea    0xc80(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    $0xffffffff,%edi
call   10a0 <exit@plt>
mov    -0x94(%rbp),%eax
shl    $0x10,%eax
imul   -0x98(%rbp),%eax
imul   $0x3,%eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x94(%rbp),%eax
shl    $0x10,%eax
imul   -0x98(%rbp),%eax
imul   $0x3,%eax,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0xa0(%rbp),%eax
imul   -0x94(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0xa0(%rbp),%eax
imul   -0x98(%rbp),%eax
mov    %eax,-0x70(%rbp)
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x12,%edx
call   1050 <memset@plt>
movb   $0x2,-0x5e(%rbp)
mov    -0x6c(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x54(%rbp)
mov    -0x6c(%rbp),%eax
sar    $0x8,%eax
mov    %al,-0x53(%rbp)
mov    -0x70(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x52(%rbp)
mov    -0x70(%rbp),%eax
sar    $0x8,%eax
mov    %al,-0x51(%rbp)
movb   $0x18,-0x50(%rbp)
lea    -0x60(%rbp),%rdi
mov    -0x20(%rbp),%rcx
mov    $0x1,%esi
mov    $0x12,%edx
call   10b0 <fwrite@plt>
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
shl    $0x8,%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
mov    %eax,-0x68(%rbp)
mov    -0x18(%rbp),%rdi
call   1060 <fgetc@plt>
shl    $0x8,%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
cmpl   $0x0,-0x64(%rbp)
jne    14a5 <main+0x315>
cmpl   $0x0,-0x68(%rbp)
jne    14a5 <main+0x315>
jmp    16f1 <main+0x561>
mov    -0x64(%rbp),%esi
mov    -0x68(%rbp),%edx
lea    0xb67(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x68(%rbp),%edi
sub    -0x64(%rbp),%edi
add    $0x1,%edi
imul   -0x9c(%rbp),%edi
call   1080 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x68(%rbp),%esi
sub    -0x64(%rbp),%esi
add    $0x1,%esi
mov    -0x9c(%rbp),%edx
mov    -0x18(%rbp),%rcx
call   1030 <fread@plt>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x68(%rbp),%ecx
sub    -0x64(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    16ec <main+0x55c>
mov    -0x74(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
cmpl   $0x0,-0x78(%rbp)
jge    152f <main+0x39f>
jmp    16de <main+0x54e>
cmpl   $0x10000,-0x78(%rbp)
jle    1541 <main+0x3b1>
jmp    16de <main+0x54e>
mov    -0x78(%rbp),%eax
cltd
idivl  -0xa0(%rbp)
imul   -0x94(%rbp),%edx
mov    %edx,-0x84(%rbp)
mov    -0x78(%rbp),%eax
cltd
idivl  -0xa0(%rbp)
imul   -0x98(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0xa0(%rbp),%ecx
imul   -0x98(%rbp),%ecx
cmp    %ecx,%eax
jl     158f <main+0x3ff>
jmp    16de <main+0x54e>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jge    16d9 <main+0x549>
movl   $0x0,-0x80(%rbp)
cmpl   $0x8,-0x80(%rbp)
jge    16c6 <main+0x536>
mov    -0x30(%rbp),%rax
mov    -0x74(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x80(%rbp),%ecx
mov    $0x80,%edx
sar    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     16b3 <main+0x523>
mov    -0x7c(%rbp),%eax
shl    $0x3,%eax
add    -0x80(%rbp),%eax
cltd
idivl  -0x94(%rbp)
mov    %edx,-0x8c(%rbp)
mov    -0x7c(%rbp),%eax
shl    $0x3,%eax
add    -0x80(%rbp),%eax
cltd
idivl  -0x94(%rbp)
mov    %eax,-0x90(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x88(%rbp),%edx
add    -0x90(%rbp),%edx
sub    %edx,%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    -0x8c(%rbp),%edx
add    %edx,%ecx
imul   $0x3,%ecx,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x88(%rbp),%edx
add    -0x90(%rbp),%edx
sub    %edx,%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    -0x8c(%rbp),%edx
add    %edx,%ecx
imul   $0x3,%ecx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    -0x88(%rbp),%edx
add    -0x90(%rbp),%edx
sub    %edx,%ecx
sub    $0x1,%ecx
imul   -0x6c(%rbp),%ecx
mov    -0x84(%rbp),%edx
add    -0x8c(%rbp),%edx
add    %edx,%ecx
imul   $0x3,%ecx,%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movb   $0xff,(%rax,%rcx,1)
jmp    16b8 <main+0x528>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    15ac <main+0x41c>
jmp    16cb <main+0x53b>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1596 <main+0x406>
jmp    16de <main+0x54e>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    14f5 <main+0x365>
jmp    1450 <main+0x2c0>
mov    -0x38(%rbp),%rdi
mov    -0xa0(%rbp),%esi
imul   -0x98(%rbp),%esi
mov    -0xa0(%rbp),%eax
imul   -0x94(%rbp),%eax
imul   $0x3,%eax,%edx
mov    -0x20(%rbp),%rcx
call   10b0 <fwrite@plt>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rsi,%r14
mov    %edi,%ebx
mov    $0x40000,%edi
call   1090 <malloc@plt>
movdqa 0xe3b(%rip),%xmm0
xor    %ecx,%ecx
movdqa 0xe40(%rip),%xmm8
movdqa 0xe47(%rip),%xmm9
movdqa 0xe4e(%rip),%xmm10
movdqa 0xe56(%rip),%xmm4
movdqa 0xe5e(%rip),%xmm5
movdqa 0xe66(%rip),%xmm6
movdqa 0xe6e(%rip),%xmm7
movdqa 0xe76(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rax,%rcx,4)
movdqu %xmm2,0x10(%rax,%rcx,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rax,%rcx,4)
movdqu %xmm3,0x30(%rax,%rcx,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rax,%rcx,4)
movdqu %xmm3,0x50(%rax,%rcx,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rax,%rcx,4)
movdqu %xmm3,0x70(%rax,%rcx,4)
add    $0x20,%rcx
paddd  %xmm1,%xmm0
cmp    $0x10000,%rcx
jne    1210 <main+0x70>
cmp    $0x2,%ebx
mov    %rax,0x70(%rsp)
jl     12fd <main+0x15d>
mov    %ebx,%ebx
movl   $0x100,(%rsp)
mov    $0x1,%ebp
xor    %r12d,%r12d
mov    $0x10,%r15d
xor    %r13d,%r13d
jmp    12e1 <main+0x141>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0xdc9(%rip),%rsi
call   1080 <strcmp@plt>
test   %eax,%eax
mov    (%rsp),%eax
cmove  %r15d,%eax
mov    %eax,(%rsp)
add    $0x1,%rbp
cmp    %rbp,%rbx
je     130a <main+0x16a>
mov    (%r14,%rbp,8),%rdi
cmpb   $0x2d,(%rdi)
je     12c0 <main+0x120>
test   %r12,%r12
je     12f8 <main+0x158>
test   %r13,%r13
cmove  %rdi,%r13
jmp    12d8 <main+0x138>
mov    %rdi,%r12
jmp    12d8 <main+0x138>
movl   $0x100,(%rsp)
xor    %r13d,%r13d
xor    %r12d,%r12d
lea    0xd87(%rip),%rsi
mov    %r12,%rdi
call   10a0 <fopen@plt>
mov    %rax,%r15
lea    0xd78(%rip),%rsi
mov    %r13,%rdi
call   10a0 <fopen@plt>
mov    %rax,0x50(%rsp)
mov    %r15,%rdi
call   1070 <fgetc@plt>
mov    %eax,%ebx
mov    %r15,%rdi
call   1070 <fgetc@plt>
mov    %eax,%ebp
shl    $0x8,%ebp
add    %ebx,%ebp
mov    %r15,%rdi
call   1070 <fgetc@plt>
mov    %eax,%r14d
mov    %r15,%rdi
call   1070 <fgetc@plt>
cmp    $0xbf00,%ebp
jne    1658 <main+0x4b8>
mov    %eax,%ebx
shl    $0x8,%ebx
add    %r14d,%ebx
mov    $0x10,%edi
call   1090 <malloc@plt>
mov    %rax,%rbp
mov    $0x1,%eax
mov    %rax,0x18(%rsp)
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    %r15,%rcx
call   1040 <fread@plt>
movsbl 0x1(%rbp),%r14d
movsbl 0x2(%rbp),%r12d
mov    %r12d,%ecx
imul   %r14d,%ecx
lea    0x7(%rcx),%eax
lea    0xe(%rcx),%edx
test   %ax,%ax
cmovns %eax,%edx
mov    %edx,0x10(%rsp)
mov    %rcx,0x68(%rsp)
mov    %ecx,%eax
shl    $0x10,%eax
lea    (%rax,%rax,2),%ebp
mov    %ebp,%edi
call   1090 <malloc@plt>
mov    %r15,%r13
mov    %rax,%r15
mov    %rax,%rdi
xor    %esi,%esi
mov    %ebp,%edx
call   1060 <memset@plt>
mov    (%rsp),%ebp
mov    %ebp,%ebx
mov    %r14d,0x4(%rsp)
imul   %r14d,%ebx
mov    %r12d,0x2c(%rsp)
imul   %r12d,%ebp
mov    %r13,%r12
lea    0x30(%rsp),%rdi
xor    %esi,%esi
mov    $0x12,%edx
call   1060 <memset@plt>
movb   $0x2,0x32(%rsp)
mov    %bl,0x3c(%rsp)
mov    %rbx,%r14
mov    %bh,0x3d(%rsp)
mov    %ebp,%eax
mov    %al,0x3e(%rsp)
mov    %ebp,%r13d
mov    %ah,0x3f(%rsp)
movb   $0x18,0x40(%rsp)
lea    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    $0x12,%edx
mov    0x50(%rsp),%rcx
call   10c0 <fwrite@plt>
mov    %r12,%rdi
call   1070 <fgetc@plt>
mov    %eax,%ebx
mov    %r12,%rdi
call   1070 <fgetc@plt>
mov    %eax,%ebp
shl    $0x8,%ebp
add    %ebx,%ebp
mov    %r12,%rdi
call   1070 <fgetc@plt>
mov    %eax,0x20(%rsp)
mov    %r12,0x58(%rsp)
mov    %r12,%rdi
call   1070 <fgetc@plt>
mov    %eax,%ebx
shl    $0x8,%ebx
add    0x20(%rsp),%ebx
mov    %ebp,%eax
or     %ebx,%eax
je     1633 <main+0x493>
movswl 0x10(%rsp),%ecx
sar    $0x3,%ecx
cmp    $0x2,%ecx
mov    0x18(%rsp),%rax
cmovge %ecx,%eax
mov    %rax,0x18(%rsp)
mov    %ecx,0x28(%rsp)
movslq %ecx,%rax
mov    %rax,0x60(%rsp)
jmp    1505 <main+0x365>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rbx
mov    %rbx,%rdi
call   1070 <fgetc@plt>
mov    %eax,%r12d
mov    %rbx,%rdi
call   1070 <fgetc@plt>
mov    %eax,%ebp
shl    $0x8,%ebp
add    %r12d,%ebp
mov    %rbx,%rdi
call   1070 <fgetc@plt>
mov    %eax,%r12d
mov    %rbx,%rdi
call   1070 <fgetc@plt>
mov    %eax,%ebx
shl    $0x8,%ebx
add    %r12d,%ebx
mov    %ebp,%eax
or     %ebx,%eax
je     1633 <main+0x493>
mov    %ebp,0x8(%rsp)
lea    0xb8e(%rip),%rdi
mov    %ebp,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1050 <printf@plt>
sub    %ebp,%ebx
lea    0x1(%rbx),%r12d
mov    %r12d,%edi
mov    0x28(%rsp),%ebp
imul   %ebp,%edi
call   1090 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %rax,%rdi
mov    %r12,0x10(%rsp)
mov    %r12d,%esi
mov    %ebp,%edx
mov    0x58(%rsp),%rcx
call   1040 <fread@plt>
test   %ebx,%ebx
js     14c0 <main+0x320>
movslq 0x8(%rsp),%rax
mov    %rax,0x8(%rsp)
xor    %r9d,%r9d
jmp    157f <main+0x3df>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9
cmp    0x10(%rsp),%r9
je     14c0 <main+0x320>
mov    0x8(%rsp),%rax
add    %r9,%rax
mov    0x70(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
cmp    $0x10000,%eax
ja     1570 <main+0x3d0>
cltd
idivl  (%rsp)
mov    %eax,%edi
imul   0x2c(%rsp),%edi
mov    %r13d,%eax
cmp    %r13d,%edi
jge    1570 <main+0x3d0>
cmpw   $0x0,0x68(%rsp)
jle    1570 <main+0x3d0>
mov    %edx,%r8d
imul   0x4(%rsp),%r8d
mov    %r9,%r10
imul   0x60(%rsp),%r10
xor    %ebp,%ebp
xor    %r11d,%r11d
jmp    15de <main+0x43e>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    $0x8,%ebp
cmp    0x18(%rsp),%r11
je     1570 <main+0x3d0>
lea    (%r11,%r10,1),%rax
mov    0x20(%rsp),%rcx
movzbl (%rcx,%rax,1),%ebx
xor    %ecx,%ecx
jmp    15f8 <main+0x458>
nop
add    $0x1,%ecx
cmp    $0x8,%ecx
je     15d0 <main+0x430>
mov    %ebx,%eax
shl    %cl,%eax
test   $0x80,%al
je     15f0 <main+0x450>
lea    (%rcx,%rbp,1),%eax
cltd
idivl  0x4(%rsp)
add    %edi,%eax
not    %eax
mov    %r13d,%r12d
add    %r13d,%eax
mov    %r14,%rsi
imul   %esi,%eax
add    %r8d,%edx
add    %eax,%edx
movslq %edx,%rax
lea    (%rax,%rax,2),%rax
movb   $0xff,(%r15,%rax,1)
movw   $0xffff,0x1(%r15,%rax,1)
ff
jmp    15f0 <main+0x450>
lea    (%r14,%r14,2),%edx
mov    %r15,%rdi
mov    %r13d,%esi
mov    0x50(%rsp),%rcx
call   10c0 <fwrite@plt>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xa4c(%rip),%rdi
call   1030 <puts@plt>
mov    $0xffffffff,%edi
call   10b0 <exit@plt>

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

LLVM IR (-O2):
@.str = [8 x i8] c"-latin1\00"
@.str.1 = [3 x i8] c"rb\00"
@.str.2 = [3 x i8] c"wb\00"
@.str.4 = [13 x i8] c"chunk %d-%d\0A\00"
@str = [10 x i8] c"no header\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [18 x i8]
%4 = getelementptr inbounds [18 x i8], [18 x i8]* %3, i64 0, i64 0
%5 = tail call dereferenceable_or_null(262144) i8* @malloc(i32 262144)
%6 = bitcast i8* %5 to i32*
br label %7
7: ; preds = %7, %2
%8 = phi i64 [ 0, %2 ], [ %36, %7 ]
%9 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %2 ], [ %37, %7 ]
%10 = add <4 x i32> %9, <i32 4, i32 4, i32 4, i32 4>
%11 = getelementptr inbounds i32, i32* %6, i64 %8
%12 = bitcast i32* %11 to <4 x i32>*
store <4 x i32> %9, <4 x i32>* %12
%13 = getelementptr inbounds i32, i32* %11, i64 4
%14 = bitcast i32* %13 to <4 x i32>*
store <4 x i32> %10, <4 x i32>* %14
%15 = or i64 %8, 8
%16 = add <4 x i32> %9, <i32 8, i32 8, i32 8, i32 8>
%17 = add <4 x i32> %9, <i32 12, i32 12, i32 12, i32 12>
%18 = getelementptr inbounds i32, i32* %6, i64 %15
%19 = bitcast i32* %18 to <4 x i32>*
store <4 x i32> %16, <4 x i32>* %19
%20 = getelementptr inbounds i32, i32* %18, i64 4
%21 = bitcast i32* %20 to <4 x i32>*
store <4 x i32> %17, <4 x i32>* %21
%22 = or i64 %8, 16
%23 = add <4 x i32> %9, <i32 16, i32 16, i32 16, i32 16>
%24 = add <4 x i32> %9, <i32 20, i32 20, i32 20, i32 20>
%25 = getelementptr inbounds i32, i32* %6, i64 %22
%26 = bitcast i32* %25 to <4 x i32>*
store <4 x i32> %23, <4 x i32>* %26
%27 = getelementptr inbounds i32, i32* %25, i64 4
%28 = bitcast i32* %27 to <4 x i32>*
store <4 x i32> %24, <4 x i32>* %28
%29 = or i64 %8, 24
%30 = add <4 x i32> %9, <i32 24, i32 24, i32 24, i32 24>
%31 = add <4 x i32> %9, <i32 28, i32 28, i32 28, i32 28>
%32 = getelementptr inbounds i32, i32* %6, i64 %29
%33 = bitcast i32* %32 to <4 x i32>*
store <4 x i32> %30, <4 x i32>* %33
%34 = getelementptr inbounds i32, i32* %32, i64 4
%35 = bitcast i32* %34 to <4 x i32>*
store <4 x i32> %31, <4 x i32>* %35
%36 = add nuw nsw i64 %8, 32
%37 = add <4 x i32> %9, <i32 32, i32 32, i32 32, i32 32>
%38 = icmp eq i64 %36, 65536
br i1 %38, label %39, label %7
39: ; preds = %7
%40 = icmp sgt i32 %0, 1
br i1 %40, label %41, label %67
41: ; preds = %39
%42 = zext i32 %0 to i64
br label %43
43: ; preds = %41, %61
%44 = phi i64 [ 1, %41 ], [ %65, %61 ]
%45 = phi i32 [ 256, %41 ], [ %64, %61 ]
%46 = phi i8* [ null, %41 ], [ %63, %61 ]
%47 = phi i8* [ null, %41 ], [ %62, %61 ]
%48 = getelementptr inbounds i8*, i8** %1, i64 %44
%49 = load i8*, i8** %48
%50 = load i8, i8* %49
%51 = icmp eq i8 %50, 45
br i1 %51, label %52, label %56
52: ; preds = %43
%53 = tail call i32 @strcmp(i8* %49, i8* dereferenceable(8) getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0))
%54 = icmp eq i32 %53, 0
%55 = select i1 %54, i32 16, i32 %45
br label %61
56: ; preds = %43
%57 = icmp eq i8* %46, null
br i1 %57, label %61, label %58
58: ; preds = %56
%59 = icmp eq i8* %47, null
%60 = select i1 %59, i8* %49, i8* %47
br label %61
61: ; preds = %58, %52, %56
%62 = phi i8* [ %47, %52 ], [ %47, %56 ], [ %60, %58 ]
%63 = phi i8* [ %46, %52 ], [ %49, %56 ], [ %46, %58 ]
%64 = phi i32 [ %55, %52 ], [ %45, %56 ], [ %45, %58 ]
%65 = add nuw nsw i64 %44, 1
%66 = icmp eq i64 %65, %42
br i1 %66, label %67, label %43
67: ; preds = %61, %39
%68 = phi i8* [ null, %39 ], [ %62, %61 ]
%69 = phi i8* [ null, %39 ], [ %63, %61 ]
%70 = phi i32 [ 256, %39 ], [ %64, %61 ]
%71 = tail call i32* @fopen(i8* %69, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%72 = tail call i32* @fopen(i8* %68, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
%73 = tail call i32 @fgetc(i32* %71)
%74 = tail call i32 @fgetc(i32* %71)
%75 = shl i32 %74, 8
%76 = add nsw i32 %75, %73
%77 = tail call i32 @fgetc(i32* %71)
%78 = tail call i32 @fgetc(i32* %71)
%79 = icmp eq i32 %76, 48896
br i1 %79, label %80, label %132
80: ; preds = %67
%81 = shl i32 %78, 8
%82 = add nsw i32 %81, %77
%83 = tail call dereferenceable_or_null(16) i8* @malloc(i32 16)
%84 = tail call i32 @fread(i8* %83, i32 1, i32 %82, i32* %71)
%85 = getelementptr inbounds i8, i8* %83, i64 1
%86 = load i8, i8* %85
%87 = sext i8 %86 to i32
%88 = getelementptr inbounds i8, i8* %83, i64 2
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = mul nsw i32 %90, %87
%92 = trunc i32 %91 to i16
%93 = add nsw i16 %92, 7
%94 = sdiv i16 %93, 8
%95 = sext i16 %94 to i32
%96 = mul nsw i32 %87, 196608
%97 = mul i32 %96, %90
%98 = tail call i8* @malloc(i32 %97)
%99 = tail call i32 @memset(i8* %98, i32 0, i32 %97)
%100 = mul nsw i32 %70, %87
%101 = mul nsw i32 %70, %90
%102 = call i32 @memset(i8* %4, i32 0, i32 18)
%103 = getelementptr inbounds [18 x i8], [18 x i8]* %3, i64 0, i64 2
store i8 2, i8* %103
%104 = trunc i32 %100 to i8
%105 = getelementptr inbounds [18 x i8], [18 x i8]* %3, i64 0, i64 12
store i8 %104, i8* %105
%106 = lshr i32 %100, 8
%107 = trunc i32 %106 to i8
%108 = getelementptr inbounds [18 x i8], [18 x i8]* %3, i64 0, i64 13
store i8 %107, i8* %108
%109 = trunc i32 %101 to i8
%110 = getelementptr inbounds [18 x i8], [18 x i8]* %3, i64 0, i64 14
store i8 %109, i8* %110
%111 = lshr i32 %101, 8
%112 = trunc i32 %111 to i8
%113 = getelementptr inbounds [18 x i8], [18 x i8]* %3, i64 0, i64 15
store i8 %112, i8* %113
%114 = getelementptr inbounds [18 x i8], [18 x i8]* %3, i64 0, i64 16
store i8 24, i8* %114
%115 = call i32 @fwrite(i8* %4, i32 1, i32 18, i32* %72)
%116 = call i32 @fgetc(i32* %71)
%117 = call i32 @fgetc(i32* %71)
%118 = shl i32 %117, 8
%119 = add nsw i32 %118, %116
%120 = call i32 @fgetc(i32* %71)
%121 = call i32 @fgetc(i32* %71)
%122 = shl i32 %121, 8
%123 = add nsw i32 %122, %120
%124 = icmp ne i32 %119, 0
%125 = icmp ne i32 %123, 0
%126 = select i1 %124, i1 true, i1 %125
br i1 %126, label %127, label %218
127: ; preds = %80
%128 = icmp slt i16 %92, 1
%129 = call i32 @llvm.smax.i32(i32 %95, i32 1)
%130 = sext i16 %94 to i64
%131 = zext i32 %129 to i64
br label %147
132: ; preds = %67
%133 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str, i64 0, i64 0))
%134 = tail call i32 @exit(i32 -1)
unreachable
135: ; preds = %215, %147
%136 = call i32 @fgetc(i32* %71)
%137 = call i32 @fgetc(i32* %71)
%138 = shl i32 %137, 8
%139 = add nsw i32 %138, %136
%140 = call i32 @fgetc(i32* %71)
%141 = call i32 @fgetc(i32* %71)
%142 = shl i32 %141, 8
%143 = add nsw i32 %142, %140
%144 = icmp ne i32 %139, 0
%145 = icmp ne i32 %143, 0
%146 = select i1 %144, i1 true, i1 %145
br i1 %146, label %147, label %218
147: ; preds = %127, %135
%148 = phi i32 [ %123, %127 ], [ %143, %135 ]
%149 = phi i32 [ %119, %127 ], [ %139, %135 ]
%150 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0), i32 %149, i32 %148)
%151 = sub nsw i32 %148, %149
%152 = add nsw i32 %151, 1
%153 = mul nsw i32 %152, %95
%154 = call i8* @malloc(i32 %153)
%155 = call i32 @fread(i8* %154, i32 %152, i32 %95, i32* %71)
%156 = icmp slt i32 %151, 0
br i1 %156, label %135, label %157
157: ; preds = %147
%158 = sext i32 %149 to i64
%159 = add i32 %148, 1
%160 = sub i32 %159, %149
%161 = zext i32 %160 to i64
br label %162
162: ; preds = %157, %215
%163 = phi i64 [ 0, %157 ], [ %216, %215 ]
%164 = add nsw i64 %163, %158
%165 = getelementptr inbounds i32, i32* %6, i64 %164
%166 = load i32, i32* %165
%167 = icmp ugt i32 %166, 65536
br i1 %167, label %215, label %168
168: ; preds = %162
%169 = srem i32 %166, %70
%170 = mul nsw i32 %169, %87
%171 = sdiv i32 %166, %70
%172 = mul nsw i32 %171, %90
%173 = icmp sge i32 %172, %101
%174 = select i1 %173, i1 true, i1 %128
br i1 %174, label %215, label %175
175: ; preds = %168
%176 = mul nsw i64 %163, %130
br label %177
177: ; preds = %175, %212
%178 = phi i64 [ 0, %175 ], [ %213, %212 ]
%179 = add nsw i64 %178, %176
%180 = getelementptr inbounds i8, i8* %154, i64 %179
%181 = load i8, i8* %180
%182 = zext i8 %181 to i32
%183 = trunc i64 %178 to i32
%184 = shl i32 %183, 3
br label %185
185: ; preds = %177, %209
%186 = phi i32 [ 0, %177 ], [ %210, %209 ]
%187 = lshr i32 128, %186
%188 = and i32 %187, %182
%189 = icmp eq i32 %188, 0
br i1 %189, label %209, label %190
190: ; preds = %185
%191 = add nuw nsw i32 %186, %184
%192 = srem i32 %191, %87
%193 = sdiv i32 %191, %87
%194 = add nsw i32 %193, %172
%195 = xor i32 %194, -1
%196 = add i32 %101, %195
%197 = mul nsw i32 %196, %100
%198 = add nsw i32 %192, %170
%199 = add nsw i32 %198, %197
%200 = mul nsw i32 %199, 3
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i8, i8* %98, i64 %201
store i8 -1, i8* %202
%203 = add nsw i32 %200, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i8, i8* %98, i64 %204
store i8 -1, i8* %205
%206 = add nsw i32 %200, 2
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i8, i8* %98, i64 %207
store i8 -1, i8* %208
br label %209
209: ; preds = %185, %190
%210 = add nuw nsw i32 %186, 1
%211 = icmp eq i32 %210, 8
br i1 %211, label %212, label %185
212: ; preds = %209
%213 = add nuw nsw i64 %178, 1
%214 = icmp eq i64 %213, %131
br i1 %214, label %215, label %177
215: ; preds = %212, %168, %162
%216 = add nuw nsw i64 %163, 1
%217 = icmp eq i64 %216, %161
br i1 %217, label %135, label %162
218: ; preds = %135, %80
%219 = mul nsw i32 %100, 3
%220 = call i32 @fwrite(i8* %98, i32 %101, i32 %219, i32* %72)
ret i32 0
}