#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 */
char EOF;
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ free(char *);
char getc(int /*<<< orphan*/ *);
char *malloc(unsigned int);
int /*<<< orphan*/ printf(char *, char *);
char *realloc(char *, unsigned int);
int main(int argc, char *argv[]) {
  FILE *fp;
  unsigned ss = 0, sbs = 192, cs1 = 0, cs2 = 0, cb1s = 32, cb2s = 32, i, j, d;
  char *sb = malloc(sbs), *cb1 = malloc(cb1s), *cb2 = malloc(cb2s);
  char c;
  if (argc != 2) {
    printf("Usage: %s [FILE]\n", argv[0]);
    return 1;
  }
  fp = fopen(*++argv, "r");
  while ((c = getc(fp)) != EOF) {
    while (c != ';') {
      if (ss == sbs - 1) {
        sbs += sbs / 2;
        sb = realloc(sb, sbs);
      }
      sb[ss++] = c;
      c = getc(fp);
    }
    do {
      while ((c = getc(fp)) != ',') {
        if (cs1 == cb1s) {
          cb1s += cb1s / 2;
          cb1 = realloc(cb1, cb1s);
        }
        cb1[cs1++] = c;
      }
      while ((c = getc(fp)) == '0' || c == '1') {
        if (cs2 == cb2s) {
          cb2s += cb2s / 2;
          cb2 = realloc(cb2, cb2s);
        }
        cb2[cs2++] = c - '0' + 'a';
      }
      if (cs2 == 0) {
        cb2[0] = 'x';
        cs2 = 1;
      }
      for (i = 0; i < ss - cs1 + 1; i++) {
        bool f = true;
        for (j = 0; j < cs1; j++) {
          if (sb[i + j] != cb1[j]) {
            f = false;
            break;
          }
        }
        if (!f) {
          continue;
        }
        if (cs1 < cs2) {
          d = cs2 - cs1;
          while (ss + d >= sbs - 1) {
            sbs += sbs / 2;
            sb = realloc(sb, sbs);
          }
          ss += d;
          for (j = ss - 1; j >= i + cs1 + d; j--) {
            sb[j] = sb[j - d];
          }
        } else if (cs1 > cs2) {
          d = cs1 - cs2;
          for (j = i + cs2; j < ss - d; j++) {
            sb[j] = sb[j + d];
          }
          ss -= d;
        }
        for (j = 0; j < cs2; j++) {
          sb[i + j] = cb2[j];
        }
      }
      cs1 = 0;
      cs2 = 0;
    } while (c == ',');
    sb[ss] = '\0';
    for (i = ss; i > 0; i--) {
      switch (sb[i - 1]) {
      case 'a':
        sb[i - 1] = '0';
        break;
      case 'b':
        sb[i - 1] = '1';
        break;
      case 'x':
        for (j = i - 1; j < ss; j++) {
          sb[j] = sb[j + 1];
        }
        ss--;
      }
    }
    printf("%s\n", sb);
    ss = 0;
  }
  free(sb);
  free(cb1);
  free(cb2);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0xc0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x20,-0x2c(%rbp)
movl   $0x20,-0x30(%rbp)
mov    -0x20(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x2c(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmpl   $0x2,-0x8(%rbp)
je     11ed <main+0x8d>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xe24(%rip),%rdi
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    16ae <main+0x54e>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x8(%rax),%rdi
lea    0xe0b(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1080 <getc@plt>
mov    %al,-0x59(%rbp)
movsbl %al,%eax
mov    0x2dc2(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     168c <main+0x52c>
jmp    1236 <main+0xd6>
movsbl -0x59(%rbp),%eax
cmp    $0x3b,%eax
je     1298 <main+0x138>
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1270 <main+0x110>
mov    -0x20(%rbp),%eax
shr    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x59(%rbp),%dl
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
call   1080 <getc@plt>
mov    %al,-0x59(%rbp)
jmp    1236 <main+0xd6>
jmp    129d <main+0x13d>
jmp    12a2 <main+0x142>
mov    -0x18(%rbp),%rdi
call   1080 <getc@plt>
mov    %al,-0x59(%rbp)
movsbl %al,%eax
cmp    $0x2c,%eax
je     12fe <main+0x19e>
mov    -0x24(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jne    12e2 <main+0x182>
mov    -0x2c(%rbp),%eax
shr    $0x1,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x2c(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x59(%rbp),%dl
mov    -0x50(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    12a2 <main+0x142>
jmp    1303 <main+0x1a3>
mov    -0x18(%rbp),%rdi
call   1080 <getc@plt>
mov    %al,-0x59(%rbp)
movsbl %al,%ecx
mov    $0x1,%al
cmp    $0x30,%ecx
mov    %al,-0x61(%rbp)
je     132d <main+0x1cd>
movsbl -0x59(%rbp),%eax
cmp    $0x31,%eax
sete   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    133d <main+0x1dd>
jmp    138a <main+0x22a>
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    1365 <main+0x205>
mov    -0x30(%rbp),%eax
shr    $0x1,%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0x30(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x58(%rbp)
movsbl -0x59(%rbp),%eax
sub    $0x30,%eax
add    $0x61,%eax
mov    %al,%dl
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    1303 <main+0x1a3>
cmpl   $0x0,-0x28(%rbp)
jne    13a2 <main+0x242>
mov    -0x58(%rbp),%rax
movb   $0x78,(%rax)
movl   $0x1,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jae    1577 <main+0x417>
movl   $0x1,-0x60(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1419 <main+0x2b9>
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%eax
mov    -0x50(%rbp),%rcx
mov    -0x38(%rbp),%edx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1406 <main+0x2a6>
movl   $0x0,-0x60(%rbp)
jmp    1419 <main+0x2b9>
jmp    140b <main+0x2ab>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13cb <main+0x26b>
cmpl   $0x0,-0x60(%rbp)
jne    1428 <main+0x2c8>
jmp    1569 <main+0x409>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    14c4 <main+0x364>
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jb     1472 <main+0x312>
mov    -0x20(%rbp),%eax
shr    $0x1,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x48(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x48(%rbp)
jmp    143d <main+0x2dd>
mov    -0x3c(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    -0x24(%rbp),%ecx
add    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jb     14bf <main+0x35f>
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1484 <main+0x324>
jmp    152a <main+0x3ca>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jbe    1525 <main+0x3c5>
mov    -0x24(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x3c(%rbp),%ecx
cmp    %ecx,%eax
jae    151a <main+0x3ba>
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x3c(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14e2 <main+0x382>
mov    -0x3c(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
jmp    152a <main+0x3ca>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    1564 <main+0x404>
mov    -0x58(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1531 <main+0x3d1>
jmp    1569 <main+0x409>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13a9 <main+0x249>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movsbl -0x59(%rbp),%eax
cmp    $0x2c,%eax
je     129d <main+0x13d>
mov    -0x48(%rbp),%rax
mov    -0x1c(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jbe    1670 <main+0x510>
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
sub    $0x61,%eax
je     15ee <main+0x48e>
jmp    15cc <main+0x46c>
mov    -0x68(%rbp),%eax
sub    $0x62,%eax
je     1603 <main+0x4a3>
jmp    15dd <main+0x47d>
mov    -0x68(%rbp),%eax
sub    $0x78,%eax
je     1618 <main+0x4b8>
jmp    165d <main+0x4fd>
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movb   $0x30,(%rax,%rcx,1)
jmp    165d <main+0x4fd>
mov    -0x48(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
movb   $0x31,(%rax,%rcx,1)
jmp    165d <main+0x4fd>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1654 <main+0x4f4>
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1621 <main+0x4c1>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1662 <main+0x502>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    15a3 <main+0x443>
mov    -0x48(%rbp),%rsi
lea    0x999(%rip),%rdi
call   1040 <printf@plt>
movl   $0x0,-0x1c(%rbp)
jmp    1210 <main+0xb0>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %rsi,%r12
mov    %edi,%ebp
mov    $0xc0,%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    $0x20,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
mov    $0x20,%edi
call   1050 <malloc@plt>
cmp    $0x2,%ebp
jne    11ef <main+0x8f>
mov    %rax,%r13
mov    %r14,0x10(%rsp)
mov    0x8(%r12),%rdi
lea    0x1e5f(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,%r14
mov    %rax,%rdi
call   1080 <getc@plt>
mov    %eax,%ebp
mov    0x3e1c(%rip),%rax
cmp    (%rax),%bpl
jne    1216 <main+0xb6>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
xor    %eax,%eax
jmp    1204 <main+0xa4>
mov    (%r12),%rsi
lea    0x1e06(%rip),%rdi
call   1040 <printf@plt>
mov    $0x1,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xc0,%ebx
mov    $0x20,%eax
movl   $0x20,0x8c(%rsp)
mov    %r14,0x98(%rsp)
jmp    127a <main+0x11a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r8,0x10(%rsp)
lea    0x1dc8(%rip),%rdi
mov    %r15,%rsi
call   1040 <printf@plt>
mov    0x98(%rsp),%r14
mov    %r14,%rdi
call   1080 <getc@plt>
mov    %eax,%ebp
mov    0x3d7b(%rip),%rax
cmp    (%rax),%bpl
mov    0x34(%rsp),%eax
je     11d1 <main+0x71>
cmp    $0x3b,%bpl
mov    %eax,0x34(%rsp)
jne    12a0 <main+0x140>
xor    %r10d,%r10d
mov    0x10(%rsp),%r8
jmp    1323 <main+0x1c3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %r10d,%r10d
jmp    12d4 <main+0x174>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r10d,%eax
add    $0x1,%r10d
mov    %bpl,(%r15,%rax,1)
mov    %r14,%rdi
mov    %r10,%rbp
call   1080 <getc@plt>
mov    %rbp,%r10
mov    %eax,%ebp
cmp    $0x3b,%al
mov    0x10(%rsp),%r8
je     1323 <main+0x1c3>
lea    -0x1(%rbx),%eax
cmp    %eax,%r10d
jne    12b0 <main+0x150>
mov    %rbx,%rcx
mov    %ecx,%r12d
shr    %r12d
add    %ecx,%r12d
mov    %r15,%rdi
mov    %r12d,%esi
mov    %r10,%rbx
call   1060 <realloc@plt>
mov    %rbx,%r10
mov    %rax,%r15
mov    %r12d,%ebx
jmp    12b0 <main+0x150>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x80(%rsp),%rbx
cmpb   $0x2c,0x27(%rsp)
jne    1fe0 <main+0xe80>
mov    %r10,0x48(%rsp)
mov    %r8,%r14
mov    0x98(%rsp),%rdi
call   1080 <getc@plt>
cmp    $0x2c,%al
mov    %rbx,0x80(%rsp)
mov    %r13,0x40(%rsp)
jne    13e0 <main+0x280>
mov    0x8c(%rsp),%ebp
xor    %r13d,%r13d
mov    0x98(%rsp),%rbx
mov    %r13,0x8(%rsp)
mov    %rbx,%rdi
call   1080 <getc@plt>
mov    %eax,%ebx
and    $0xfe,%al
cmp    $0x30,%al
jne    1450 <main+0x2f0>
xor    %r12d,%r12d
mov    0x40(%rsp),%r13
jmp    13b8 <main+0x258>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x31,%bl
mov    %r12d,%eax
add    $0x1,%r12d
mov    %bl,0x0(%r13,%rax,1)
mov    0x98(%rsp),%rdi
call   1080 <getc@plt>
mov    %eax,%ebx
and    $0xfe,%al
cmp    $0x30,%al
jne    1470 <main+0x310>
mov    0x34(%rsp),%esi
cmp    %esi,%r12d
jne    1390 <main+0x230>
mov    %esi,%eax
shr    %eax
add    %eax,%esi
mov    %r13,%rdi
mov    %esi,0x34(%rsp)
call   1060 <realloc@plt>
mov    %rax,%r13
jmp    1390 <main+0x230>
nopl   0x0(%rax,%rax,1)
mov    %eax,%r12d
xor    %r13d,%r13d
mov    0x8c(%rsp),%ebp
mov    0x98(%rsp),%rbx
jmp    1421 <main+0x2c1>
nopw   0x0(%rax,%rax,1)
mov    %r13d,%eax
add    $0x1,%r13d
mov    %rdi,%r14
mov    %r12b,(%rdi,%rax,1)
mov    %rbx,%rdi
call   1080 <getc@plt>
mov    %eax,%r12d
cmp    $0x2c,%al
je     135f <main+0x1ff>
cmp    %ebp,%r13d
mov    %r14,%rdi
jne    1400 <main+0x2a0>
mov    %ebp,%eax
shr    %eax
add    %eax,%ebp
mov    %ebp,%esi
call   1060 <realloc@plt>
mov    0x98(%rsp),%rbx
mov    %rax,%rdi
jmp    1400 <main+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14,%r8
mov    0x48(%rsp),%r10
mov    0x8(%rsp),%r11
mov    0x40(%rsp),%r13
mov    0x34(%rsp),%ecx
jmp    1486 <main+0x326>
nopl   0x0(%rax,%rax,1)
test   %r12d,%r12d
mov    %r14,%r8
mov    0x48(%rsp),%r10
mov    0x8(%rsp),%r11
mov    0x34(%rsp),%ecx
jne    1491 <main+0x331>
movb   $0x78,0x0(%r13)
mov    $0x1,%r12d
mov    $0x1,%edx
sub    %r11d,%edx
mov    %edx,%eax
add    %r10d,%eax
mov    %ecx,0x34(%rsp)
mov    %ebp,0x8c(%rsp)
mov    %bl,0x27(%rsp)
je     1310 <main+0x1b0>
mov    %r11d,%eax
sub    %r12d,%eax
mov    %rax,0x38(%rsp)
mov    %r12d,%eax
sub    %r11d,%eax
mov    %r11d,%r9d
mov    %r12d,%ecx
mov    %rdx,0x18(%rsp)
lea    -0x1(%rcx),%rdx
mov    %rdx,0x60(%rsp)
lea    0x0(%r13,%rcx,1),%rdx
mov    %rdx,0x110(%rsp)
lea    -0x2(%r12),%edx
mov    %rdx,0x108(%rsp)
sub    %r11d,%edx
mov    %rdx,0x130(%rsp)
mov    %ecx,%ebp
and    $0xffffffe0,%ebp
lea    -0x20(%rbp),%rdx
mov    %rdx,0xf8(%rsp)
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rdx
mov    %rdx,0xd8(%rsp)
mov    %ecx,%edx
and    $0xfffffff8,%edx
mov    %rcx,0x78(%rsp)
and    $0x3,%ecx
mov    %rcx,0x140(%rsp)
mov    %rsi,0xf0(%rsp)
mov    %rsi,%rcx
mov    %rdx,%rsi
mov    %rcx,%rdx
shl    $0x5,%rdx
lea    -0x1(%r12),%edi
lea    0x20(%r11),%ecx
mov    %rcx,0x58(%rsp)
lea    -0x21(%rax),%ecx
mov    %rcx,0xd0(%rsp)
lea    -0x11(%rax),%ecx
mov    %rcx,0xc8(%rsp)
mov    %rax,%rcx
mov    %rax,0xa8(%rsp)
add    $0xffffffcf,%eax
mov    %rax,0xc0(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0xe0(%rsp)
lea    0x3(%r13),%rax
mov    %rax,0x138(%rsp)
mov    $0x40,%ecx
mov    %rdi,0x128(%rsp)
mov    %edi,%eax
mov    %edi,0x6c(%rsp)
mov    %r9,0xb0(%rsp)
xor    %r14d,%r14d
mov    %r12d,%edi
mov    0x80(%rsp),%rbx
mov    %r12,0x70(%rsp)
mov    %r9,0x28(%rsp)
mov    %rbp,0x100(%rsp)
mov    %rsi,0x50(%rsp)
mov    0x18(%rsp),%rbp
mov    %r13,0x40(%rsp)
mov    %r8,0x10(%rsp)
mov    %rdx,0xe8(%rsp)
jmp    163a <main+0x4da>
nopl   0x0(%rax)
mov    0x58(%rsp),%rcx
add    $0x1,%r14
lea    (%r10,%rbp,1),%eax
add    $0x1,%edi
add    $0x1,%rcx
mov    %rcx,0x58(%rsp)
addq   $0x1,0xb0(%rsp)
addl   $0x1,0x6c(%rsp)
mov    0x80(%rsp),%ecx
add    $0x1,%ecx
cmp    %eax,%r14d
jae    1318 <main+0x1b8>
mov    %ecx,0x80(%rsp)
mov    %edi,%edi
test   %r11d,%r11d
je     1668 <main+0x508>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
lea    (%r14,%rax,1),%ecx
movzbl (%r15,%rcx,1),%ecx
cmp    (%r8,%rax,1),%cl
jne    1600 <main+0x4a0>
add    $0x1,%rax
cmp    %rax,%r9
jne    1650 <main+0x4f0>
lea    (%r12,%r14,1),%eax
mov    %rax,0x90(%rsp)
lea    (%r11,%r14,1),%edx
cmp    %r11d,%r12d
mov    %rdi,%rax
mov    %rdi,(%rsp)
jbe    1700 <main+0x5a0>
mov    %r10,0x48(%rsp)
mov    0xa8(%rsp),%rax
lea    (%r10,%rax,1),%r12d
lea    -0x1(%rbx),%eax
cmp    %eax,%r12d
jb     16c5 <main+0x565>
nopl   (%rax)
mov    %ebx,%r13d
shr    %r13d
lea    (%rbx,%r13,1),%ebp
mov    %r15,%rdi
mov    %ebp,%esi
call   1060 <realloc@plt>
mov    %rax,%r15
lea    (%rbx,%r13,1),%eax
add    $0xffffffff,%eax
mov    %ebp,%ebx
cmp    %eax,%r12d
jae    16a0 <main+0x540>
lea    -0x1(%r12),%eax
cmp    0x90(%rsp),%eax
jae    177a <main+0x61a>
mov    %r12d,%r10d
mov    0x40(%rsp),%r13
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%r11
mov    0x70(%rsp),%r12
mov    0x18(%rsp),%rbp
mov    0x28(%rsp),%r9
jmp    1767 <main+0x607>
nopw   0x0(%rax,%rax,1)
jae    17c4 <main+0x664>
mov    %r10d,%r11d
sub    0x38(%rsp),%r11d
cmp    %r11d,0x90(%rsp)
jae    17ce <main+0x66e>
mov    %r10,0x48(%rsp)
mov    %r11d,%ecx
mov    %rcx,%r10
sub    %rdi,%r10
cmp    $0x8,%r10
jae    1a1b <main+0x8bb>
mov    0x38(%rsp),%rdx
nopl   0x0(%rax)
lea    (%rdx,%rdi,1),%eax
movzbl (%r15,%rax,1),%eax
mov    %al,(%r15,%rdi,1)
add    $0x1,%rdi
cmp    %rcx,%rdi
jb     1740 <main+0x5e0>
mov    %r11d,%r10d
mov    0x8(%rsp),%r11
mov    0x70(%rsp),%r12
mov    0x18(%rsp),%rbp
mov    0x60(%rsp),%rcx
mov    0x50(%rsp),%rsi
mov    (%rsp),%rdi
jmp    1aed <main+0x98d>
mov    0x128(%rsp),%rsi
lea    (%rsi,%r14,1),%r10d
mov    0x48(%rsp),%rcx
mov    0x130(%rsp),%rdx
lea    (%rdx,%rcx,1),%r8d
cmp    %r8d,%r10d
mov    %r8d,%edx
cmovb  %r10d,%edx
lea    (%rsi,%rcx,1),%ebp
mov    0x8(%rsp),%r11
add    %r11d,%edx
mov    %ebp,%esi
sub    %edx,%esi
cmp    $0x4,%esi
jae    17e0 <main+0x680>
mov    0x40(%rsp),%r13
mov    0x10(%rsp),%r8
jmp    1a95 <main+0x935>
mov    0x60(%rsp),%rcx
jmp    1aed <main+0x98d>
mov    %r11d,%r10d
mov    0x8(%rsp),%r11
mov    0x60(%rsp),%rcx
jmp    1aed <main+0x98d>
mov    %esi,0xbc(%rsp)
cmp    %r8d,%r10d
mov    %r8d,%edx
cmovb  %r10d,%edx
mov    0x108(%rsp),%rsi
lea    (%rsi,%rcx,1),%r9d
add    %r11d,%edx
mov    %r9d,%edi
sub    %edx,%edi
cmp    %eax,%edi
ja     17b5 <main+0x655>
lea    -0x1(%rcx),%edx
cmp    %edx,%edi
ja     17b5 <main+0x655>
mov    %eax,%r11d
lea    (%r15,%r11,1),%rsi
mov    %rsi,%rcx
sub    %rdi,%rcx
cmp    %rsi,%rcx
ja     1a86 <main+0x926>
mov    %ebp,0x88(%rsp)
lea    (%r15,%rdx,1),%rcx
mov    %rcx,%rbp
sub    %rdi,%rbp
cmp    %rcx,%rbp
mov    0x40(%rsp),%r13
ja     1a8b <main+0x92b>
cmp    %r8d,%r10d
mov    %r8d,%ecx
cmovb  %r10d,%ecx
add    0x8(%rsp),%ecx
sub    %ecx,%r9d
mov    %r11,%rcx
sub    %r9,%rcx
add    %r15,%rcx
lea    (%r15,%rdx,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rcx
jae    1886 <main+0x726>
lea    (%r15,%r11,1),%rcx
add    $0x1,%rcx
mov    %rdx,%rdi
sub    %r9,%rdi
add    %r15,%rdi
cmp    %rcx,%rdi
jb     1a8b <main+0x92b>
xor    %ebp,%ebp
mov    0xbc(%rsp),%r9d
cmp    $0x10,%r9d
mov    0x48(%rsp),%r11
jb     1d88 <main+0xc28>
mov    %r9d,%ebp
and    $0xfffffff0,%ebp
lea    -0x10(%rbp),%ecx
mov    %ecx,%esi
shr    $0x4,%esi
add    $0x1,%esi
xor    %edi,%edi
cmp    $0x30,%ecx
jb     19a4 <main+0x844>
mov    %esi,0xb8(%rsp)
mov    0xd0(%rsp),%rcx
add    %r11d,%ecx
mov    %rcx,0xa0(%rsp)
mov    0xc8(%rsp),%rcx
add    %r11d,%ecx
mov    %rcx,0x120(%rsp)
mov    0xc0(%rsp),%rcx
add    %r11d,%ecx
mov    %rcx,0x118(%rsp)
mov    0x6c(%rsp),%ecx
cmp    %r8d,%ecx
mov    %r8d,%edi
cmovb  %ecx,%edi
add    0x8(%rsp),%edi
mov    0x88(%rsp),%r11d
sub    %edi,%r11d
and    $0xfffffff0,%r11d
add    $0xfffffff0,%r11d
shr    $0x4,%r11d
add    $0x1,%r11d
and    $0xfffffffc,%r11d
xor    %edi,%edi
nopl   (%rax)
lea    (%rax,%rdi,1),%esi
lea    (%rdx,%rdi,1),%ecx
movups -0xf(%r15,%rcx,1),%xmm0
movups %xmm0,-0xf(%r15,%rsi,1)
mov    0x120(%rsp),%rcx
add    %edi,%ecx
lea    -0x10(%rdx,%rdi,1),%esi
movups -0xf(%r15,%rsi,1),%xmm0
movups %xmm0,-0xf(%r15,%rcx,1)
mov    0xa0(%rsp),%rcx
add    %edi,%ecx
lea    -0x20(%rdx,%rdi,1),%esi
movups -0xf(%r15,%rsi,1),%xmm0
movups %xmm0,-0xf(%r15,%rcx,1)
mov    0x118(%rsp),%rcx
add    %edi,%ecx
lea    (%rdx,%rdi,1),%esi
add    $0xffffffd0,%esi
movups -0xf(%r15,%rsi,1),%xmm0
movups %xmm0,-0xf(%r15,%rcx,1)
add    $0xffffffc0,%edi
add    $0xfffffffc,%r11d
jne    1930 <main+0x7d0>
neg    %edi
mov    0xb8(%rsp),%esi
test   $0x3,%sil
mov    0xa8(%rsp),%r11
je     1a0a <main+0x8aa>
not    %edi
add    0x48(%rsp),%edi
mov    0x6c(%rsp),%edx
cmp    %r8d,%edx
mov    %r8d,%ecx
cmovb  %edx,%ecx
add    0x8(%rsp),%ecx
mov    0x88(%rsp),%edx
sub    %ecx,%edx
and    $0x30,%dl
add    $0xf0,%dl
shr    $0x4,%dl
add    $0x1,%dl
movzbl %dl,%edx
and    $0x3,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r11,%rdi,1),%ecx
mov    %edi,%esi
movups -0xf(%r15,%rsi,1),%xmm0
movups %xmm0,-0xf(%r15,%rcx,1)
add    $0xfffffff0,%edi
add    $0xffffffff,%edx
jne    19f0 <main+0x890>
cmp    %ebp,%r9d
jne    1d79 <main+0xc19>
mov    %r12d,%r10d
jmp    16df <main+0x57f>
mov    %rdi,%rax
mov    %rdi,%rsi
not    %rsi
add    %rcx,%rsi
mov    %edx,%ebp
add    %esi,%ebp
mov    0x28(%rsp),%r9
jb     1734 <main+0x5d4>
shr    $0x20,%rsi
mov    %rax,%rdi
jne    1734 <main+0x5d4>
lea    (%r15,%rax,1),%rdi
lea    (%rdx,%rcx,1),%rsi
sub    %rax,%rsi
add    %r15,%rsi
mov    %rdi,0xa0(%rsp)
cmp    %rsi,%rdi
jae    1a71 <main+0x911>
lea    (%r15,%rcx,1),%rsi
add    %r15,%rdx
mov    %rax,%rdi
cmp    %rsi,%rdx
jb     1734 <main+0x5d4>
cmp    $0x20,%r10
jae    1e34 <main+0xcd4>
xor    %edx,%edx
mov    (%rsp),%rax
jmp    1f33 <main+0xdd3>
mov    0x40(%rsp),%r13
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%r11
mov    0x18(%rsp),%rbp
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    (%rsp),%rdi
mov    %rbp,%r10
mov    0x90(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rax,1),%ecx
movzbl (%r15,%rcx,1),%ecx
mov    %eax,%edx
mov    %cl,(%r15,%rdx,1)
add    $0xffffffff,%eax
cmp    %ebp,%eax
jae    1ac0 <main+0x960>
mov    %r12d,%eax
mov    0x70(%rsp),%r12
mov    0x60(%rsp),%rcx
mov    0x50(%rsp),%rsi
mov    %r10,%rbp
mov    %rax,%r10
cmp    $0x8,%r12d
jae    1bd0 <main+0xa70>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    0x78(%rsp),%rsi
mov    0x140(%rsp),%rdx
test   %rdx,%rdx
je     1b38 <main+0x9d8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rax,1),%ecx
lea    (%r14,%rax,1),%edi
mov    %cl,(%r15,%rdi,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1b20 <main+0x9c0>
cmp    $0x3,%rsi
jb     1bb0 <main+0xa50>
mov    %rbx,%r9
mov    0x138(%rsp),%rcx
mov    %r14,%rdx
mov    0x78(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl -0x3(%rcx,%rax,1),%ebx
lea    (%rax,%rdx,1),%rdi
mov    %edi,%ebp
mov    %bl,(%r15,%rbp,1)
movzbl -0x2(%rcx,%rax,1),%ebx
lea    0x1(%rdi),%ebp
mov    %bl,(%r15,%rbp,1)
movzbl -0x1(%rcx,%rax,1),%ebx
lea    0x2(%rdi),%ebp
mov    %bl,(%r15,%rbp,1)
movzbl (%rcx,%rax,1),%ebx
add    $0x3,%edi
mov    %bl,(%r15,%rdi,1)
add    $0xfffffffffffffffc,%rsi
add    $0x4,%rdx
add    $0x4,%rcx
cmp    %rsi,%rax
jne    1b60 <main+0xa00>
mov    %r9,%rbx
mov    0x18(%rsp),%rbp
mov    0x28(%rsp),%r9
mov    0x50(%rsp),%rsi
mov    0x58(%rsp),%rcx
mov    (%rsp),%rdi
jmp    1605 <main+0x4a5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r14d,%eax
add    %ecx,%eax
jb     1af7 <main+0x997>
mov    %rcx,%rax
shr    $0x20,%rax
mov    $0x0,%eax
jne    1af9 <main+0x999>
mov    0x78(%rsp),%rax
add    %r14,%rax
add    %r15,%rax
cmp    %rax,%r13
jae    1c0f <main+0xaaf>
lea    (%r15,%r14,1),%rax
cmp    0x110(%rsp),%rax
jb     1af7 <main+0x997>
cmp    $0x20,%r12d
jae    1c1c <main+0xabc>
xor    %ecx,%ecx
jmp    1d50 <main+0xbf0>
cmpq   $0x60,0xf8(%rsp)
jae    1c2e <main+0xace>
xor    %eax,%eax
jmp    1cc4 <main+0xb64>
mov    0xd8(%rsp),%rcx
mov    0x80(%rsp),%eax
mov    %eax,%edx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x0(%r13,%rax,1),%xmm0
movups 0x10(%r13,%rax,1),%xmm1
lea    -0x40(%rdx),%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
movups 0x20(%r13,%rax,1),%xmm0
movups 0x30(%r13,%rax,1),%xmm1
lea    -0x20(%rdx),%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
movups 0x40(%r13,%rax,1),%xmm0
movups 0x50(%r13,%rax,1),%xmm1
mov    %edx,%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
movups 0x60(%r13,%rax,1),%xmm0
movups 0x70(%r13,%rax,1),%xmm1
lea    0x20(%rdx),%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
sub    $0xffffffffffffff80,%rax
sub    $0xffffff80,%edx
add    $0xfffffffffffffffc,%rcx
jne    1c50 <main+0xaf0>
cmpq   $0x0,0xf0(%rsp)
mov    0xe8(%rsp),%rdi
je     1d10 <main+0xbb0>
mov    0xe0(%rsp),%rcx
add    %rax,%rcx
add    %r14d,%eax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdx,1),%xmm0
movups (%rcx,%rdx,1),%xmm1
lea    (%rax,%rdx,1),%esi
movups %xmm0,(%r15,%rsi,1)
movups %xmm1,0x10(%r15,%rsi,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1cf0 <main+0xb90>
mov    0x78(%rsp),%rax
mov    0x100(%rsp),%rsi
cmp    %rax,%rsi
je     1bb0 <main+0xa50>
mov    %rsi,%rcx
mov    %rax,%rdx
mov    %rsi,%rax
test   $0x18,%dl
mov    0x50(%rsp),%rsi
mov    (%rsp),%rdi
je     1af9 <main+0x999>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rcx,1),%rax
lea    (%r14,%rcx,1),%edx
mov    %rax,(%r15,%rdx,1)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    1d50 <main+0xbf0>
mov    %rsi,%rax
cmp    0x78(%rsp),%rsi
je     1600 <main+0x4a0>
jmp    1af9 <main+0x999>
test   $0xc,%r9b
je     1fba <main+0xe5a>
mov    0x48(%rsp),%r11
cmp    %r8d,%r10d
cmovae %r8d,%r10d
mov    0x8(%rsp),%rcx
add    %ecx,%r10d
mov    0x88(%rsp),%esi
mov    %esi,%r9d
sub    %r10d,%r9d
mov    %r9d,%r10d
and    $0xfffffffc,%r10d
sub    %r10d,%eax
mov    0x6c(%rsp),%edx
cmp    %r8d,%edx
cmovb  %edx,%r8d
add    %ecx,%r8d
sub    %r8d,%esi
and    $0xfffffffc,%esi
mov    %ebp,%ecx
sub    %esi,%ecx
not    %ebp
add    %r11d,%ebp
mov    0xa8(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rbp,1),%edi
mov    %ebp,%edx
mov    -0x3(%r15,%rdx,1),%edx
mov    %edx,-0x3(%r15,%rdi,1)
add    $0xfffffffc,%ebp
add    $0x4,%ecx
jne    1de0 <main+0xc80>
cmp    %r10d,%r9d
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%r11
mov    0x18(%rsp),%rbp
mov    0x38(%rsp),%rsi
mov    0x28(%rsp),%r9
mov    (%rsp),%rdi
jne    1aa8 <main+0x948>
mov    %r12d,%r10d
mov    0x70(%rsp),%r12
mov    0x60(%rsp),%rcx
mov    0x50(%rsp),%rsi
jmp    1aed <main+0x98d>
mov    %r10,%rdx
and    $0xffffffffffffffe0,%rdx
lea    -0x20(%rdx),%rsi
mov    %rsi,%r9
shr    $0x5,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1fc1 <main+0xe61>
mov    (%rsp),%rax
lea    (%r15,%rax,1),%rsi
add    $0x30,%rsi
mov    %r10,%rbp
and    $0xffffffffffffffe0,%rbp
add    $0xffffffffffffffe0,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edi,%edi
mov    0x58(%rsp),%r8
mov    0xb0(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r12,%rdi,1),%eax
movups (%r15,%rax,1),%xmm0
movups 0x10(%r15,%rax,1),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,1)
movups %xmm1,-0x20(%rsi,%rdi,1)
lea    (%r8,%rdi,1),%eax
movups (%r15,%rax,1),%xmm0
movups 0x10(%r15,%rax,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1e90 <main+0xd30>
test   $0x1,%r9b
je     1ef5 <main+0xd95>
mov    (%rsp),%rsi
lea    (%rdi,%rsi,1),%rax
add    %esi,%edi
add    0x38(%rsp),%edi
movups (%r15,%rdi,1),%xmm0
movups 0x10(%r15,%rdi,1),%xmm1
movups %xmm0,(%r15,%rax,1)
movups %xmm1,0x10(%r15,%rax,1)
cmp    %rdx,%r10
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r9
mov    0x50(%rsp),%rsi
jne    1f25 <main+0xdc5>
mov    %r11d,%r10d
mov    0x8(%rsp),%r11
mov    0x70(%rsp),%r12
mov    0x18(%rsp),%rbp
mov    0x60(%rsp),%rcx
jmp    1771 <main+0x611>
test   $0x18,%r10b
mov    (%rsp),%rax
je     1fd2 <main+0xe72>
mov    0xa0(%rsp),%r9
mov    0x48(%rsp),%rsi
add    0xa8(%rsp),%esi
sub    0x90(%rsp),%rsi
mov    %rsi,%r12
and    $0xfffffffffffffff8,%rsi
lea    (%rsi,%rax,1),%rdi
and    $0xfffffffffffffff8,%r10
mov    0xb0(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
lea    (%rdx,%rbp,1),%eax
mov    (%r15,%rax,1),%rax
mov    %rax,(%r9,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r10
jne    1f70 <main+0xe10>
cmp    %rsi,%r12
mov    0x28(%rsp),%r9
mov    (%rsp),%rax
jne    1734 <main+0x5d4>
mov    %r11d,%r10d
mov    0x8(%rsp),%r11
mov    0x70(%rsp),%r12
mov    0x18(%rsp),%rbp
mov    0x60(%rsp),%rcx
mov    0x50(%rsp),%rsi
mov    %rax,%rdi
jmp    1aed <main+0x98d>
sub    %ebp,%eax
jmp    1a8b <main+0x92b>
xor    %edi,%edi
test   $0x1,%r9b
jne    1ed1 <main+0xd71>
jmp    1ef5 <main+0xd95>
add    %rax,%rdx
mov    %rdx,%rdi
jmp    1734 <main+0x5d4>
nopl   (%rax)
mov    %r10d,%r9d
movb   $0x0,(%r15,%r9,1)
test   %r10d,%r10d
je     1240 <main+0xe0>
lea    -0x1(%r10),%r14d
lea    (%r15,%r14,1),%rdx
add    $0x31,%rdx
mov    %r10d,%esi
neg    %esi
lea    (%r15,%r14,1),%rdi
add    $0x1,%rdi
xor    %ebp,%ebp
mov    %r10d,%r12d
mov    %r13,0x40(%rsp)
mov    %rbx,0x80(%rsp)
mov    %r10,0x48(%rsp)
jmp    2050 <main+0xef0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movb   $0x31,(%r15,%r9,1)
add    $0xffffffffffffffff,%r14
add    $0x1,%ebp
add    $0xffffffffffffffff,%rdx
add    $0x1,%esi
add    $0xffffffffffffffff,%rdi
test   %r9,%r9
je     1240 <main+0xe0>
movsbl -0x1(%r15,%r9,1),%eax
add    $0xffffffffffffffff,%r9
cmp    $0x61,%eax
je     20b0 <main+0xf50>
cmp    $0x62,%eax
je     2030 <main+0xed0>
cmp    $0x78,%eax
jne    2035 <main+0xed5>
mov    %r12d,%r11d
cmp    %r11,%r9
jae    2236 <main+0x10d6>
mov    %ebp,%r10d
sub    0x48(%rsp),%r10d
add    %r12d,%r10d
mov    %r14,%rcx
cmp    $0x7,%r10d
jb     2220 <main+0x10c0>
cmp    $0x1f,%r10d
mov    %r12,0x58(%rsp)
jae    20ba <main+0xf5a>
mov    %r8,%r13
xor    %eax,%eax
jmp    2198 <main+0x1038>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movb   $0x30,(%r15,%r9,1)
jmp    2035 <main+0xed5>
lea    0x1(%r10),%rax
mov    %rax,0x90(%rsp)
movabs $0x1ffffffe0,%rcx
and    %rcx,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,(%rsp)
mov    (%rsp),%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %rcx,0x78(%rsp)
cmpq   $0x0,(%rsp)
je     21fe <main+0x109e>
lea    (%r12,%rsi,1),%ecx
add    $0x1,%rcx
and    $0xffffffffffffffe0,%rcx
add    $0xffffffffffffffe0,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rdx,%r12,1),%xmm0
movups -0x20(%rdx,%r12,1),%xmm1
movups -0x10(%rdx,%r12,1),%xmm2
movups (%rdx,%r12,1),%xmm3
movups %xmm0,-0x31(%rdx,%r12,1)
movups %xmm1,-0x21(%rdx,%r12,1)
movups %xmm2,-0x11(%rdx,%r12,1)
movups %xmm3,-0x1(%rdx,%r12,1)
add    $0x40,%r12
add    $0xfffffffffffffffe,%rcx
jne    2120 <main+0xfc0>
testb  $0x1,0x78(%rsp)
je     217a <main+0x101a>
add    %r14,%r12
movups 0x1(%r15,%r12,1),%xmm0
movups 0x11(%r15,%r12,1),%xmm1
movups %xmm0,(%r15,%r12,1)
movups %xmm1,0x10(%r15,%r12,1)
mov    0x90(%rsp),%rcx
cmp    %rax,%rcx
mov    0x58(%rsp),%r12
je     2236 <main+0x10d6>
test   $0x18,%cl
je     2211 <main+0x10b1>
mov    %r8,%r13
add    $0x1,%r10
movabs $0x1ffffffe0,%rcx
lea    0x18(%rcx),%r12
and    %r10,%r12
lea    (%r14,%r12,1),%rcx
mov    0x58(%rsp),%rbx
lea    (%rbx,%rsi,1),%r8d
add    $0x1,%r8
and    $0xfffffffffffffff8,%r8
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%rax,1),%rbx
mov    %rbx,-0x1(%rdi,%rax,1)
add    $0x8,%rax
cmp    %rax,%r8
jne    21d0 <main+0x1070>
cmp    %r12,%r10
mov    %r13,%r8
mov    0x40(%rsp),%r13
mov    0x80(%rsp),%rbx
mov    0x58(%rsp),%r12
jne    2220 <main+0x10c0>
jmp    2236 <main+0x10d6>
xor    %r12d,%r12d
testb  $0x1,0x78(%rsp)
jne    2160 <main+0x1000>
jmp    217a <main+0x101a>
add    %r14,%rax
mov    %rax,%rcx
nopw   0x0(%rax,%rax,1)
movzbl 0x1(%r15,%rcx,1),%eax
mov    %al,(%r15,%rcx,1)
lea    0x1(%rcx),%rax
mov    %rax,%rcx
cmp    %eax,%r11d
jne    2220 <main+0x10c0>
add    $0xffffffff,%r12d
jmp    2035 <main+0xed5>

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

LLVM IR (-O2):
@.str = [18 x i8] c"Usage: %s [FILE]\0A\00"
@.str.1 = [2 x i8] c"r\00"
@EOF = global i8 0
@.str.2 = [4 x i8] c"%s\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = tail call dereferenceable_or_null(192) i8* @malloc(i32 192)
%4 = tail call dereferenceable_or_null(32) i8* @malloc(i32 32)
%5 = tail call dereferenceable_or_null(32) i8* @malloc(i32 32)
%6 = icmp eq i32 %0, 2
br i1 %6, label %10, label %7
7: ; preds = %2
%8 = load i8*, i8** %1
%9 = tail call i32 @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %8)
br label %859
10: ; preds = %2
%11 = getelementptr inbounds i8*, i8** %1, i64 1
%12 = load i8*, i8** %11
%13 = tail call i32* @fopen(i8* %12, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%14 = tail call signext i8 @getc(i32* %13)
%15 = load i8, i8* @EOF
%16 = icmp eq i8 %14, %15
br i1 %16, label %852, label %17
17: ; preds = %10, %847
%18 = phi i8 [ %849, %847 ], [ %14, %10 ]
%19 = phi i8* [ %112, %847 ], [ %5, %10 ]
%20 = phi i8* [ %62, %847 ], [ %4, %10 ]
%21 = phi i8* [ %716, %847 ], [ %3, %10 ]
%22 = phi i32 [ %113, %847 ], [ 32, %10 ]
%23 = phi i32 [ %61, %847 ], [ 32, %10 ]
%24 = phi i32 [ %715, %847 ], [ 192, %10 ]
%25 = icmp eq i8 %18, 59
br i1 %25, label %45, label %26
26: ; preds = %17, %37
%27 = phi i8 [ %43, %37 ], [ %18, %17 ]
%28 = phi i8* [ %39, %37 ], [ %21, %17 ]
%29 = phi i32 [ %38, %37 ], [ %24, %17 ]
%30 = phi i32 [ %40, %37 ], [ 0, %17 ]
%31 = add i32 %29, -1
%32 = icmp eq i32 %30, %31
br i1 %32, label %33, label %37
33: ; preds = %26
%34 = lshr i32 %29, 1
%35 = add i32 %34, %29
%36 = tail call i8* @realloc(i8* %28, i32 %35)
br label %37
37: ; preds = %33, %26
%38 = phi i32 [ %35, %33 ], [ %29, %26 ]
%39 = phi i8* [ %36, %33 ], [ %28, %26 ]
%40 = add i32 %30, 1
%41 = zext i32 %30 to i64
%42 = getelementptr inbounds i8, i8* %39, i64 %41
store i8 %27, i8* %42
%43 = tail call signext i8 @getc(i32* %13)
%44 = icmp eq i8 %43, 59
br i1 %44, label %45, label %26
45: ; preds = %37, %17
%46 = phi i32 [ 0, %17 ], [ %40, %37 ]
%47 = phi i32 [ %24, %17 ], [ %38, %37 ]
%48 = phi i8* [ %21, %17 ], [ %39, %37 ]
br label %49
49: ; preds = %45, %713
%50 = phi i32 [ %714, %713 ], [ %46, %45 ]
%51 = phi i32 [ %715, %713 ], [ %47, %45 ]
%52 = phi i32 [ %61, %713 ], [ %23, %45 ]
%53 = phi i32 [ %113, %713 ], [ %22, %45 ]
%54 = phi i8* [ %716, %713 ], [ %48, %45 ]
%55 = phi i8* [ %62, %713 ], [ %20, %45 ]
%56 = phi i8* [ %112, %713 ], [ %19, %45 ]
%57 = tail call signext i8 @getc(i32* %13)
%58 = icmp eq i8 %57, 44
br i1 %58, label %59, label %66
59: ; preds = %76, %49
%60 = phi i32 [ 0, %49 ], [ %79, %76 ]
%61 = phi i32 [ %52, %49 ], [ %77, %76 ]
%62 = phi i8* [ %55, %49 ], [ %78, %76 ]
%63 = tail call signext i8 @getc(i32* %13)
%64 = and i8 %63, -2
%65 = icmp eq i8 %64, 48
br i1 %65, label %84, label %106
66: ; preds = %49, %76
%67 = phi i8 [ %82, %76 ], [ %57, %49 ]
%68 = phi i8* [ %78, %76 ], [ %55, %49 ]
%69 = phi i32 [ %77, %76 ], [ %52, %49 ]
%70 = phi i32 [ %79, %76 ], [ 0, %49 ]
%71 = icmp eq i32 %70, %69
br i1 %71, label %72, label %76
72: ; preds = %66
%73 = lshr i32 %69, 1
%74 = add i32 %73, %69
%75 = tail call i8* @realloc(i8* %68, i32 %74)
br label %76
76: ; preds = %72, %66
%77 = phi i32 [ %74, %72 ], [ %69, %66 ]
%78 = phi i8* [ %75, %72 ], [ %68, %66 ]
%79 = add i32 %70, 1
%80 = zext i32 %70 to i64
%81 = getelementptr inbounds i8, i8* %78, i64 %80
store i8 %67, i8* %81
%82 = tail call signext i8 @getc(i32* %13)
%83 = icmp eq i8 %82, 44
br i1 %83, label %59, label %66
84: ; preds = %59, %94
%85 = phi i8 [ %101, %94 ], [ %63, %59 ]
%86 = phi i8* [ %96, %94 ], [ %56, %59 ]
%87 = phi i32 [ %95, %94 ], [ %53, %59 ]
%88 = phi i32 [ %98, %94 ], [ 0, %59 ]
%89 = icmp eq i32 %88, %87
br i1 %89, label %90, label %94
90: ; preds = %84
%91 = lshr i32 %87, 1
%92 = add i32 %91, %87
%93 = tail call i8* @realloc(i8* %86, i32 %92)
br label %94
94: ; preds = %90, %84
%95 = phi i32 [ %92, %90 ], [ %87, %84 ]
%96 = phi i8* [ %93, %90 ], [ %86, %84 ]
%97 = add nuw nsw i8 %85, 49
%98 = add i32 %88, 1
%99 = zext i32 %88 to i64
%100 = getelementptr inbounds i8, i8* %96, i64 %99
store i8 %97, i8* %100
%101 = tail call signext i8 @getc(i32* %13)
%102 = and i8 %101, -2
%103 = icmp eq i8 %102, 48
br i1 %103, label %84, label %104
104: ; preds = %94
%105 = icmp eq i32 %98, 0
br i1 %105, label %106, label %110
106: ; preds = %59, %104
%107 = phi i8 [ %101, %104 ], [ %63, %59 ]
%108 = phi i8* [ %96, %104 ], [ %56, %59 ]
%109 = phi i32 [ %95, %104 ], [ %53, %59 ]
store i8 120, i8* %108
br label %110
110: ; preds = %106, %104
%111 = phi i8 [ %107, %106 ], [ %101, %104 ]
%112 = phi i8* [ %108, %106 ], [ %96, %104 ]
%113 = phi i32 [ %109, %106 ], [ %95, %104 ]
%114 = phi i32 [ 1, %106 ], [ %98, %104 ]
%115 = sub i32 1, %60
%116 = sub i32 0, %50
%117 = icmp eq i32 %115, %116
br i1 %117, label %713, label %118
118: ; preds = %110
%119 = icmp eq i32 %60, 0
%120 = icmp ugt i32 %114, %60
%121 = icmp ult i32 %114, %60
%122 = sub i32 %60, %114
%123 = sub i32 %114, %60
%124 = zext i32 %60 to i64
%125 = zext i32 %114 to i64
%126 = add nsw i64 %125, -1
%127 = getelementptr i8, i8* %112, i64 %125
%128 = zext i32 %114 to i64
%129 = add i32 %114, -2
%130 = add i32 %114, -1
%131 = add i32 %114, -2
%132 = sub i32 %131, %60
%133 = add i32 %114, -2
%134 = add i32 %114, -2
%135 = sub i32 %134, %60
%136 = add i32 %114, -1
%137 = add i32 %114, -2
%138 = sub i32 %137, %60
%139 = add i32 %114, -1
%140 = add i32 %114, -2
%141 = sub i32 %140, %60
%142 = sub i32 %114, %60
%143 = and i64 %125, 4294967264
%144 = add nsw i64 %143, -32
%145 = lshr exact i64 %144, 5
%146 = add nuw nsw i64 %145, 1
%147 = icmp ult i32 %114, 8
%148 = trunc i64 %126 to i32
%149 = icmp ugt i64 %126, 4294967295
%150 = icmp ult i32 %114, 32
%151 = and i64 %125, 4294967264
%152 = and i64 %146, 3
%153 = icmp ult i64 %144, 96
%154 = and i64 %146, 1152921504606846972
%155 = icmp eq i64 %152, 0
%156 = icmp eq i64 %151, %125
%157 = and i64 %125, 24
%158 = icmp eq i64 %157, 0
%159 = and i64 %128, 4294967288
%160 = icmp eq i64 %159, %128
%161 = and i64 %125, 3
%162 = icmp eq i64 %161, 0
br label %163
163: ; preds = %118, %704
%164 = phi i64 [ 0, %118 ], [ %712, %704 ]
%165 = phi i32 [ %114, %118 ], [ %711, %704 ]
%166 = phi i8* [ %54, %118 ], [ %707, %704 ]
%167 = phi i32 [ 0, %118 ], [ %708, %704 ]
%168 = phi i32 [ %51, %118 ], [ %706, %704 ]
%169 = phi i32 [ %50, %118 ], [ %705, %704 ]
%170 = trunc i64 %164 to i32
%171 = add i32 %114, %170
%172 = zext i32 %171 to i64
%173 = zext i32 %165 to i64
%174 = zext i32 %165 to i64
%175 = trunc i64 %164 to i32
%176 = add i32 %60, %175
%177 = zext i32 %176 to i64
%178 = zext i32 %165 to i64
%179 = trunc i64 %164 to i32
%180 = add i32 %60, %179
%181 = trunc i64 %164 to i32
%182 = add i32 %139, %181
%183 = trunc i64 %164 to i32
%184 = add i32 %136, %183
%185 = trunc i64 %164 to i32
%186 = add i32 %130, %185
%187 = trunc i64 %164 to i32
%188 = add i32 %130, %187
%189 = add i64 %164, %125
%190 = zext i32 %165 to i64
br i1 %119, label %204, label %193
191: ; preds = %193
%192 = icmp eq i64 %203, %124
br i1 %192, label %204, label %193
193: ; preds = %163, %191
%194 = phi i64 [ %203, %191 ], [ 0, %163 ]
%195 = trunc i64 %194 to i32
%196 = add i32 %167, %195
%197 = zext i32 %196 to i64
%198 = getelementptr inbounds i8, i8* %166, i64 %197
%199 = load i8, i8* %198
%200 = getelementptr inbounds i8, i8* %62, i64 %194
%201 = load i8, i8* %200
%202 = icmp eq i8 %199, %201
%203 = add nuw nsw i64 %194, 1
br i1 %202, label %191, label %704
204: ; preds = %191, %163
br i1 %120, label %205, label %404
205: ; preds = %204
%206 = add i32 %169, %123
%207 = add i32 %168, -1
%208 = icmp ult i32 %206, %207
br i1 %208, label %209, label %386
209: ; preds = %386, %205
%210 = phi i32 [ %168, %205 ], [ %390, %386 ]
%211 = phi i8* [ %166, %205 ], [ %391, %386 ]
%212 = add i32 %167, %114
%213 = add i32 %206, -1
%214 = icmp ult i32 %213, %212
br i1 %214, label %539, label %215
215: ; preds = %209
%216 = add i32 %138, %169
%217 = call i32 @llvm.umin.i32(i32 %184, i32 %216)
%218 = add i32 %136, %169
%219 = add i32 %60, %217
%220 = sub i32 %218, %219
%221 = icmp ult i32 %220, 4
br i1 %221, label %384, label %222
222: ; preds = %215
%223 = add i32 %132, %169
%224 = call i32 @llvm.umin.i32(i32 %188, i32 %223)
%225 = add i32 %129, %169
%226 = add i32 %60, %224
%227 = sub i32 %225, %226
%228 = icmp ugt i32 %227, %213
%229 = add i32 %169, -1
%230 = icmp ugt i32 %227, %229
%231 = zext i32 %213 to i64
%232 = getelementptr i8, i8* %211, i64 %231
%233 = zext i32 %227 to i64
%234 = sub nsw i64 0, %233
%235 = getelementptr i8, i8* %232, i64 %234
%236 = icmp ugt i8* %235, %232
%237 = zext i32 %229 to i64
%238 = getelementptr i8, i8* %211, i64 %237
%239 = zext i32 %227 to i64
%240 = sub nsw i64 0, %239
%241 = getelementptr i8, i8* %238, i64 %240
%242 = icmp ugt i8* %241, %238
%243 = or i1 %228, %230
%244 = or i1 %243, %236
%245 = or i1 %244, %242
br i1 %245, label %384, label %246
246: ; preds = %222
%247 = zext i32 %213 to i64
%248 = add i32 %135, %169
%249 = call i32 @llvm.umin.i32(i32 %186, i32 %248)
%250 = add i32 %133, %169
%251 = add i32 %60, %249
%252 = sub i32 %250, %251
%253 = zext i32 %252 to i64
%254 = sub nsw i64 %247, %253
%255 = getelementptr i8, i8* %211, i64 %254
%256 = getelementptr i8, i8* %211, i64 1
%257 = getelementptr i8, i8* %256, i64 %247
%258 = add i32 %169, -1
%259 = zext i32 %258 to i64
%260 = sub nsw i64 %259, %253
%261 = getelementptr i8, i8* %211, i64 %260
%262 = getelementptr i8, i8* %211, i64 1
%263 = getelementptr i8, i8* %262, i64 %259
%264 = icmp ult i8* %255, %263
%265 = icmp ult i8* %261, %257
%266 = and i1 %264, %265
br i1 %266, label %384, label %267
267: ; preds = %246
%268 = icmp ult i32 %220, 16
br i1 %268, label %358, label %269
269: ; preds = %267
%270 = and i32 %220, -16
%271 = add i32 %270, -16
%272 = lshr exact i32 %271, 4
%273 = add nuw nsw i32 %272, 1
%274 = and i32 %273, 3
%275 = icmp ult i32 %271, 48
br i1 %275, label %331, label %276
276: ; preds = %269
%277 = and i32 %273, 536870908
%278 = getelementptr inbounds i8, i8* %211, i64 -15
%279 = getelementptr inbounds i8, i8* %211, i64 -15
%280 = getelementptr inbounds i8, i8* %211, i64 -15
%281 = getelementptr inbounds i8, i8* %211, i64 -15
%282 = getelementptr inbounds i8, i8* %211, i64 -15
%283 = getelementptr inbounds i8, i8* %211, i64 -15
%284 = getelementptr inbounds i8, i8* %211, i64 -15
%285 = getelementptr inbounds i8, i8* %211, i64 -15
br label %286
286: ; preds = %286, %276
%287 = phi i32 [ 0, %276 ], [ %328, %286 ]
%288 = phi i32 [ 0, %276 ], [ %329, %286 ]
%289 = sub i32 %213, %287
%290 = sub i32 %289, %123
%291 = zext i32 %290 to i64
%292 = getelementptr inbounds i8, i8* %278, i64 %291
%293 = bitcast i8* %292 to <16 x i8>*
%294 = load <16 x i8>, <16 x i8>* %293
%295 = zext i32 %289 to i64
%296 = getelementptr inbounds i8, i8* %279, i64 %295
%297 = bitcast i8* %296 to <16 x i8>*
store <16 x i8> %294, <16 x i8>* %297
%298 = or i32 %287, 16
%299 = sub i32 %213, %298
%300 = sub i32 %299, %123
%301 = zext i32 %300 to i64
%302 = getelementptr inbounds i8, i8* %280, i64 %301
%303 = bitcast i8* %302 to <16 x i8>*
%304 = load <16 x i8>, <16 x i8>* %303
%305 = zext i32 %299 to i64
%306 = getelementptr inbounds i8, i8* %281, i64 %305
%307 = bitcast i8* %306 to <16 x i8>*
store <16 x i8> %304, <16 x i8>* %307
%308 = or i32 %287, 32
%309 = sub i32 %213, %308
%310 = sub i32 %309, %123
%311 = zext i32 %310 to i64
%312 = getelementptr inbounds i8, i8* %282, i64 %311
%313 = bitcast i8* %312 to <16 x i8>*
%314 = load <16 x i8>, <16 x i8>* %313
%315 = zext i32 %309 to i64
%316 = getelementptr inbounds i8, i8* %283, i64 %315
%317 = bitcast i8* %316 to <16 x i8>*
store <16 x i8> %314, <16 x i8>* %317
%318 = or i32 %287, 48
%319 = sub i32 %213, %318
%320 = sub i32 %319, %123
%321 = zext i32 %320 to i64
%322 = getelementptr inbounds i8, i8* %284, i64 %321
%323 = bitcast i8* %322 to <16 x i8>*
%324 = load <16 x i8>, <16 x i8>* %323
%325 = zext i32 %319 to i64
%326 = getelementptr inbounds i8, i8* %285, i64 %325
%327 = bitcast i8* %326 to <16 x i8>*
store <16 x i8> %324, <16 x i8>* %327
%328 = add nuw i32 %287, 64
%329 = add i32 %288, 4
%330 = icmp eq i32 %329, %277
br i1 %330, label %331, label %286
331: ; preds = %286, %269
%332 = phi i32 [ 0, %269 ], [ %328, %286 ]
%333 = icmp eq i32 %274, 0
br i1 %333, label %352, label %334
334: ; preds = %331
%335 = getelementptr inbounds i8, i8* %211, i64 -15
%336 = getelementptr inbounds i8, i8* %211, i64 -15
br label %337
337: ; preds = %337, %334
%338 = phi i32 [ %332, %334 ], [ %349, %337 ]
%339 = phi i32 [ 0, %334 ], [ %350, %337 ]
%340 = sub i32 %213, %338
%341 = sub i32 %340, %123
%342 = zext i32 %341 to i64
%343 = getelementptr inbounds i8, i8* %335, i64 %342
%344 = bitcast i8* %343 to <16 x i8>*
%345 = load <16 x i8>, <16 x i8>* %344
%346 = zext i32 %340 to i64
%347 = getelementptr inbounds i8, i8* %336, i64 %346
%348 = bitcast i8* %347 to <16 x i8>*
store <16 x i8> %345, <16 x i8>* %348
%349 = add nuw i32 %338, 16
%350 = add i32 %339, 1
%351 = icmp eq i32 %350, %274
br i1 %351, label %352, label %337
352: ; preds = %337, %331
%353 = icmp eq i32 %220, %270
br i1 %353, label %539, label %354
354: ; preds = %352
%355 = sub i32 %213, %270
%356 = and i32 %220, 12
%357 = icmp eq i32 %356, 0
br i1 %357, label %384, label %358
358: ; preds = %267, %354
%359 = phi i32 [ %270, %354 ], [ 0, %267 ]
%360 = add i32 %141, %169
%361 = call i32 @llvm.umin.i32(i32 %182, i32 %360)
%362 = add i32 %139, %169
%363 = add i32 %60, %361
%364 = sub i32 %362, %363
%365 = and i32 %364, -4
%366 = sub i32 %213, %365
%367 = getelementptr inbounds i8, i8* %211, i64 -3
%368 = getelementptr inbounds i8, i8* %211, i64 -3
br label %369
369: ; preds = %369, %358
%370 = phi i32 [ %359, %358 ], [ %380, %369 ]
%371 = sub i32 %213, %370
%372 = sub i32 %371, %123
%373 = zext i32 %372 to i64
%374 = getelementptr inbounds i8, i8* %367, i64 %373
%375 = bitcast i8* %374 to <4 x i8>*
%376 = load <4 x i8>, <4 x i8>* %375
%377 = zext i32 %371 to i64
%378 = getelementptr inbounds i8, i8* %368, i64 %377
%379 = bitcast i8* %378 to <4 x i8>*
store <4 x i8> %376, <4 x i8>* %379
%380 = add nuw i32 %370, 4
%381 = icmp eq i32 %380, %365
br i1 %381, label %382, label %369
382: ; preds = %369
%383 = icmp eq i32 %364, %365
br i1 %383, label %539, label %384
384: ; preds = %246, %222, %215, %354, %382
%385 = phi i32 [ %213, %215 ], [ %213, %246 ], [ %213, %222 ], [ %355, %354 ], [ %366, %382 ]
br label %394
386: ; preds = %205, %386
%387 = phi i8* [ %391, %386 ], [ %166, %205 ]
%388 = phi i32 [ %390, %386 ], [ %168, %205 ]
%389 = lshr i32 %388, 1
%390 = add i32 %389, %388
%391 = tail call i8* @realloc(i8* %387, i32 %390)
%392 = add i32 %390, -1
%393 = icmp ult i32 %206, %392
br i1 %393, label %209, label %386
394: ; preds = %384, %394
%395 = phi i32 [ %402, %394 ], [ %385, %384 ]
%396 = sub i32 %395, %123
%397 = zext i32 %396 to i64
%398 = getelementptr inbounds i8, i8* %211, i64 %397
%399 = load i8, i8* %398
%400 = zext i32 %395 to i64
%401 = getelementptr inbounds i8, i8* %211, i64 %400
store i8 %399, i8* %401
%402 = add i32 %395, -1
%403 = icmp ult i32 %402, %212
br i1 %403, label %539, label %394
404: ; preds = %204
br i1 %121, label %405, label %539
405: ; preds = %404
%406 = add i32 %167, %114
%407 = sub i32 %169, %122
%408 = icmp ult i32 %406, %407
br i1 %408, label %409, label %539
409: ; preds = %405
%410 = zext i32 %407 to i64
%411 = sub nsw i64 %410, %173
%412 = icmp ult i64 %411, 8
br i1 %412, label %527, label %413
413: ; preds = %409
%414 = xor i64 %178, -1
%415 = add nsw i64 %414, %410
%416 = trunc i64 %415 to i32
%417 = xor i32 %180, -1
%418 = icmp ult i32 %417, %416
%419 = icmp ugt i64 %415, 4294967295
%420 = or i1 %418, %419
br i1 %420, label %527, label %421
421: ; preds = %413
%422 = getelementptr i8, i8* %166, i64 %174
%423 = getelementptr i8, i8* %166, i64 %410
%424 = getelementptr i8, i8* %166, i64 %177
%425 = add nuw nsw i64 %177, %410
%426 = sub nsw i64 %425, %174
%427 = getelementptr i8, i8* %166, i64 %426
%428 = icmp ult i8* %422, %427
%429 = icmp ult i8* %424, %423
%430 = and i1 %428, %429
br i1 %430, label %527, label %431
431: ; preds = %421
%432 = icmp ult i64 %411, 32
br i1 %432, label %504, label %433
433: ; preds = %431
%434 = and i64 %411, -32
%435 = add nsw i64 %434, -32
%436 = lshr exact i64 %435, 5
%437 = add nuw nsw i64 %436, 1
%438 = and i64 %437, 1
%439 = icmp eq i64 %435, 0
br i1 %439, label %479, label %440
440: ; preds = %433
%441 = and i64 %437, 1152921504606846974
br label %442
442: ; preds = %442, %440
%443 = phi i64 [ 0, %440 ], [ %476, %442 ]
%444 = phi i64 [ 0, %440 ], [ %477, %442 ]
%445 = add i64 %443, %190
%446 = trunc i64 %443 to i32
%447 = add i32 %165, %446
%448 = add i32 %122, %447
%449 = zext i32 %448 to i64
%450 = getelementptr inbounds i8, i8* %166, i64 %449
%451 = bitcast i8* %450 to <16 x i8>*
%452 = load <16 x i8>, <16 x i8>* %451
%453 = getelementptr inbounds i8, i8* %450, i64 16
%454 = bitcast i8* %453 to <16 x i8>*
%455 = load <16 x i8>, <16 x i8>* %454
%456 = getelementptr inbounds i8, i8* %166, i64 %445
%457 = bitcast i8* %456 to <16 x i8>*
store <16 x i8> %452, <16 x i8>* %457
%458 = getelementptr inbounds i8, i8* %456, i64 16
%459 = bitcast i8* %458 to <16 x i8>*
store <16 x i8> %455, <16 x i8>* %459
%460 = or i64 %443, 32
%461 = add i64 %460, %190
%462 = trunc i64 %460 to i32
%463 = add i32 %165, %462
%464 = add i32 %122, %463
%465 = zext i32 %464 to i64
%466 = getelementptr inbounds i8, i8* %166, i64 %465
%467 = bitcast i8* %466 to <16 x i8>*
%468 = load <16 x i8>, <16 x i8>* %467
%469 = getelementptr inbounds i8, i8* %466, i64 16
%470 = bitcast i8* %469 to <16 x i8>*
%471 = load <16 x i8>, <16 x i8>* %470
%472 = getelementptr inbounds i8, i8* %166, i64 %461
%473 = bitcast i8* %472 to <16 x i8>*
store <16 x i8> %468, <16 x i8>* %473
%474 = getelementptr inbounds i8, i8* %472, i64 16
%475 = bitcast i8* %474 to <16 x i8>*
store <16 x i8> %471, <16 x i8>* %475
%476 = add nuw i64 %443, 64
%477 = add i64 %444, 2
%478 = icmp eq i64 %477, %441
br i1 %478, label %479, label %442
479: ; preds = %442, %433
%480 = phi i64 [ 0, %433 ], [ %476, %442 ]
%481 = icmp eq i64 %438, 0
br i1 %481, label %498, label %482
482: ; preds = %479
%483 = add i64 %480, %190
%484 = trunc i64 %480 to i32
%485 = add i32 %165, %484
%486 = add i32 %122, %485
%487 = zext i32 %486 to i64
%488 = getelementptr inbounds i8, i8* %166, i64 %487
%489 = bitcast i8* %488 to <16 x i8>*
%490 = load <16 x i8>, <16 x i8>* %489
%491 = getelementptr inbounds i8, i8* %488, i64 16
%492 = bitcast i8* %491 to <16 x i8>*
%493 = load <16 x i8>, <16 x i8>* %492
%494 = getelementptr inbounds i8, i8* %166, i64 %483
%495 = bitcast i8* %494 to <16 x i8>*
store <16 x i8> %490, <16 x i8>* %495
%496 = getelementptr inbounds i8, i8* %494, i64 16
%497 = bitcast i8* %496 to <16 x i8>*
store <16 x i8> %493, <16 x i8>* %497
br label %498
498: ; preds = %479, %482
%499 = icmp eq i64 %411, %434
br i1 %499, label %539, label %500
500: ; preds = %498
%501 = add nsw i64 %434, %190
%502 = and i64 %411, 24
%503 = icmp eq i64 %502, 0
br i1 %503, label %527, label %504
504: ; preds = %431, %500
%505 = phi i64 [ %434, %500 ], [ 0, %431 ]
%506 = add i32 %142, %169
%507 = zext i32 %506 to i64
%508 = sub nsw i64 %507, %172
%509 = and i64 %508, -8
%510 = add nsw i64 %509, %190
br label %511
511: ; preds = %511, %504
%512 = phi i64 [ %505, %504 ], [ %523, %511 ]
%513 = add i64 %512, %190
%514 = trunc i64 %512 to i32
%515 = add i32 %165, %514
%516 = add i32 %122, %515
%517 = zext i32 %516 to i64
%518 = getelementptr inbounds i8, i8* %166, i64 %517
%519 = bitcast i8* %518 to <8 x i8>*
%520 = load <8 x i8>, <8 x i8>* %519
%521 = getelementptr inbounds i8, i8* %166, i64 %513
%522 = bitcast i8* %521 to <8 x i8>*
store <8 x i8> %520, <8 x i8>* %522
%523 = add nuw i64 %512, 8
%524 = icmp eq i64 %523, %509
br i1 %524, label %525, label %511
525: ; preds = %511
%526 = icmp eq i64 %508, %509
br i1 %526, label %539, label %527
527: ; preds = %421, %413, %409, %500, %525
%528 = phi i64 [ %190, %409 ], [ %190, %421 ], [ %190, %413 ], [ %501, %500 ], [ %510, %525 ]
br label %529
529: ; preds = %527, %529
%530 = phi i64 [ %537, %529 ], [ %528, %527 ]
%531 = trunc i64 %530 to i32
%532 = add i32 %122, %531
%533 = zext i32 %532 to i64
%534 = getelementptr inbounds i8, i8* %166, i64 %533
%535 = load i8, i8* %534
%536 = getelementptr inbounds i8, i8* %166, i64 %530
store i8 %535, i8* %536
%537 = add nuw nsw i64 %530, 1
%538 = icmp ult i64 %537, %410
br i1 %538, label %529, label %539
539: ; preds = %529, %394, %498, %525, %352, %382, %404, %209, %405
%540 = phi i32 [ %169, %404 ], [ %206, %209 ], [ %407, %405 ], [ %206, %382 ], [ %206, %352 ], [ %407, %525 ], [ %407, %498 ], [ %206, %394 ], [ %407, %529 ]
%541 = phi i32 [ %168, %404 ], [ %210, %209 ], [ %168, %405 ], [ %210, %382 ], [ %210, %352 ], [ %168, %525 ], [ %168, %498 ], [ %210, %394 ], [ %168, %529 ]
%542 = phi i8* [ %166, %404 ], [ %211, %209 ], [ %166, %405 ], [ %211, %382 ], [ %211, %352 ], [ %166, %525 ], [ %166, %498 ], [ %211, %394 ], [ %166, %529 ]
br i1 %147, label %654, label %543
543: ; preds = %539
%544 = xor i32 %167, -1
%545 = icmp ult i32 %544, %148
%546 = or i1 %545, %149
br i1 %546, label %654, label %547
547: ; preds = %543
%548 = getelementptr i8, i8* %542, i64 %164
%549 = getelementptr i8, i8* %542, i64 %189
%550 = icmp ult i8* %112, %549
%551 = icmp ult i8* %548, %127
%552 = and i1 %550, %551
br i1 %552, label %654, label %553
553: ; preds = %547
br i1 %150, label %639, label %554
554: ; preds = %553
br i1 %153, label %616, label %555
555: ; preds = %554, %555
%556 = phi i64 [ %613, %555 ], [ 0, %554 ]
%557 = phi i64 [ %614, %555 ], [ 0, %554 ]
%558 = trunc i64 %556 to i32
%559 = getelementptr inbounds i8, i8* %112, i64 %556
%560 = bitcast i8* %559 to <16 x i8>*
%561 = load <16 x i8>, <16 x i8>* %560
%562 = getelementptr inbounds i8, i8* %559, i64 16
%563 = bitcast i8* %562 to <16 x i8>*
%564 = load <16 x i8>, <16 x i8>* %563
%565 = add i32 %167, %558
%566 = zext i32 %565 to i64
%567 = getelementptr inbounds i8, i8* %542, i64 %566
%568 = bitcast i8* %567 to <16 x i8>*
store <16 x i8> %561, <16 x i8>* %568
%569 = getelementptr inbounds i8, i8* %567, i64 16
%570 = bitcast i8* %569 to <16 x i8>*
store <16 x i8> %564, <16 x i8>* %570
%571 = or i64 %556, 32
%572 = trunc i64 %571 to i32
%573 = getelementptr inbounds i8, i8* %112, i64 %571
%574 = bitcast i8* %573 to <16 x i8>*
%575 = load <16 x i8>, <16 x i8>* %574
%576 = getelementptr inbounds i8, i8* %573, i64 16
%577 = bitcast i8* %576 to <16 x i8>*
%578 = load <16 x i8>, <16 x i8>* %577
%579 = add i32 %167, %572
%580 = zext i32 %579 to i64
%581 = getelementptr inbounds i8, i8* %542, i64 %580
%582 = bitcast i8* %581 to <16 x i8>*
store <16 x i8> %575, <16 x i8>* %582
%583 = getelementptr inbounds i8, i8* %581, i64 16
%584 = bitcast i8* %583 to <16 x i8>*
store <16 x i8> %578, <16 x i8>* %584
%585 = or i64 %556, 64
%586 = trunc i64 %585 to i32
%587 = getelementptr inbounds i8, i8* %112, i64 %585
%588 = bitcast i8* %587 to <16 x i8>*
%589 = load <16 x i8>, <16 x i8>* %588
%590 = getelementptr inbounds i8, i8* %587, i64 16
%591 = bitcast i8* %590 to <16 x i8>*
%592 = load <16 x i8>, <16 x i8>* %591
%593 = add i32 %167, %586
%594 = zext i32 %593 to i64
%595 = getelementptr inbounds i8, i8* %542, i64 %594
%596 = bitcast i8* %595 to <16 x i8>*
store <16 x i8> %589, <16 x i8>* %596
%597 = getelementptr inbounds i8, i8* %595, i64 16
%598 = bitcast i8* %597 to <16 x i8>*
store <16 x i8> %592, <16 x i8>* %598
%599 = or i64 %556, 96
%600 = trunc i64 %599 to i32
%601 = getelementptr inbounds i8, i8* %112, i64 %599
%602 = bitcast i8* %601 to <16 x i8>*
%603 = load <16 x i8>, <16 x i8>* %602
%604 = getelementptr inbounds i8, i8* %601, i64 16
%605 = bitcast i8* %604 to <16 x i8>*
%606 = load <16 x i8>, <16 x i8>* %605
%607 = add i32 %167, %600
%608 = zext i32 %607 to i64
%609 = getelementptr inbounds i8, i8* %542, i64 %608
%610 = bitcast i8* %609 to <16 x i8>*
store <16 x i8> %603, <16 x i8>* %610
%611 = getelementptr inbounds i8, i8* %609, i64 16
%612 = bitcast i8* %611 to <16 x i8>*
store <16 x i8> %606, <16 x i8>* %612
%613 = add nuw i64 %556, 128
%614 = add i64 %557, 4
%615 = icmp eq i64 %614, %154
br i1 %615, label %616, label %555
616: ; preds = %555, %554
%617 = phi i64 [ 0, %554 ], [ %613, %555 ]
br i1 %155, label %637, label %618
618: ; preds = %616, %618
%619 = phi i64 [ %634, %618 ], [ %617, %616 ]
%620 = phi i64 [ %635, %618 ], [ 0, %616 ]
%621 = trunc i64 %619 to i32
%622 = getelementptr inbounds i8, i8* %112, i64 %619
%623 = bitcast i8* %622 to <16 x i8>*
%624 = load <16 x i8>, <16 x i8>* %623
%625 = getelementptr inbounds i8, i8* %622, i64 16
%626 = bitcast i8* %625 to <16 x i8>*
%627 = load <16 x i8>, <16 x i8>* %626
%628 = add i32 %167, %621
%629 = zext i32 %628 to i64
%630 = getelementptr inbounds i8, i8* %542, i64 %629
%631 = bitcast i8* %630 to <16 x i8>*
store <16 x i8> %624, <16 x i8>* %631
%632 = getelementptr inbounds i8, i8* %630, i64 16
%633 = bitcast i8* %632 to <16 x i8>*
store <16 x i8> %627, <16 x i8>* %633
%634 = add nuw i64 %619, 32
%635 = add i64 %620, 1
%636 = icmp eq i64 %635, %152
br i1 %636, label %637, label %618
637: ; preds = %618, %616
br i1 %156, label %704, label %638
638: ; preds = %637
br i1 %158, label %654, label %639
639: ; preds = %553, %638
%640 = phi i64 [ %151, %638 ], [ 0, %553 ]
br label %641
641: ; preds = %641, %639
%642 = phi i64 [ %640, %639 ], [ %651, %641 ]
%643 = trunc i64 %642 to i32
%644 = getelementptr inbounds i8, i8* %112, i64 %642
%645 = bitcast i8* %644 to <8 x i8>*
%646 = load <8 x i8>, <8 x i8>* %645
%647 = add i32 %167, %643
%648 = zext i32 %647 to i64
%649 = getelementptr inbounds i8, i8* %542, i64 %648
%650 = bitcast i8* %649 to <8 x i8>*
store <8 x i8> %646, <8 x i8>* %650
%651 = add nuw i64 %642, 8
%652 = icmp eq i64 %651, %159
br i1 %652, label %653, label %641
653: ; preds = %641
br i1 %160, label %704, label %654
654: ; preds = %547, %543, %539, %638, %653
%655 = phi i64 [ 0, %539 ], [ 0, %547 ], [ 0, %543 ], [ %151, %638 ], [ %159, %653 ]
%656 = xor i64 %655, -1
%657 = add nsw i64 %656, %125
br i1 %162, label %670, label %658
658: ; preds = %654, %658
%659 = phi i64 [ %667, %658 ], [ %655, %654 ]
%660 = phi i64 [ %668, %658 ], [ 0, %654 ]
%661 = getelementptr inbounds i8, i8* %112, i64 %659
%662 = load i8, i8* %661
%663 = trunc i64 %659 to i32
%664 = add i32 %167, %663
%665 = zext i32 %664 to i64
%666 = getelementptr inbounds i8, i8* %542, i64 %665
store i8 %662, i8* %666
%667 = add nuw nsw i64 %659, 1
%668 = add i64 %660, 1
%669 = icmp eq i64 %668, %161
br i1 %669, label %670, label %658
670: ; preds = %658, %654
%671 = phi i64 [ %655, %654 ], [ %667, %658 ]
%672 = icmp ult i64 %657, 3
br i1 %672, label %704, label %673
673: ; preds = %670, %673
%674 = phi i64 [ %702, %673 ], [ %671, %670 ]
%675 = getelementptr inbounds i8, i8* %112, i64 %674
%676 = load i8, i8* %675
%677 = trunc i64 %674 to i32
%678 = add i32 %167, %677
%679 = zext i32 %678 to i64
%680 = getelementptr inbounds i8, i8* %542, i64 %679
store i8 %676, i8* %680
%681 = add nuw nsw i64 %674, 1
%682 = getelementptr inbounds i8, i8* %112, i64 %681
%683 = load i8, i8* %682
%684 = trunc i64 %681 to i32
%685 = add i32 %167, %684
%686 = zext i32 %685 to i64
%687 = getelementptr inbounds i8, i8* %542, i64 %686
store i8 %683, i8* %687
%688 = add nuw nsw i64 %674, 2
%689 = getelementptr inbounds i8, i8* %112, i64 %688
%690 = load i8, i8* %689
%691 = trunc i64 %688 to i32
%692 = add i32 %167, %691
%693 = zext i32 %692 to i64
%694 = getelementptr inbounds i8, i8* %542, i64 %693
store i8 %690, i8* %694
%695 = add nuw nsw i64 %674, 3
%696 = getelementptr inbounds i8, i8* %112, i64 %695
%697 = load i8, i8* %696
%698 = trunc i64 %695 to i32
%699 = add i32 %167, %698
%700 = zext i32 %699 to i64
%701 = getelementptr inbounds i8, i8* %542, i64 %700
store i8 %697, i8* %701
%702 = add nuw nsw i64 %674, 4
%703 = icmp eq i64 %702, %125
br i1 %703, label %704, label %673
704: ; preds = %193, %670, %673, %637, %653
%705 = phi i32 [ %540, %653 ], [ %540, %637 ], [ %540, %673 ], [ %540, %670 ], [ %169, %193 ]
%706 = phi i32 [ %541, %653 ], [ %541, %637 ], [ %541, %673 ], [ %541, %670 ], [ %168, %193 ]
%707 = phi i8* [ %542, %653 ], [ %542, %637 ], [ %542, %673 ], [ %542, %670 ], [ %166, %193 ]
%708 = add nuw i32 %167, 1
%709 = add i32 %115, %705
%710 = icmp ult i32 %708, %709
%711 = add i32 %165, 1
%712 = add i64 %164, 1
br i1 %710, label %163, label %713
713: ; preds = %704, %110
%714 = phi i32 [ %50, %110 ], [ %705, %704 ]
%715 = phi i32 [ %51, %110 ], [ %706, %704 ]
%716 = phi i8* [ %54, %110 ], [ %707, %704 ]
%717 = icmp eq i8 %111, 44
br i1 %717, label %49, label %718
718: ; preds = %713
%719 = zext i32 %714 to i64
%720 = getelementptr inbounds i8, i8* %716, i64 %719
store i8 0, i8* %720
%721 = icmp eq i32 %714, 0
br i1 %721, label %847, label %722
722: ; preds = %718
%723 = add i32 %714, -1
%724 = zext i32 %723 to i64
br label %725
725: ; preds = %722, %842
%726 = phi i32 [ 0, %722 ], [ %846, %842 ]
%727 = phi i64 [ %719, %722 ], [ %732, %842 ]
%728 = phi i64 [ %724, %722 ], [ %845, %842 ]
%729 = phi i32 [ %714, %722 ], [ %843, %842 ]
%730 = sub i32 %726, %714
%731 = sub i32 %726, %714
%732 = add nsw i64 %727, -1
%733 = getelementptr inbounds i8, i8* %716, i64 %732
%734 = load i8, i8* %733
%735 = sext i8 %734 to i32
switch i32 %735, label %842 [
i32 97, label %830
i32 98, label %831
i32 120, label %736
]
736: ; preds = %725
%737 = zext i32 %729 to i64
%738 = icmp ult i64 %732, %737
br i1 %738, label %739, label %840
739: ; preds = %736
%740 = add i32 %729, %731
%741 = zext i32 %740 to i64
%742 = add nuw nsw i64 %741, 1
%743 = icmp ult i32 %740, 7
br i1 %743, label %828, label %744
744: ; preds = %739
%745 = icmp ult i32 %740, 31
br i1 %745, label %808, label %746
746: ; preds = %744
%747 = and i64 %742, 8589934560
%748 = add nsw i64 %747, -32
%749 = lshr exact i64 %748, 5
%750 = add nuw nsw i64 %749, 1
%751 = and i64 %750, 1
%752 = icmp eq i64 %748, 0
br i1 %752, label %786, label %753
753: ; preds = %746
%754 = and i64 %750, 1152921504606846974
br label %755
755: ; preds = %755, %753
%756 = phi i64 [ 0, %753 ], [ %783, %755 ]
%757 = phi i64 [ 0, %753 ], [ %784, %755 ]
%758 = add i64 %728, %756
%759 = add nsw i64 %758, 1
%760 = getelementptr inbounds i8, i8* %716, i64 %759
%761 = bitcast i8* %760 to <16 x i8>*
%762 = load <16 x i8>, <16 x i8>* %761
%763 = getelementptr inbounds i8, i8* %760, i64 16
%764 = bitcast i8* %763 to <16 x i8>*
%765 = load <16 x i8>, <16 x i8>* %764
%766 = getelementptr inbounds i8, i8* %716, i64 %758
%767 = bitcast i8* %766 to <16 x i8>*
store <16 x i8> %762, <16 x i8>* %767
%768 = getelementptr inbounds i8, i8* %766, i64 16
%769 = bitcast i8* %768 to <16 x i8>*
store <16 x i8> %765, <16 x i8>* %769
%770 = or i64 %756, 32
%771 = add i64 %728, %770
%772 = add nsw i64 %771, 1
%773 = getelementptr inbounds i8, i8* %716, i64 %772
%774 = bitcast i8* %773 to <16 x i8>*
%775 = load <16 x i8>, <16 x i8>* %774
%776 = getelementptr inbounds i8, i8* %773, i64 16
%777 = bitcast i8* %776 to <16 x i8>*
%778 = load <16 x i8>, <16 x i8>* %777
%779 = getelementptr inbounds i8, i8* %716, i64 %771
%780 = bitcast i8* %779 to <16 x i8>*
store <16 x i8> %775, <16 x i8>* %780
%781 = getelementptr inbounds i8, i8* %779, i64 16
%782 = bitcast i8* %781 to <16 x i8>*
store <16 x i8> %778, <16 x i8>* %782
%783 = add nuw i64 %756, 64
%784 = add i64 %757, 2
%785 = icmp eq i64 %784, %754
br i1 %785, label %786, label %755
786: ; preds = %755, %746
%787 = phi i64 [ 0, %746 ], [ %783, %755 ]
%788 = icmp eq i64 %751, 0
br i1 %788, label %802, label %789
789: ; preds = %786
%790 = add i64 %728, %787
%791 = add nsw i64 %790, 1
%792 = getelementptr inbounds i8, i8* %716, i64 %791
%793 = bitcast i8* %792 to <16 x i8>*
%794 = load <16 x i8>, <16 x i8>* %793
%795 = getelementptr inbounds i8, i8* %792, i64 16
%796 = bitcast i8* %795 to <16 x i8>*
%797 = load <16 x i8>, <16 x i8>* %796
%798 = getelementptr inbounds i8, i8* %716, i64 %790
%799 = bitcast i8* %798 to <16 x i8>*
store <16 x i8> %794, <16 x i8>* %799
%800 = getelementptr inbounds i8, i8* %798, i64 16
%801 = bitcast i8* %800 to <16 x i8>*
store <16 x i8> %797, <16 x i8>* %801
br label %802
802: ; preds = %786, %789
%803 = icmp eq i64 %742, %747
br i1 %803, label %840, label %804
804: ; preds = %802
%805 = add i64 %728, %747
%806 = and i64 %742, 24
%807 = icmp eq i64 %806, 0
br i1 %807, label %828, label %808
808: ; preds = %744, %804
%809 = phi i64 [ %747, %804 ], [ 0, %744 ]
%810 = add i32 %729, %730
%811 = zext i32 %810 to i64
%812 = add nuw nsw i64 %811, 1
%813 = and i64 %812, 8589934584
%814 = add i64 %728, %813
br label %815
815: ; preds = %815, %808
%816 = phi i64 [ %809, %808 ], [ %824, %815 ]
%817 = add i64 %728, %816
%818 = add nsw i64 %817, 1
%819 = getelementptr inbounds i8, i8* %716, i64 %818
%820 = bitcast i8* %819 to <8 x i8>*
%821 = load <8 x i8>, <8 x i8>* %820
%822 = getelementptr inbounds i8, i8* %716, i64 %817
%823 = bitcast i8* %822 to <8 x i8>*
store <8 x i8> %821, <8 x i8>* %823
%824 = add nuw i64 %816, 8
%825 = icmp eq i64 %824, %813
br i1 %825, label %826, label %815
826: ; preds = %815
%827 = icmp eq i64 %812, %813
br i1 %827, label %840, label %828
828: ; preds = %739, %804, %826
%829 = phi i64 [ %728, %739 ], [ %805, %804 ], [ %814, %826 ]
br label %832
830: ; preds = %725
store i8 48, i8* %733
br label %842
831: ; preds = %725
store i8 49, i8* %733
br label %842
832: ; preds = %828, %832
%833 = phi i64 [ %834, %832 ], [ %829, %828 ]
%834 = add nsw i64 %833, 1
%835 = getelementptr inbounds i8, i8* %716, i64 %834
%836 = load i8, i8* %835
%837 = getelementptr inbounds i8, i8* %716, i64 %833
store i8 %836, i8* %837
%838 = trunc i64 %834 to i32
%839 = icmp eq i32 %729, %838
br i1 %839, label %840, label %832
840: ; preds = %832, %802, %826, %736
%841 = add i32 %729, -1
br label %842
842: ; preds = %830, %831, %725, %840
%843 = phi i32 [ %729, %725 ], [ %841, %840 ], [ %729, %831 ], [ %729, %830 ]
%844 = icmp eq i64 %732, 0
%845 = add nsw i64 %728, -1
%846 = add i32 %726, 1
br i1 %844, label %847, label %725
847: ; preds = %842, %718
%848 = tail call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i8* %716)
%849 = tail call signext i8 @getc(i32* %13)
%850 = load i8, i8* @EOF
%851 = icmp eq i8 %849, %850
br i1 %851, label %852, label %17
852: ; preds = %847, %10
%853 = phi i8* [ %3, %10 ], [ %716, %847 ]
%854 = phi i8* [ %4, %10 ], [ %62, %847 ]
%855 = phi i8* [ %5, %10 ], [ %112, %847 ]
%856 = tail call i32 @free(i8* %853)
%857 = tail call i32 @free(i8* %854)
%858 = tail call i32 @free(i8* %855)
br label %859
859: ; preds = %852, %7
%860 = phi i32 [ 1, %7 ], [ 0, %852 ]
ret i32 %860
}