#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 */
struct timeval {
  int tv_sec;
  int tv_usec;
};

/* Variables and functions */
int /*<<< orphan*/ MAP_SHARED;
int O_CREAT;
int O_RDWR;
int PROT_READ;
int PROT_WRITE;
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ gettimeofday(struct timeval *, int /*<<< orphan*/ *);
char *mmap(int /*<<< orphan*/, int, int, int /*<<< orphan*/, int,
           int /*<<< orphan*/);
int /*<<< orphan*/ munmap(char *, int);
int open(char *, int);
int /*<<< orphan*/ perror(char *);
int /*<<< orphan*/ printf(char *, long, long, ...);
int /*<<< orphan*/ stderr;
int main(int argc, char *argv[]) {
  char *file1, *file2, *fileout, *temp_out;
  char *pfile1, *pfile2, *pfileout, *cfile;
  int fd1, fd2, fdout;
  int eof1 = 0, eof2 = 0;
  long line1 = 0, line2 = 0, lineout = 0;
  struct timeval before, after;
  int duration;
  int ret = 1;
  int flag = PROT_WRITE | PROT_READ;
  int i = 0;
  int rsize1, rsize2, *csize;
  int currentFile;
  char buffer[1024], *pbuffer, *pbufferfin;
  int sbuf, sbuffin;
  if (argc != 4) {
    fprintf(stderr, "usage: %s file1 file2 fout\n", argv[0]);
    goto leave0;
  }
  if ((fd1 = open(argv[1], O_RDWR | O_CREAT)) < 0) {
    perror(argv[1]);
    goto leave0;
  }
  if ((fd2 = open(argv[2], O_RDWR | O_CREAT)) < 0) {
    perror(argv[2]);
    goto leave1;
  }
  if ((fdout = open(argv[3], O_RDWR | O_CREAT)) < 0) {
    perror(argv[3]);
    goto leave2;
  }
  if ((file1 = mmap(0, 1048576, flag, MAP_SHARED, fd1, 0)) == NULL) {
    perror("mmap error");
    exit(1);
  }
  if ((file2 = mmap(0, 1048576, flag, MAP_SHARED, fd2, 0)) == NULL) {
    perror("mmap error");
    exit(1);
  }
  if ((fileout = mmap(0, 1048576 * 2, flag, MAP_SHARED, fdout, 0)) == NULL) {
    perror("mmap error");
    exit(1);
  }
  gettimeofday(&before, NULL);
  pfile1 = file1;
  pfile2 = file2;
  pfileout = fileout;
  pbuffer = buffer;
  rsize1 = 1048576;
  rsize2 = 1048576;
  sbuf = 0;
  sbuffin = 0;
  currentFile = 1;
  while (rsize1 && rsize2) {
    if (currentFile == 1) {
      rsize1--;
      sbuf++;
      if ((*pfileout++ = *pfile1++) == '\n') {
        currentFile = 2;
      }
    } else if (currentFile == 2) {
      rsize2--;
      sbuf++;
      if ((*pfileout++ = *pfile2++) == '\n') {
        currentFile = 1;
      }
    }
  }
  while (rsize1) {
    *pfileout++ = *pfile1++;
    rsize1--;
  }
  while (rsize2) {
    *pfileout++ = *pfile2++;
    rsize2--;
  }
  gettimeofday(&after, NULL);
  duration = (after.tv_sec - before.tv_sec) * 1000000 +
             (after.tv_usec - before.tv_usec);
  printf("Processing time = %d.%06d sec\n", duration / 1000000,
         duration % 1000000);
  printf("File1 = %ld, File2= %ld, Total = %ld Lines\n", line1, line2, lineout);
  ret = 0;
leave3:
  munmap(fileout, 1048576 * 2);
leave2:
  munmap(file1, 1048576);
  munmap(file2, 1048576);
leave1:
leave0:
  close(fdout);
  close(fd1);
  return ret;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
movq   $0x0,-0x70(%rbp)
movq   $0x0,-0x78(%rbp)
movq   $0x0,-0x80(%rbp)
movl   $0x1,-0x98(%rbp)
mov    0x2dd8(%rip),%rax
mov    (%rax),%eax
mov    0x2e07(%rip),%rcx
or     (%rcx),%eax
mov    %eax,-0x9c(%rbp)
movl   $0x0,-0xa0(%rbp)
cmpl   $0x4,-0x8(%rbp)
je     1226 <main+0x96>
mov    0x2db4(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xde4(%rip),%rsi
call   1070 <fprintf@plt>
jmp    1675 <main+0x4e5>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2d9b(%rip),%rax
mov    (%rax),%esi
mov    0x2dba(%rip),%rax
or     (%rax),%esi
call   1090 <open@plt>
mov    %eax,-0x54(%rbp)
cmp    $0x0,%eax
jge    1263 <main+0xd3>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   10a0 <perror@plt>
jmp    1675 <main+0x4e5>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
mov    0x2d5e(%rip),%rax
mov    (%rax),%esi
mov    0x2d7d(%rip),%rax
or     (%rax),%esi
call   1090 <open@plt>
mov    %eax,-0x58(%rbp)
cmp    $0x0,%eax
jge    12a0 <main+0x110>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   10a0 <perror@plt>
jmp    1670 <main+0x4e0>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
mov    0x2d21(%rip),%rax
mov    (%rax),%esi
mov    0x2d40(%rip),%rax
or     (%rax),%esi
call   1090 <open@plt>
mov    %eax,-0x5c(%rbp)
cmp    $0x0,%eax
jge    12dd <main+0x14d>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   10a0 <perror@plt>
jmp    1654 <main+0x4c4>
mov    -0x9c(%rbp),%edx
mov    0x2cf6(%rip),%rax
mov    (%rax),%ecx
mov    -0x54(%rbp),%r8d
xor    %r9d,%r9d
mov    $0x100000,%esi
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
jne    1324 <main+0x194>
lea    0xd07(%rip),%rdi
call   10a0 <perror@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
mov    -0x9c(%rbp),%edx
mov    0x2caf(%rip),%rax
mov    (%rax),%ecx
mov    -0x58(%rbp),%r8d
xor    %r9d,%r9d
mov    $0x100000,%esi
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    136b <main+0x1db>
lea    0xcc0(%rip),%rdi
call   10a0 <perror@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
mov    -0x9c(%rbp),%edx
mov    0x2c68(%rip),%rax
mov    (%rax),%ecx
mov    -0x5c(%rbp),%r8d
xor    %r9d,%r9d
mov    $0x200000,%esi
mov    %r9d,%edi
call   1030 <mmap@plt>
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jne    13b2 <main+0x222>
lea    0xc79(%rip),%rdi
call   10a0 <perror@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
lea    -0x88(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x48(%rbp)
lea    -0x4c0(%rbp),%rax
mov    %rax,-0x4c8(%rbp)
movl   $0x100000,-0xa4(%rbp)
movl   $0x100000,-0xa8(%rbp)
movl   $0x0,-0x4d4(%rbp)
movl   $0x0,-0x4d8(%rbp)
movl   $0x1,-0xb4(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0xa4(%rbp)
mov    %al,-0x4d9(%rbp)
je     143f <main+0x2af>
cmpl   $0x0,-0xa8(%rbp)
setne  %al
mov    %al,-0x4d9(%rbp)
mov    -0x4d9(%rbp),%al
test   $0x1,%al
jne    1452 <main+0x2c2>
jmp    152c <main+0x39c>
cmpl   $0x1,-0xb4(%rbp)
jne    14ba <main+0x32a>
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x4d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4d4(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%al
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %al,(%rcx)
movsbl %al,%eax
cmp    $0xa,%eax
jne    14b5 <main+0x325>
movl   $0x2,-0xb4(%rbp)
jmp    1527 <main+0x397>
cmpl   $0x2,-0xb4(%rbp)
jne    1522 <main+0x392>
mov    -0xa8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa8(%rbp)
mov    -0x4d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4d4(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%al
mov    -0x48(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %al,(%rcx)
movsbl %al,%eax
cmp    $0xa,%eax
jne    151d <main+0x38d>
movl   $0x1,-0xb4(%rbp)
jmp    1522 <main+0x392>
jmp    1527 <main+0x397>
jmp    141a <main+0x28a>
jmp    1531 <main+0x3a1>
cmpl   $0x0,-0xa4(%rbp)
je     1574 <main+0x3e4>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    1531 <main+0x3a1>
jmp    1579 <main+0x3e9>
cmpl   $0x0,-0xa8(%rbp)
je     15bc <main+0x42c>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0xa8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa8(%rbp)
jmp    1579 <main+0x3e9>
lea    -0x90(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1050 <gettimeofday@plt>
mov    -0x90(%rbp),%eax
sub    -0x88(%rbp),%eax
imul   $0xf4240,%eax,%eax
mov    -0x8c(%rbp),%ecx
sub    -0x84(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
movslq %eax,%rsi
mov    -0x94(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
movslq %edx,%rdx
lea    0xa0c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x80(%rbp),%rcx
lea    0xa11(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x98(%rbp)
mov    -0x28(%rbp),%rdi
mov    $0x200000,%esi
call   1080 <munmap@plt>
mov    -0x18(%rbp),%rdi
mov    $0x100000,%esi
call   1080 <munmap@plt>
mov    -0x20(%rbp),%rdi
mov    $0x100000,%esi
call   1080 <munmap@plt>
jmp    1675 <main+0x4e5>
mov    -0x5c(%rbp),%edi
call   1060 <close@plt>
mov    -0x54(%rbp),%edi
call   1060 <close@plt>
mov    -0x98(%rbp),%eax
add    $0x4e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%r12
cmp    $0x4,%edi
jne    1784 <main+0x5f4>
mov    0x2e07(%rip),%rax
mov    0x2e38(%rip),%rcx
mov    (%rcx),%ebx
or     (%rax),%ebx
mov    0x8(%r12),%rdi
mov    0x2e08(%rip),%r14
mov    0x2e29(%rip),%r15
mov    (%r15),%esi
or     (%r14),%esi
call   1090 <open@plt>
test   %eax,%eax
js     179d <main+0x60d>
mov    %eax,%ebp
mov    0x10(%r12),%rdi
mov    (%r15),%esi
or     (%r14),%esi
call   1090 <open@plt>
test   %eax,%eax
js     17a7 <main+0x617>
mov    %eax,%r13d
mov    0x18(%r12),%rdi
mov    (%r15),%esi
or     (%r14),%esi
call   1090 <open@plt>
mov    %eax,(%rsp)
test   %eax,%eax
js     17b1 <main+0x621>
mov    0x2dbf(%rip),%r14
mov    (%r14),%ecx
xor    %edi,%edi
mov    $0x100000,%esi
mov    %ebx,%edx
mov    %ebp,0x4(%rsp)
mov    %ebp,%r8d
xor    %r9d,%r9d
call   1030 <mmap@plt>
test   %rax,%rax
je     176e <main+0x5de>
mov    %rax,%r12
mov    (%r14),%ecx
xor    %edi,%edi
mov    $0x100000,%esi
mov    %ebx,%edx
mov    %r13d,%r8d
xor    %r9d,%r9d
call   1030 <mmap@plt>
test   %rax,%rax
je     176e <main+0x5de>
mov    %rax,%r15
mov    (%r14),%ecx
xor    %edi,%edi
mov    $0x200000,%esi
mov    %ebx,%edx
mov    (%rsp),%r8d
xor    %r9d,%r9d
call   1030 <mmap@plt>
test   %rax,%rax
je     176e <main+0x5de>
mov    %rax,%r14
lea    0x10(%rsp),%rdi
xor    %esi,%esi
call   1050 <gettimeofday@plt>
mov    $0x100000,%r11d
mov    $0x1,%edx
mov    %r12,%rsi
mov    %r15,%r13
mov    $0x100000,%eax
mov    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    $0x1,%edx
jne    12e0 <main+0x150>
add    $0xffffffff,%eax
movzbl (%rsi),%ebx
add    $0x1,%rsi
mov    %bl,(%rcx)
xor    %edx,%edx
cmp    $0xa,%bl
sete   %dl
add    $0x1,%edx
jmp    12ff <main+0x16f>
xchg   %ax,%ax
add    $0xffffffff,%r11d
movzbl 0x0(%r13),%edx
add    $0x1,%r13
mov    %dl,(%rcx)
xor    %edi,%edi
cmp    $0xa,%dl
sete   %dil
mov    $0x2,%edx
sub    %edi,%edx
add    $0x1,%rcx
test   %eax,%eax
je     130c <main+0x17c>
test   %r11d,%r11d
jne    12c0 <main+0x130>
test   %eax,%eax
je     14b1 <main+0x321>
lea    -0x1(%rax),%edx
cmp    $0x1f,%edx
jb     1414 <main+0x284>
lea    (%rdx,%rsi,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rcx
jae    133e <main+0x1ae>
lea    (%rcx,%rdx,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rsi
jb     1414 <main+0x284>
lea    0x1(%rdx),%rbx
mov    %rbx,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rdx
mov    %rdx,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %ebp,%r10d
and    $0x3,%r10d
cmp    $0x60,%rdx
jae    1369 <main+0x1d9>
xor    %edx,%edx
jmp    13c8 <main+0x238>
and    $0xfffffffffffffffc,%rbp
xor    %edx,%edx
nop
movups (%rsi,%rdx,1),%xmm0
movups 0x10(%rsi,%rdx,1),%xmm1
movups %xmm0,(%rcx,%rdx,1)
movups %xmm1,0x10(%rcx,%rdx,1)
movups 0x20(%rsi,%rdx,1),%xmm0
movups 0x30(%rsi,%rdx,1),%xmm1
movups %xmm0,0x20(%rcx,%rdx,1)
movups %xmm1,0x30(%rcx,%rdx,1)
movups 0x40(%rsi,%rdx,1),%xmm0
movups 0x50(%rsi,%rdx,1),%xmm1
movups %xmm0,0x40(%rcx,%rdx,1)
movups %xmm1,0x50(%rcx,%rdx,1)
movups 0x60(%rsi,%rdx,1),%xmm0
movups 0x70(%rsi,%rdx,1),%xmm1
movups %xmm0,0x60(%rcx,%rdx,1)
movups %xmm1,0x70(%rcx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rbp
jne    1370 <main+0x1e0>
test   %r10,%r10
je     1402 <main+0x272>
lea    (%rsi,%rdx,1),%rbp
add    $0x10,%rbp
add    $0x10,%rdx
shl    $0x5,%r10
xor    %edi,%edi
nop
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
lea    (%rdx,%rdi,1),%r8
movups %xmm0,-0x10(%rcx,%r8,1)
movups %xmm1,(%rcx,%r8,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    13e0 <main+0x250>
add    %r9,%rcx
cmp    %r9,%rbx
je     14b1 <main+0x321>
add    %r9,%rsi
sub    %r9d,%eax
lea    -0x1(%rax),%r8d
test   $0x7,%al
je     1447 <main+0x2b7>
mov    %eax,%edi
and    $0x7,%edi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rsi,%rbp,1),%edx
mov    %dl,(%rcx,%rbp,1)
add    $0x1,%rbp
cmp    %ebp,%edi
jne    1430 <main+0x2a0>
add    %rbp,%rsi
sub    %ebp,%eax
add    %rbp,%rcx
cmp    $0x7,%r8d
jb     14b1 <main+0x321>
mov    %eax,%edi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%rdx,1),%eax
mov    %al,(%rcx,%rdx,1)
movzbl 0x1(%rsi,%rdx,1),%eax
mov    %al,0x1(%rcx,%rdx,1)
movzbl 0x2(%rsi,%rdx,1),%eax
mov    %al,0x2(%rcx,%rdx,1)
movzbl 0x3(%rsi,%rdx,1),%eax
mov    %al,0x3(%rcx,%rdx,1)
movzbl 0x4(%rsi,%rdx,1),%eax
mov    %al,0x4(%rcx,%rdx,1)
movzbl 0x5(%rsi,%rdx,1),%eax
mov    %al,0x5(%rcx,%rdx,1)
movzbl 0x6(%rsi,%rdx,1),%eax
mov    %al,0x6(%rcx,%rdx,1)
movzbl 0x7(%rsi,%rdx,1),%eax
mov    %al,0x7(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    %edx,%edi
jne    1460 <main+0x2d0>
add    %rdx,%rcx
test   %r11d,%r11d
je     157e <main+0x3ee>
lea    -0x1(%r11),%r8d
cmp    $0x7,%r8d
jb     14e6 <main+0x356>
lea    (%r8,%r13,1),%rax
add    $0x1,%rax
cmp    %rax,%rcx
jae    1632 <main+0x4a2>
lea    (%rcx,%r8,1),%rax
add    $0x1,%rax
cmp    %rax,%r13
jae    1632 <main+0x4a2>
mov    %r13,%rdx
mov    %rcx,%rsi
lea    -0x1(%r11),%ecx
test   $0x7,%r11b
je     1518 <main+0x388>
mov    %r11d,%eax
and    $0x7,%eax
xor    %edi,%edi
xchg   %ax,%ax
movzbl (%rdx,%rdi,1),%ebx
mov    %bl,(%rsi,%rdi,1)
add    $0x1,%rdi
cmp    %edi,%eax
jne    1500 <main+0x370>
add    %rdi,%rdx
sub    %edi,%r11d
add    %rdi,%rsi
cmp    $0x7,%ecx
jb     157e <main+0x3ee>
mov    %r11d,%eax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdx,%rcx,1),%ebx
mov    %bl,(%rsi,%rcx,1)
movzbl 0x1(%rdx,%rcx,1),%ebx
mov    %bl,0x1(%rsi,%rcx,1)
movzbl 0x2(%rdx,%rcx,1),%ebx
mov    %bl,0x2(%rsi,%rcx,1)
movzbl 0x3(%rdx,%rcx,1),%ebx
mov    %bl,0x3(%rsi,%rcx,1)
movzbl 0x4(%rdx,%rcx,1),%ebx
mov    %bl,0x4(%rsi,%rcx,1)
movzbl 0x5(%rdx,%rcx,1),%ebx
mov    %bl,0x5(%rsi,%rcx,1)
movzbl 0x6(%rdx,%rcx,1),%ebx
mov    %bl,0x6(%rsi,%rcx,1)
movzbl 0x7(%rdx,%rcx,1),%ebx
mov    %bl,0x7(%rsi,%rcx,1)
add    $0x8,%rcx
cmp    %ecx,%eax
jne    1530 <main+0x3a0>
lea    0x8(%rsp),%rdi
xor    %esi,%esi
call   1050 <gettimeofday@plt>
mov    0x8(%rsp),%eax
mov    0xc(%rsp),%ecx
sub    0x10(%rsp),%eax
imul   $0xf4240,%eax,%eax
sub    0x14(%rsp),%ecx
add    %eax,%ecx
movslq %ecx,%rax
imul   $0x431bde83,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x32,%rcx
add    %edx,%ecx
movslq %ecx,%rsi
imul   $0xf4240,%esi,%ecx
sub    %ecx,%eax
movslq %eax,%rdx
lea    0xa59(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xa6a(%rip),%rdi
xor    %esi,%esi
xor    %edx,%edx
xor    %ecx,%ecx
xor    %eax,%eax
call   1040 <printf@plt>
mov    %r14,%rdi
mov    $0x200000,%esi
call   1080 <munmap@plt>
mov    %r12,%rdi
mov    $0x100000,%esi
call   1080 <munmap@plt>
mov    %r15,%rdi
mov    $0x100000,%esi
call   1080 <munmap@plt>
mov    (%rsp),%edi
call   1060 <close@plt>
mov    0x4(%rsp),%edi
call   1060 <close@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%rdi
cmp    $0x1f,%r8d
jae    1649 <main+0x4b9>
xor    %ebp,%ebp
jmp    172a <main+0x59a>
lea    0x1(%r8),%r9
mov    %r9,%rbp
and    %rdi,%rbp
lea    -0x20(%rbp),%rax
mov    %rax,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmp    $0x60,%rax
jae    1673 <main+0x4e3>
xor    %edx,%edx
jmp    16e1 <main+0x551>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movups 0x0(%r13,%rdx,1),%xmm0
movups 0x10(%r13,%rdx,1),%xmm1
movups %xmm0,(%rcx,%rdx,1)
movups %xmm1,0x10(%rcx,%rdx,1)
movups 0x20(%r13,%rdx,1),%xmm0
movups 0x30(%r13,%rdx,1),%xmm1
movups %xmm0,0x20(%rcx,%rdx,1)
movups %xmm1,0x30(%rcx,%rdx,1)
movups 0x40(%r13,%rdx,1),%xmm0
movups 0x50(%r13,%rdx,1),%xmm1
movups %xmm0,0x40(%rcx,%rdx,1)
movups %xmm1,0x50(%rcx,%rdx,1)
movups 0x60(%r13,%rdx,1),%xmm0
movups 0x70(%r13,%rdx,1),%xmm1
movups %xmm0,0x60(%rcx,%rdx,1)
movups %xmm1,0x70(%rcx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1680 <main+0x4f0>
test   %r10,%r10
je     171b <main+0x58b>
lea    (%rcx,%rdx,1),%rsi
add    $0x10,%rsi
lea    (%rdx,%r13,1),%rax
add    $0x10,%rax
shl    $0x5,%r10
xor    %edx,%edx
nopl   0x0(%rax)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,1)
movups %xmm1,(%rsi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1700 <main+0x570>
cmp    %rbp,%r9
je     157e <main+0x3ee>
test   $0x18,%r9b
je     1760 <main+0x5d0>
add    $0x1,%r8
add    $0x18,%rdi
and    %r8,%rdi
lea    (%rdi,%r13,1),%rdx
sub    %edi,%r11d
lea    (%rcx,%rdi,1),%rsi
mov    0x0(%r13,%rbp,1),%rax
mov    %rax,(%rcx,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%rdi
jne    1740 <main+0x5b0>
cmp    %rdi,%r8
jne    14ec <main+0x35c>
jmp    157e <main+0x3ee>
add    %rbp,%rcx
sub    %ebp,%r11d
add    %rbp,%r13
jmp    14e6 <main+0x356>
lea    0x8a7(%rip),%rdi
call   10a0 <perror@plt>
mov    $0x1,%edi
call   10b0 <exit@plt>
mov    0x2835(%rip),%rax
mov    (%rax),%edi
mov    (%r12),%rdx
lea    0x868(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x8(%r12),%rdi
call   10a0 <perror@plt>
mov    0x10(%r12),%rdi
call   10a0 <perror@plt>
mov    0x18(%r12),%rdi
call   10a0 <perror@plt>

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

LLVM IR (-O2):
%struct.timeval = type { i32, i32 }
@PROT_WRITE = global i32 0
@PROT_READ = global i32 0
@stderr = global i32 0
@.str = [28 x i8] c"usage: %s file1 file2 fout\0A\00"
@O_RDWR = global i32 0
@O_CREAT = global i32 0
@MAP_SHARED = global i32 0
@.str.1 = [11 x i8] c"mmap error\00"
@.str.2 = [31 x i8] c"Processing time = %d.%06d sec\0A\00"
@.str.3 = [44 x i8] c"File1 = %ld, File2= %ld, Total = %ld Lines\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca %struct.timeval
%4 = alloca %struct.timeval
%5 = bitcast %struct.timeval* %3 to i8*
%6 = bitcast %struct.timeval* %4 to i8*
%7 = load i32, i32* @PROT_WRITE
%8 = load i32, i32* @PROT_READ
%9 = or i32 %8, %7
%10 = icmp eq i32 %0, 4
br i1 %10, label %15, label %11
11: ; preds = %2
%12 = load i32, i32* @stderr
%13 = load i8*, i8** %1
%14 = tail call i32 @fprintf(i32 %12, i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str, i64 0, i64 0), i8* %13)
unreachable
15: ; preds = %2
%16 = getelementptr inbounds i8*, i8** %1, i64 1
%17 = load i8*, i8** %16
%18 = load i32, i32* @O_RDWR
%19 = load i32, i32* @O_CREAT
%20 = or i32 %19, %18
%21 = tail call i32 @open(i8* %17, i32 %20)
%22 = icmp slt i32 %21, 0
br i1 %22, label %23, label %26
23: ; preds = %15
%24 = load i8*, i8** %16
%25 = tail call i32 @perror(i8* %24)
unreachable
26: ; preds = %15
%27 = getelementptr inbounds i8*, i8** %1, i64 2
%28 = load i8*, i8** %27
%29 = load i32, i32* @O_RDWR
%30 = load i32, i32* @O_CREAT
%31 = or i32 %30, %29
%32 = tail call i32 @open(i8* %28, i32 %31)
%33 = icmp slt i32 %32, 0
br i1 %33, label %34, label %37
34: ; preds = %26
%35 = load i8*, i8** %27
%36 = tail call i32 @perror(i8* %35)
unreachable
37: ; preds = %26
%38 = getelementptr inbounds i8*, i8** %1, i64 3
%39 = load i8*, i8** %38
%40 = load i32, i32* @O_RDWR
%41 = load i32, i32* @O_CREAT
%42 = or i32 %41, %40
%43 = tail call i32 @open(i8* %39, i32 %42)
%44 = icmp slt i32 %43, 0
br i1 %44, label %45, label %48
45: ; preds = %37
%46 = load i8*, i8** %38
%47 = tail call i32 @perror(i8* %46)
unreachable
48: ; preds = %37
%49 = load i32, i32* @MAP_SHARED
%50 = tail call i8* @mmap(i32 0, i32 1048576, i32 %9, i32 %49, i32 %21, i32 0)
%51 = icmp eq i8* %50, null
br i1 %51, label %52, label %55
52: ; preds = %48
%53 = tail call i32 @perror(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0))
%54 = tail call i32 @exit(i32 1)
unreachable
55: ; preds = %48
%56 = load i32, i32* @MAP_SHARED
%57 = tail call i8* @mmap(i32 0, i32 1048576, i32 %9, i32 %56, i32 %32, i32 0)
%58 = icmp eq i8* %57, null
br i1 %58, label %59, label %62
59: ; preds = %55
%60 = tail call i32 @perror(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0))
%61 = tail call i32 @exit(i32 1)
unreachable
62: ; preds = %55
%63 = load i32, i32* @MAP_SHARED
%64 = tail call i8* @mmap(i32 0, i32 2097152, i32 %9, i32 %63, i32 %43, i32 0)
%65 = icmp eq i8* %64, null
br i1 %65, label %66, label %69
66: ; preds = %62
%67 = tail call i32 @perror(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0))
%68 = tail call i32 @exit(i32 1)
unreachable
69: ; preds = %62
%70 = call i32 @gettimeofday(%struct.timeval* %3, i32* null)
br label %194
71: ; preds = %214
%72 = icmp eq i32 %215, 0
br i1 %72, label %224, label %73
73: ; preds = %71
%74 = add i32 %215, -1
%75 = zext i32 %74 to i64
%76 = add nuw nsw i64 %75, 1
%77 = icmp ult i32 %74, 31
br i1 %77, label %170, label %78
78: ; preds = %73
%79 = add i32 %215, -1
%80 = zext i32 %79 to i64
%81 = add nuw nsw i64 %80, 1
%82 = getelementptr i8, i8* %220, i64 %81
%83 = getelementptr i8, i8* %219, i64 %81
%84 = icmp ult i8* %220, %83
%85 = icmp ult i8* %219, %82
%86 = and i1 %84, %85
br i1 %86, label %170, label %87
87: ; preds = %78
%88 = and i64 %76, 8589934560
%89 = getelementptr i8, i8* %219, i64 %88
%90 = trunc i64 %88 to i32
%91 = sub i32 %215, %90
%92 = getelementptr i8, i8* %220, i64 %88
%93 = add nsw i64 %88, -32
%94 = lshr exact i64 %93, 5
%95 = add nuw nsw i64 %94, 1
%96 = and i64 %95, 3
%97 = icmp ult i64 %93, 96
br i1 %97, label %149, label %98
98: ; preds = %87
%99 = and i64 %95, 1152921504606846972
br label %100
100: ; preds = %100, %98
%101 = phi i64 [ 0, %98 ], [ %146, %100 ]
%102 = phi i64 [ 0, %98 ], [ %147, %100 ]
%103 = getelementptr i8, i8* %219, i64 %101
%104 = getelementptr i8, i8* %220, i64 %101
%105 = bitcast i8* %103 to <16 x i8>*
%106 = load <16 x i8>, <16 x i8>* %105
%107 = getelementptr i8, i8* %103, i64 16
%108 = bitcast i8* %107 to <16 x i8>*
%109 = load <16 x i8>, <16 x i8>* %108
%110 = bitcast i8* %104 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %110
%111 = getelementptr i8, i8* %104, i64 16
%112 = bitcast i8* %111 to <16 x i8>*
store <16 x i8> %109, <16 x i8>* %112
%113 = or i64 %101, 32
%114 = getelementptr i8, i8* %219, i64 %113
%115 = getelementptr i8, i8* %220, i64 %113
%116 = bitcast i8* %114 to <16 x i8>*
%117 = load <16 x i8>, <16 x i8>* %116
%118 = getelementptr i8, i8* %114, i64 16
%119 = bitcast i8* %118 to <16 x i8>*
%120 = load <16 x i8>, <16 x i8>* %119
%121 = bitcast i8* %115 to <16 x i8>*
store <16 x i8> %117, <16 x i8>* %121
%122 = getelementptr i8, i8* %115, i64 16
%123 = bitcast i8* %122 to <16 x i8>*
store <16 x i8> %120, <16 x i8>* %123
%124 = or i64 %101, 64
%125 = getelementptr i8, i8* %219, i64 %124
%126 = getelementptr i8, i8* %220, i64 %124
%127 = bitcast i8* %125 to <16 x i8>*
%128 = load <16 x i8>, <16 x i8>* %127
%129 = getelementptr i8, i8* %125, i64 16
%130 = bitcast i8* %129 to <16 x i8>*
%131 = load <16 x i8>, <16 x i8>* %130
%132 = bitcast i8* %126 to <16 x i8>*
store <16 x i8> %128, <16 x i8>* %132
%133 = getelementptr i8, i8* %126, i64 16
%134 = bitcast i8* %133 to <16 x i8>*
store <16 x i8> %131, <16 x i8>* %134
%135 = or i64 %101, 96
%136 = getelementptr i8, i8* %219, i64 %135
%137 = getelementptr i8, i8* %220, i64 %135
%138 = bitcast i8* %136 to <16 x i8>*
%139 = load <16 x i8>, <16 x i8>* %138
%140 = getelementptr i8, i8* %136, i64 16
%141 = bitcast i8* %140 to <16 x i8>*
%142 = load <16 x i8>, <16 x i8>* %141
%143 = bitcast i8* %137 to <16 x i8>*
store <16 x i8> %139, <16 x i8>* %143
%144 = getelementptr i8, i8* %137, i64 16
%145 = bitcast i8* %144 to <16 x i8>*
store <16 x i8> %142, <16 x i8>* %145
%146 = add nuw i64 %101, 128
%147 = add i64 %102, 4
%148 = icmp eq i64 %147, %99
br i1 %148, label %149, label %100
149: ; preds = %100, %87
%150 = phi i64 [ 0, %87 ], [ %146, %100 ]
%151 = icmp eq i64 %96, 0
br i1 %151, label %168, label %152
152: ; preds = %149, %152
%153 = phi i64 [ %165, %152 ], [ %150, %149 ]
%154 = phi i64 [ %166, %152 ], [ 0, %149 ]
%155 = getelementptr i8, i8* %219, i64 %153
%156 = getelementptr i8, i8* %220, i64 %153
%157 = bitcast i8* %155 to <16 x i8>*
%158 = load <16 x i8>, <16 x i8>* %157
%159 = getelementptr i8, i8* %155, i64 16
%160 = bitcast i8* %159 to <16 x i8>*
%161 = load <16 x i8>, <16 x i8>* %160
%162 = bitcast i8* %156 to <16 x i8>*
store <16 x i8> %158, <16 x i8>* %162
%163 = getelementptr i8, i8* %156, i64 16
%164 = bitcast i8* %163 to <16 x i8>*
store <16 x i8> %161, <16 x i8>* %164
%165 = add nuw i64 %153, 32
%166 = add i64 %154, 1
%167 = icmp eq i64 %166, %96
br i1 %167, label %168, label %152
168: ; preds = %152, %149
%169 = icmp eq i64 %76, %88
br i1 %169, label %224, label %170
170: ; preds = %78, %73, %168
%171 = phi i8* [ %219, %78 ], [ %219, %73 ], [ %89, %168 ]
%172 = phi i32 [ %215, %78 ], [ %215, %73 ], [ %91, %168 ]
%173 = phi i8* [ %220, %78 ], [ %220, %73 ], [ %92, %168 ]
%174 = add i32 %172, -1
%175 = and i32 %172, 7
%176 = icmp eq i32 %175, 0
br i1 %176, label %188, label %177
177: ; preds = %170, %177
%178 = phi i8* [ %182, %177 ], [ %171, %170 ]
%179 = phi i32 [ %185, %177 ], [ %172, %170 ]
%180 = phi i8* [ %184, %177 ], [ %173, %170 ]
%181 = phi i32 [ %186, %177 ], [ 0, %170 ]
%182 = getelementptr inbounds i8, i8* %178, i64 1
%183 = load i8, i8* %178
%184 = getelementptr inbounds i8, i8* %180, i64 1
store i8 %183, i8* %180
%185 = add nsw i32 %179, -1
%186 = add i32 %181, 1
%187 = icmp eq i32 %186, %175
br i1 %187, label %188, label %177
188: ; preds = %177, %170
%189 = phi i8* [ undef, %170 ], [ %184, %177 ]
%190 = phi i8* [ %171, %170 ], [ %182, %177 ]
%191 = phi i32 [ %172, %170 ], [ %185, %177 ]
%192 = phi i8* [ %173, %170 ], [ %184, %177 ]
%193 = icmp ult i32 %174, 7
br i1 %193, label %224, label %373
194: ; preds = %69, %214
%195 = phi i8* [ %50, %69 ], [ %219, %214 ]
%196 = phi i32 [ 1, %69 ], [ %218, %214 ]
%197 = phi i8* [ %57, %69 ], [ %217, %214 ]
%198 = phi i32 [ 1048576, %69 ], [ %216, %214 ]
%199 = phi i32 [ 1048576, %69 ], [ %215, %214 ]
%200 = phi i8* [ %64, %69 ], [ %220, %214 ]
%201 = icmp eq i32 %196, 1
br i1 %201, label %202, label %208
202: ; preds = %194
%203 = add nsw i32 %199, -1
%204 = getelementptr inbounds i8, i8* %195, i64 1
%205 = load i8, i8* %195
store i8 %205, i8* %200
%206 = icmp eq i8 %205, 10
%207 = select i1 %206, i32 2, i32 1
br label %214
208: ; preds = %194
%209 = add nsw i32 %198, -1
%210 = getelementptr inbounds i8, i8* %197, i64 1
%211 = load i8, i8* %197
store i8 %211, i8* %200
%212 = icmp eq i8 %211, 10
%213 = select i1 %212, i32 1, i32 2
br label %214
214: ; preds = %208, %202
%215 = phi i32 [ %203, %202 ], [ %199, %208 ]
%216 = phi i32 [ %198, %202 ], [ %209, %208 ]
%217 = phi i8* [ %197, %202 ], [ %210, %208 ]
%218 = phi i32 [ %207, %202 ], [ %213, %208 ]
%219 = phi i8* [ %204, %202 ], [ %195, %208 ]
%220 = getelementptr inbounds i8, i8* %200, i64 1
%221 = icmp ne i32 %215, 0
%222 = icmp ne i32 %216, 0
%223 = select i1 %221, i1 %222, i1 false
br i1 %223, label %194, label %71
224: ; preds = %188, %373, %168, %71
%225 = phi i8* [ %220, %71 ], [ %92, %168 ], [ %189, %188 ], [ %400, %373 ]
%226 = icmp eq i32 %216, 0
br i1 %226, label %433, label %227
227: ; preds = %224
%228 = add i32 %216, -1
%229 = zext i32 %228 to i64
%230 = add nuw nsw i64 %229, 1
%231 = icmp ult i32 %228, 7
br i1 %231, label %350, label %232
232: ; preds = %227
%233 = add i32 %216, -1
%234 = zext i32 %233 to i64
%235 = add nuw nsw i64 %234, 1
%236 = getelementptr i8, i8* %225, i64 %235
%237 = getelementptr i8, i8* %217, i64 %235
%238 = icmp ult i8* %225, %237
%239 = icmp ult i8* %217, %236
%240 = and i1 %238, %239
br i1 %240, label %350, label %241
241: ; preds = %232
%242 = icmp ult i32 %228, 31
br i1 %242, label %329, label %243
243: ; preds = %241
%244 = and i64 %230, 8589934560
%245 = add nsw i64 %244, -32
%246 = lshr exact i64 %245, 5
%247 = add nuw nsw i64 %246, 1
%248 = and i64 %247, 3
%249 = icmp ult i64 %245, 96
br i1 %249, label %301, label %250
250: ; preds = %243
%251 = and i64 %247, 1152921504606846972
br label %252
252: ; preds = %252, %250
%253 = phi i64 [ 0, %250 ], [ %298, %252 ]
%254 = phi i64 [ 0, %250 ], [ %299, %252 ]
%255 = getelementptr i8, i8* %217, i64 %253
%256 = getelementptr i8, i8* %225, i64 %253
%257 = bitcast i8* %255 to <16 x i8>*
%258 = load <16 x i8>, <16 x i8>* %257
%259 = getelementptr i8, i8* %255, i64 16
%260 = bitcast i8* %259 to <16 x i8>*
%261 = load <16 x i8>, <16 x i8>* %260
%262 = bitcast i8* %256 to <16 x i8>*
store <16 x i8> %258, <16 x i8>* %262
%263 = getelementptr i8, i8* %256, i64 16
%264 = bitcast i8* %263 to <16 x i8>*
store <16 x i8> %261, <16 x i8>* %264
%265 = or i64 %253, 32
%266 = getelementptr i8, i8* %217, i64 %265
%267 = getelementptr i8, i8* %225, i64 %265
%268 = bitcast i8* %266 to <16 x i8>*
%269 = load <16 x i8>, <16 x i8>* %268
%270 = getelementptr i8, i8* %266, i64 16
%271 = bitcast i8* %270 to <16 x i8>*
%272 = load <16 x i8>, <16 x i8>* %271
%273 = bitcast i8* %267 to <16 x i8>*
store <16 x i8> %269, <16 x i8>* %273
%274 = getelementptr i8, i8* %267, i64 16
%275 = bitcast i8* %274 to <16 x i8>*
store <16 x i8> %272, <16 x i8>* %275
%276 = or i64 %253, 64
%277 = getelementptr i8, i8* %217, i64 %276
%278 = getelementptr i8, i8* %225, i64 %276
%279 = bitcast i8* %277 to <16 x i8>*
%280 = load <16 x i8>, <16 x i8>* %279
%281 = getelementptr i8, i8* %277, i64 16
%282 = bitcast i8* %281 to <16 x i8>*
%283 = load <16 x i8>, <16 x i8>* %282
%284 = bitcast i8* %278 to <16 x i8>*
store <16 x i8> %280, <16 x i8>* %284
%285 = getelementptr i8, i8* %278, i64 16
%286 = bitcast i8* %285 to <16 x i8>*
store <16 x i8> %283, <16 x i8>* %286
%287 = or i64 %253, 96
%288 = getelementptr i8, i8* %217, i64 %287
%289 = getelementptr i8, i8* %225, i64 %287
%290 = bitcast i8* %288 to <16 x i8>*
%291 = load <16 x i8>, <16 x i8>* %290
%292 = getelementptr i8, i8* %288, i64 16
%293 = bitcast i8* %292 to <16 x i8>*
%294 = load <16 x i8>, <16 x i8>* %293
%295 = bitcast i8* %289 to <16 x i8>*
store <16 x i8> %291, <16 x i8>* %295
%296 = getelementptr i8, i8* %289, i64 16
%297 = bitcast i8* %296 to <16 x i8>*
store <16 x i8> %294, <16 x i8>* %297
%298 = add nuw i64 %253, 128
%299 = add i64 %254, 4
%300 = icmp eq i64 %299, %251
br i1 %300, label %301, label %252
301: ; preds = %252, %243
%302 = phi i64 [ 0, %243 ], [ %298, %252 ]
%303 = icmp eq i64 %248, 0
br i1 %303, label %320, label %304
304: ; preds = %301, %304
%305 = phi i64 [ %317, %304 ], [ %302, %301 ]
%306 = phi i64 [ %318, %304 ], [ 0, %301 ]
%307 = getelementptr i8, i8* %217, i64 %305
%308 = getelementptr i8, i8* %225, i64 %305
%309 = bitcast i8* %307 to <16 x i8>*
%310 = load <16 x i8>, <16 x i8>* %309
%311 = getelementptr i8, i8* %307, i64 16
%312 = bitcast i8* %311 to <16 x i8>*
%313 = load <16 x i8>, <16 x i8>* %312
%314 = bitcast i8* %308 to <16 x i8>*
store <16 x i8> %310, <16 x i8>* %314
%315 = getelementptr i8, i8* %308, i64 16
%316 = bitcast i8* %315 to <16 x i8>*
store <16 x i8> %313, <16 x i8>* %316
%317 = add nuw i64 %305, 32
%318 = add i64 %306, 1
%319 = icmp eq i64 %318, %248
br i1 %319, label %320, label %304
320: ; preds = %304, %301
%321 = icmp eq i64 %230, %244
br i1 %321, label %433, label %322
322: ; preds = %320
%323 = getelementptr i8, i8* %225, i64 %244
%324 = trunc i64 %244 to i32
%325 = sub i32 %216, %324
%326 = getelementptr i8, i8* %217, i64 %244
%327 = and i64 %230, 24
%328 = icmp eq i64 %327, 0
br i1 %328, label %350, label %329
329: ; preds = %241, %322
%330 = phi i64 [ %244, %322 ], [ 0, %241 ]
%331 = add i32 %216, -1
%332 = zext i32 %331 to i64
%333 = add nuw nsw i64 %332, 1
%334 = and i64 %333, 8589934584
%335 = getelementptr i8, i8* %217, i64 %334
%336 = trunc i64 %334 to i32
%337 = sub i32 %216, %336
%338 = getelementptr i8, i8* %225, i64 %334
br label %339
339: ; preds = %339, %329
%340 = phi i64 [ %330, %329 ], [ %346, %339 ]
%341 = getelementptr i8, i8* %217, i64 %340
%342 = getelementptr i8, i8* %225, i64 %340
%343 = bitcast i8* %341 to <8 x i8>*
%344 = load <8 x i8>, <8 x i8>* %343
%345 = bitcast i8* %342 to <8 x i8>*
store <8 x i8> %344, <8 x i8>* %345
%346 = add nuw i64 %340, 8
%347 = icmp eq i64 %346, %334
br i1 %347, label %348, label %339
348: ; preds = %339
%349 = icmp eq i64 %333, %334
br i1 %349, label %433, label %350
350: ; preds = %232, %227, %322, %348
%351 = phi i8* [ %217, %227 ], [ %217, %232 ], [ %326, %322 ], [ %335, %348 ]
%352 = phi i32 [ %216, %227 ], [ %216, %232 ], [ %325, %322 ], [ %337, %348 ]
%353 = phi i8* [ %225, %227 ], [ %225, %232 ], [ %323, %322 ], [ %338, %348 ]
%354 = add i32 %352, -1
%355 = and i32 %352, 7
%356 = icmp eq i32 %355, 0
br i1 %356, label %368, label %357
357: ; preds = %350, %357
%358 = phi i8* [ %362, %357 ], [ %351, %350 ]
%359 = phi i32 [ %365, %357 ], [ %352, %350 ]
%360 = phi i8* [ %364, %357 ], [ %353, %350 ]
%361 = phi i32 [ %366, %357 ], [ 0, %350 ]
%362 = getelementptr inbounds i8, i8* %358, i64 1
%363 = load i8, i8* %358
%364 = getelementptr inbounds i8, i8* %360, i64 1
store i8 %363, i8* %360
%365 = add nsw i32 %359, -1
%366 = add i32 %361, 1
%367 = icmp eq i32 %366, %355
br i1 %367, label %368, label %357
368: ; preds = %357, %350
%369 = phi i8* [ %351, %350 ], [ %362, %357 ]
%370 = phi i32 [ %352, %350 ], [ %365, %357 ]
%371 = phi i8* [ %353, %350 ], [ %364, %357 ]
%372 = icmp ult i32 %354, 7
br i1 %372, label %433, label %403
373: ; preds = %188, %373
%374 = phi i8* [ %398, %373 ], [ %190, %188 ]
%375 = phi i32 [ %401, %373 ], [ %191, %188 ]
%376 = phi i8* [ %400, %373 ], [ %192, %188 ]
%377 = getelementptr inbounds i8, i8* %374, i64 1
%378 = load i8, i8* %374
%379 = getelementptr inbounds i8, i8* %376, i64 1
store i8 %378, i8* %376
%380 = getelementptr inbounds i8, i8* %374, i64 2
%381 = load i8, i8* %377
%382 = getelementptr inbounds i8, i8* %376, i64 2
store i8 %381, i8* %379
%383 = getelementptr inbounds i8, i8* %374, i64 3
%384 = load i8, i8* %380
%385 = getelementptr inbounds i8, i8* %376, i64 3
store i8 %384, i8* %382
%386 = getelementptr inbounds i8, i8* %374, i64 4
%387 = load i8, i8* %383
%388 = getelementptr inbounds i8, i8* %376, i64 4
store i8 %387, i8* %385
%389 = getelementptr inbounds i8, i8* %374, i64 5
%390 = load i8, i8* %386
%391 = getelementptr inbounds i8, i8* %376, i64 5
store i8 %390, i8* %388
%392 = getelementptr inbounds i8, i8* %374, i64 6
%393 = load i8, i8* %389
%394 = getelementptr inbounds i8, i8* %376, i64 6
store i8 %393, i8* %391
%395 = getelementptr inbounds i8, i8* %374, i64 7
%396 = load i8, i8* %392
%397 = getelementptr inbounds i8, i8* %376, i64 7
store i8 %396, i8* %394
%398 = getelementptr inbounds i8, i8* %374, i64 8
%399 = load i8, i8* %395
%400 = getelementptr inbounds i8, i8* %376, i64 8
store i8 %399, i8* %397
%401 = add nsw i32 %375, -8
%402 = icmp eq i32 %401, 0
br i1 %402, label %224, label %373
403: ; preds = %368, %403
%404 = phi i8* [ %428, %403 ], [ %369, %368 ]
%405 = phi i32 [ %431, %403 ], [ %370, %368 ]
%406 = phi i8* [ %430, %403 ], [ %371, %368 ]
%407 = getelementptr inbounds i8, i8* %404, i64 1
%408 = load i8, i8* %404
%409 = getelementptr inbounds i8, i8* %406, i64 1
store i8 %408, i8* %406
%410 = getelementptr inbounds i8, i8* %404, i64 2
%411 = load i8, i8* %407
%412 = getelementptr inbounds i8, i8* %406, i64 2
store i8 %411, i8* %409
%413 = getelementptr inbounds i8, i8* %404, i64 3
%414 = load i8, i8* %410
%415 = getelementptr inbounds i8, i8* %406, i64 3
store i8 %414, i8* %412
%416 = getelementptr inbounds i8, i8* %404, i64 4
%417 = load i8, i8* %413
%418 = getelementptr inbounds i8, i8* %406, i64 4
store i8 %417, i8* %415
%419 = getelementptr inbounds i8, i8* %404, i64 5
%420 = load i8, i8* %416
%421 = getelementptr inbounds i8, i8* %406, i64 5
store i8 %420, i8* %418
%422 = getelementptr inbounds i8, i8* %404, i64 6
%423 = load i8, i8* %419
%424 = getelementptr inbounds i8, i8* %406, i64 6
store i8 %423, i8* %421
%425 = getelementptr inbounds i8, i8* %404, i64 7
%426 = load i8, i8* %422
%427 = getelementptr inbounds i8, i8* %406, i64 7
store i8 %426, i8* %424
%428 = getelementptr inbounds i8, i8* %404, i64 8
%429 = load i8, i8* %425
%430 = getelementptr inbounds i8, i8* %406, i64 8
store i8 %429, i8* %427
%431 = add nsw i32 %405, -8
%432 = icmp eq i32 %431, 0
br i1 %432, label %433, label %403
433: ; preds = %368, %403, %320, %348, %224
%434 = call i32 @gettimeofday(%struct.timeval* %4, i32* null)
%435 = getelementptr inbounds %struct.timeval, %struct.timeval* %4, i64 0, i32 0
%436 = load i32, i32* %435
%437 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 0
%438 = load i32, i32* %437
%439 = sub nsw i32 %436, %438
%440 = mul nsw i32 %439, 1000000
%441 = getelementptr inbounds %struct.timeval, %struct.timeval* %4, i64 0, i32 1
%442 = load i32, i32* %441
%443 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 1
%444 = load i32, i32* %443
%445 = sub nsw i32 %442, %444
%446 = add nsw i32 %445, %440
%447 = sdiv i32 %446, 1000000
%448 = sext i32 %447 to i64
%449 = srem i32 %446, 1000000
%450 = sext i32 %449 to i64
%451 = tail call i32 (i8*, i64, i64, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0), i64 %448, i64 %450)
%452 = tail call i32 (i8*, i64, i64, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.3, i64 0, i64 0), i64 0, i64 0, i64 0)
%453 = tail call i32 @munmap(i8* %64, i32 2097152)
%454 = tail call i32 @munmap(i8* %50, i32 1048576)
%455 = tail call i32 @munmap(i8* %57, i32 1048576)
%456 = tail call i32 @close(i32 %43)
%457 = tail call i32 @close(i32 %21)
ret i32 0
}