#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/ *, char *, ...);
int fscanf(int /*<<< orphan*/ *, char *, int *);
scalar_t__ malloc(int);
scalar_t__ realloc(int *, int);
int /*<<< orphan*/ *stdin;
int /*<<< orphan*/ *stdout;
void main(int argc, char **argv) {
  int tmp, lit;
  int *data, size = 0, max = 1000000, *buffer, bsize;
  int blast = max, lsize = 0;
  int fixed = 0;
  FILE *input = stdin;
  FILE *output = stdout;
  data = (int *)malloc(sizeof(int) * max);
  buffer = (int *)malloc(sizeof(int) * max);
  bsize = 0;
  do {
  start:
    if (bsize == fixed) {
      tmp = fscanf(input, " b %i ", &lit);
      if (tmp == 1) {
        buffer[fixed++] = -lit;
        bsize++;
        goto start;
      }
    }
    tmp = fscanf(input, " %i ", &lit);
    if (tmp > 0) {
      buffer[bsize++] = lit;
      if (lit == 0) {
        int i, flag;
        for (i = 0; i < bsize; i++)
          fprintf(output, "%i ", buffer[i]);
        fprintf(output, "\n");
        if (bsize == 1)
          break;
        delete : flag = (bsize < blast);
        if (flag) {
          for (i = 0; i < bsize - 1; i++)
            if (data[lsize + i] != buffer[i])
              flag = 0;
        }
        if (flag) {
          fprintf(output, "d ");
          for (i = 0; i < blast; i++)
            fprintf(output, "%i ", data[lsize + i]);
          fprintf(output, "\n");
          size = lsize;
          lsize--;
          blast = 1;
          while (data[lsize - 1] != 0) {
            blast++;
            lsize--;
          }
          goto delete;
        }
        lsize = size;
        if (size + bsize >= max) {
          max = max * 2;
          data = (int *)realloc(data, sizeof(int) * max);
        }
        for (i = 0; i < bsize; i++)
          data[size++] = buffer[i];
        blast = bsize;
        if (bsize == fixed + 1)
          fixed--;
        bsize = fixed;
      }
    } else
      break;
  } while (1);
  fclose(input);
  fclose(output);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0xf4240,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    0x2e60(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    0x2e42(%rip),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
movslq -0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x20(%rbp)
movslq -0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
jmp    11cf <main+0x7f>
mov    -0x34(%rbp),%eax
cmp    -0x40(%rbp),%eax
jne    1229 <main+0xd9>
mov    -0x48(%rbp),%rdi
lea    0xe1a(%rip),%rsi
lea    -0x18(%rbp),%rdx
call   1040 <fscanf@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0x1,-0x14(%rbp)
jne    1224 <main+0xd4>
xor    %edx,%edx
sub    -0x18(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11cf <main+0x7f>
jmp    1229 <main+0xd9>
mov    -0x48(%rbp),%rdi
lea    0xdce(%rip),%rsi
lea    -0x18(%rbp),%rdx
call   1040 <fscanf@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    149e <main+0x34e>
mov    -0x18(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x18(%rbp)
jne    1499 <main+0x349>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    12aa <main+0x15a>
mov    -0x50(%rbp),%rdi
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xd6e(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1273 <main+0x123>
mov    -0x50(%rbp),%rdi
lea    0xd52(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
cmpl   $0x1,-0x34(%rbp)
jne    12cb <main+0x17b>
jmp    14b7 <main+0x367>
jmp    12d0 <main+0x180>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x58(%rbp)
cmpl   $0x0,-0x58(%rbp)
je     1343 <main+0x1f3>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    133e <main+0x1ee>
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x54(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
je     132b <main+0x1db>
movl   $0x0,-0x58(%rbp)
jmp    1330 <main+0x1e0>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12f2 <main+0x1a2>
jmp    1343 <main+0x1f3>
cmpl   $0x0,-0x58(%rbp)
je     13fd <main+0x2ad>
mov    -0x50(%rbp),%rdi
lea    0xcb1(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    13a2 <main+0x252>
mov    -0x50(%rbp),%rdi
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
lea    0xc76(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1366 <main+0x216>
mov    -0x50(%rbp),%rdi
lea    0xc5a(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13f8 <main+0x2a8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    13ca <main+0x27a>
jmp    12d0 <main+0x180>
mov    -0x24(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jl     1432 <main+0x2e2>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
movslq -0x28(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%esi
call   1070 <realloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1473 <main+0x323>
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1439 <main+0x2e9>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1493 <main+0x343>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    14a3 <main+0x353>
jmp    14b7 <main+0x367>
jmp    14a8 <main+0x358>
mov    $0x1,%al
test   $0x1,%al
jne    11ca <main+0x7a>
jmp    14b7 <main+0x367>
mov    -0x48(%rbp),%rdi
call   1030 <fclose@plt>
mov    -0x50(%rbp),%rdi
call   1030 <fclose@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    0x2e60(%rip),%rax
mov    (%rax),%r14
mov    0x2e46(%rip),%rax
mov    (%rax),%rax
mov    %rax,0x30(%rsp)
mov    $0x3d0900,%edi
call   1070 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    $0x3d0900,%edi
call   1070 <malloc@plt>
mov    %rax,%rbx
add    $0x10,%rax
mov    %rax,0x58(%rsp)
lea    0xc(%rbx),%rax
mov    %rax,0x60(%rsp)
xor    %r12d,%r12d
mov    $0xf4240,%eax
mov    %rax,0x50(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
or     $0x2,%rax
mov    %rax,0x68(%rsp)
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0xf4240,%ebp
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %edx,%edx
mov    %edx,%r13d
cmp    %r13d,%edx
jne    1250 <main+0xe0>
movl   $0x0,0x24(%rsp)
movslq %edx,%r15
mov    %r14,%rdi
lea    0xdf6(%rip),%rsi
lea    0x14(%rsp),%rdx
call   1040 <fscanf@plt>
cmp    $0x1,%eax
jne    1260 <main+0xf0>
xor    %eax,%eax
sub    0x14(%rsp),%eax
lea    0x1(%r15),%r13
mov    %eax,(%rbx,%r15,4)
lea    -0x1(%r13),%eax
cmp    %eax,%r15d
mov    %r13,%r15
je     1210 <main+0xa0>
mov    %r13d,%r15d
jmp    126b <main+0xfb>
nopl   0x0(%rax,%rax,1)
movl   $0x0,0x24(%rsp)
mov    %edx,%r15d
jmp    126b <main+0xfb>
nopl   (%rax)
movl   $0xffffffff,0x24(%rsp)
ff
mov    %r15d,%r13d
mov    %r14,%rdi
lea    0xd9d(%rip),%rsi
lea    0x14(%rsp),%rdx
call   1040 <fscanf@plt>
test   %eax,%eax
jle    1844 <main+0x6d4>
mov    0x14(%rsp),%eax
lea    0x1(%r15),%edx
movslq %r15d,%rcx
mov    %eax,(%rbx,%rcx,4)
cmpl   $0x0,0x14(%rsp)
jne    1200 <main+0x90>
mov    %edx,%ecx
mov    %rcx,0x38(%rsp)
test   %r15d,%r15d
mov    %rdx,0x40(%rsp)
mov    %rbx,0x48(%rsp)
js     1316 <main+0x1a6>
xor    %ebx,%ebx
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x48(%rsp),%rax
mov    (%rax,%rbx,4),%edx
mov    %rsi,%rdi
lea    0xd31(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    0x30(%rsp),%rsi
add    $0x1,%rbx
cmp    %rbx,%r12
jne    12d0 <main+0x160>
mov    $0xa,%edi
call   1050 <fputc@plt>
test   %r15d,%r15d
mov    0x48(%rsp),%rbx
mov    $0x0,%r12d
jne    1325 <main+0x1b5>
jmp    1844 <main+0x6d4>
mov    $0xa,%edi
mov    0x30(%rsp),%rsi
call   1050 <fputc@plt>
mov    0x40(%rsp),%r8
cmp    %ebp,%r8d
jge    1610 <main+0x4a0>
mov    %r15d,%r9d
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x90(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0x88(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x80(%rsp)
and    0x68(%rsp),%rcx
mov    %rcx,0x78(%rsp)
mov    0x18(%rsp),%rax
lea    0x30(%rax),%rcx
mov    %rcx,0x70(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,0xa0(%rsp)
mov    0x8(%rsp),%rax
mov    0x28(%rsp),%rcx
mov    %rcx,0x8(%rsp)
mov    0x30(%rsp),%rcx
mov    %r14,0xb0(%rsp)
mov    %r9,0xa8(%rsp)
mov    %r13,0x98(%rsp)
cs nopw 0x0(%rax,%rax,1)
mov    %eax,%r10d
movslq %eax,%r11
test   %r15d,%r15d
jle    151b <main+0x3ab>
cmp    $0x8,%r15d
jae    13f0 <main+0x280>
mov    $0x1,%eax
xor    %edi,%edi
jmp    14ec <main+0x37c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x88(%rsp)
je     15ee <main+0x47e>
mov    0x70(%rsp),%rax
lea    (%rax,%r11,4),%rsi
mov    0x78(%rsp),%rdx
xor    %eax,%eax
movdqa 0xbe9(%rip),%xmm1
movdqa %xmm1,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rsi,%rax,4),%xmm2
movdqu -0x20(%rsi,%rax,4),%xmm3
movdqu -0x10(%rsi,%rax,4),%xmm4
movdqu (%rsi,%rax,4),%xmm5
movdqu (%rbx,%rax,4),%xmm6
pcmpeqd %xmm2,%xmm6
movdqu 0x10(%rbx,%rax,4),%xmm2
pcmpeqd %xmm3,%xmm2
movdqu 0x20(%rbx,%rax,4),%xmm3
pcmpeqd %xmm4,%xmm3
pand   %xmm6,%xmm3
pand   %xmm3,%xmm0
movdqu 0x30(%rbx,%rax,4),%xmm3
pcmpeqd %xmm5,%xmm3
pand   %xmm2,%xmm3
pand   %xmm3,%xmm1
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdx
jne    1420 <main+0x2b0>
testb  $0x1,0x80(%rsp)
01
je     14b1 <main+0x341>
lea    (%rax,%r11,1),%rsi
mov    0x18(%rsp),%rdx
movdqu (%rdx,%rsi,4),%xmm2
movdqu 0x10(%rdx,%rsi,4),%xmm3
movdqu (%rbx,%rax,4),%xmm4
pcmpeqd %xmm2,%xmm4
pand   %xmm4,%xmm0
movdqu 0x10(%rbx,%rax,4),%xmm2
pcmpeqd %xmm3,%xmm2
pand   %xmm2,%xmm1
movdqa %xmm0,%xmm2
movdqa 0xb43(%rip),%xmm3
pcmpeqd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
pcmpeqd %xmm3,%xmm2
movmskps %xmm2,%edx
xor    %eax,%eax
cmp    $0xf,%edx
sete   %al
mov    0x90(%rsp),%rdx
mov    %rdx,%rdi
cmp    %r9,%rdx
je     1513 <main+0x3a3>
mov    0x18(%rsp),%rdx
lea    (%rdx,%r11,4),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rdi,4),%esi
cmp    (%rbx,%rdi,4),%esi
cmovne %r12d,%eax
add    $0x1,%rdi
cmp    %rdi,%r9
jne    1500 <main+0x390>
test   %eax,%eax
je     161e <main+0x4ae>
mov    %r11,0x8(%rsp)
mov    %r10,0x28(%rsp)
mov    $0x2,%esi
mov    $0x1,%edx
lea    0xae1(%rip),%rdi
mov    %rcx,%r14
call   1090 <fwrite@plt>
test   %ebp,%ebp
lea    0xacc(%rip),%r13
jle    157a <main+0x40a>
mov    %ebp,%ebp
mov    0x18(%rsp),%rax
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,4),%r12
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rbx,4),%edx
mov    %r14,%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1560 <main+0x3f0>
mov    $0xa,%edi
mov    %r14,%rsi
call   1050 <fputc@plt>
mov    0xa0(%rsp),%rax
mov    0x8(%rsp),%rcx
lea    (%rax,%rcx,4),%rax
xor    %ebp,%ebp
mov    %r14,%rcx
nopl   (%rax)
cmpl   $0x0,(%rax,%rbp,4)
lea    -0x1(%rbp),%rbp
jne    15a0 <main+0x430>
mov    0x28(%rsp),%rsi
lea    (%rsi,%rbp,1),%eax
neg    %ebp
mov    %esi,%edx
mov    %rdx,0x8(%rsp)
mov    0x40(%rsp),%r8
cmp    %ebp,%r8d
mov    0xb0(%rsp),%r14
mov    0x48(%rsp),%rbx
mov    $0x0,%r12d
mov    0xa8(%rsp),%r9
mov    0x98(%rsp),%r13
jl     13c0 <main+0x250>
jmp    1617 <main+0x4a7>
xor    %eax,%eax
movdqa 0xa08(%rip),%xmm1
movdqa %xmm1,%xmm0
testb  $0x1,0x80(%rsp)
01
jne    1482 <main+0x312>
jmp    14b1 <main+0x341>
nop
mov    0x28(%rsp),%rax
jmp    1619 <main+0x4a9>
mov    %esi,%eax
mov    %rax,0x8(%rsp)
mov    0x8(%rsp),%rax
add    %r8d,%eax
mov    0x50(%rsp),%rsi
cmp    %esi,%eax
jge    1640 <main+0x4d0>
mov    0x18(%rsp),%rax
jmp    1662 <main+0x4f2>
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rbp
lea    (%rsi,%rsi,1),%ebx
shl    $0x3,%esi
mov    0x18(%rsp),%rdi
call   1080 <realloc@plt>
mov    0x40(%rsp),%r8
mov    %ebx,%ecx
mov    %rcx,0x50(%rsp)
mov    %rbp,%rbx
mov    0x8(%rsp),%rcx
mov    %rcx,0x28(%rsp)
test   %r15d,%r15d
js     182f <main+0x6bf>
movslq 0x8(%rsp),%r10
cmp    $0x8,%r8d
jae    168c <main+0x51c>
xor    %ebp,%ebp
mov    0x38(%rsp),%r9
jmp    17a0 <main+0x630>
lea    (%rax,%r10,4),%rdx
mov    0x38(%rsp),%r9
lea    (%rbx,%r9,4),%rcx
cmp    %rcx,%rdx
jae    16b2 <main+0x542>
lea    (%r10,%r9,1),%rcx
lea    (%rax,%rcx,4),%rcx
cmp    %rcx,%rbx
jae    16b2 <main+0x542>
xor    %ebp,%ebp
jmp    17a0 <main+0x630>
mov    %r9d,%ebp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    16d6 <main+0x566>
xor    %esi,%esi
jmp    174c <main+0x5dc>
and    $0xfffffffffffffffc,%rdx
lea    (%rax,%r10,4),%rdi
add    $0x70,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rbx,%rsi,4),%xmm0
movups 0x10(%rbx,%rsi,4),%xmm1
movups %xmm0,-0x70(%rdi,%rsi,4)
movups %xmm1,-0x60(%rdi,%rsi,4)
movups 0x20(%rbx,%rsi,4),%xmm0
movups 0x30(%rbx,%rsi,4),%xmm1
movups %xmm0,-0x50(%rdi,%rsi,4)
movups %xmm1,-0x40(%rdi,%rsi,4)
movups 0x40(%rbx,%rsi,4),%xmm0
movups 0x50(%rbx,%rsi,4),%xmm1
movups %xmm0,-0x30(%rdi,%rsi,4)
movups %xmm1,-0x20(%rdi,%rsi,4)
movdqu 0x60(%rbx,%rsi,4),%xmm0
movdqu 0x70(%rbx,%rsi,4),%xmm1
movdqu %xmm0,-0x10(%rdi,%rsi,4)
movdqu %xmm1,(%rdi,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    16f0 <main+0x580>
test   %rcx,%rcx
je     178f <main+0x61f>
mov    0x58(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
add    %r10,%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rdi,1),%xmm0
movdqu (%rdx,%rdi,1),%xmm1
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1770 <main+0x600>
add    %rbp,%r10
cmp    %r9,%rbp
je     182a <main+0x6ba>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rcx
not    %rcx
add    %r9,%rcx
mov    %r9,%rdx
and    $0x3,%rdx
je     17d5 <main+0x665>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rbp,4),%esi
mov    %esi,(%rax,%r10,4)
add    $0x1,%r10
add    $0x1,%rbp
add    $0xffffffffffffffff,%rdx
jne    17c0 <main+0x650>
cmp    $0x3,%rcx
jb     182a <main+0x6ba>
lea    (%rax,%r10,4),%rcx
add    $0xc,%rcx
sub    %rbp,%r9
mov    0x60(%rsp),%rdx
lea    (%rdx,%rbp,4),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0xc(%rdx,%rdi,4),%esi
mov    %esi,-0xc(%rcx,%rdi,4)
mov    -0x8(%rdx,%rdi,4),%esi
mov    %esi,-0x8(%rcx,%rdi,4)
mov    -0x4(%rdx,%rdi,4),%esi
mov    %esi,-0x4(%rcx,%rdi,4)
mov    (%rdx,%rdi,4),%esi
mov    %esi,(%rcx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%r9
jne    1800 <main+0x690>
add    %rdi,%r10
mov    %r10,0x28(%rsp)
mov    %rax,0x18(%rsp)
add    0x24(%rsp),%r13d
mov    %r8d,%ebp
mov    %r13d,%edx
jmp    11fd <main+0x8d>
mov    %r14,%rdi
call   1030 <fclose@plt>
mov    0x30(%rsp),%rdi
call   1030 <fclose@plt>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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