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

/* Variables and functions */
int /*<<< orphan*/ MAP_SHARED;
int O_CREAT;
int O_RDWR;
int PROT_READ;
int PROT_WRITE;
int /*<<< orphan*/ SEEK_END;
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ fseek(int /*<<< orphan*/ *, long, int /*<<< orphan*/);
int ftell(int /*<<< orphan*/ *);
int /*<<< orphan*/ ftruncate(int, int);
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 /*<<< orphan*/ write(int, int /*<<< orphan*/ *, int /*<<< orphan*/);
int main(int argc, char *argv[]) {
  int ret = 1;
  long line1 = 0, line2 = 0, lineout = 0;
  struct timeval before, after;
  int duration;
  int fd1, fd2, fdout;
  char *file1, *file2, *fileout, *temp_out;
  char *pfile1, *pfile2, *pfileout, *cfile;
  int rsize1, rsize2, *csize;
  int currentFile;
  int flag = PROT_WRITE | PROT_READ;
  char *head_line, *tail_line, *index_line;
  FILE *fpMe;
  int filelen1, filelen2;
  if (argc != 4) {
    fprintf(stderr, "usage: %s file1 file2 fout\n", argv[0]);
    goto leave0;
  }
  if ((fpMe = fopen(argv[1], "rb")) == NULL) {
    perror(argv[1]);
    goto leave0;
  }
  fseek(fpMe, 0L, SEEK_END);
  filelen1 = ftell(fpMe);
  fclose(fpMe);
  if ((fpMe = fopen(argv[2], "rb")) == NULL) {
    perror(argv[2]);
    goto leave0;
  }
  fseek(fpMe, 0L, SEEK_END);
  filelen2 = ftell(fpMe);
  fclose(fpMe);
  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, 0644)) < 0) {
    perror(argv[3]);
    goto leave2;
  }
  write(fdout, NULL, 0);
  ftruncate(fdout, filelen1 + filelen2);
  if ((file1 = mmap(0, filelen1, flag, MAP_SHARED, fd1, 0)) == NULL) {
    perror("mmap error");
    goto leave3;
  }
  if ((file2 = mmap(0, filelen2, flag, MAP_SHARED, fd2, 0)) == NULL) {
    perror("mmap error");
    goto leave4;
  }
  if ((fileout = mmap(0, filelen1 + filelen2, flag, MAP_SHARED, fdout, 0)) ==
      NULL) {
    perror("mmap error");
    goto leave5;
  }
  gettimeofday(&before, NULL);
  pfile1 = file1;
  pfile2 = file2;
  pfileout = fileout;
  rsize1 = filelen1;
  rsize2 = filelen2;
  currentFile = 1;
  head_line = pfile1;
  while (rsize1 && rsize2) {
    if (currentFile == 1) {
      rsize1--;
      if ((*pfile1++) == '\n') {
        line1++;
        currentFile = 2;
        tail_line = pfile1;
        index_line = --tail_line;
        while (1) {
          *pfileout++ = *(--index_line);
          if (index_line == head_line) {
            *pfileout++ = *tail_line;
            head_line = pfile2;
            break;
          }
        }
      }
    } else if (currentFile == 2) {
      rsize2--;
      if ((*pfile2++) == '\n') {
        line2++;
        currentFile = 1;
        tail_line = pfile2;
        index_line = --tail_line;
        while (1) {
          *pfileout++ = *(--index_line);
          if (index_line == head_line) {
            *pfileout++ = *tail_line;
            head_line = pfile1;
            break;
          }
        }
      }
    }
  }
  while (rsize1) {
    rsize1--;
    if ((*pfile1++) == '\n') {
      line1++;
      tail_line = pfile1;
      index_line = --tail_line;
      while (1) {
        *pfileout++ = *(--index_line);
        if (index_line == head_line) {
          *pfileout++ = *tail_line;
          head_line = pfile1;
          break;
        }
      }
    }
  }
  while (rsize2) {
    rsize2--;
    if ((*pfile2++) == '\n') {
      line2++;
      tail_line = pfile2;
      index_line = --tail_line;
      while (1) {
        *pfileout++ = *(--index_line);
        if (index_line == head_line) {
          *pfileout++ = *tail_line;
          head_line = pfile2;
          break;
        }
      }
    }
  }
  gettimeofday(&after, NULL);
  lineout = line1 + line2;
  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;
leave6:
  munmap(fileout, filelen1 + filelen2);
leave5:
  munmap(file2, filelen2);
leave4:
  munmap(file1, filelen1);
leave3:
  close(fdout);
leave2:
  close(fd2);
leave1:
  close(fd1);
leave0:
  return ret;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x1,-0x14(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    0x2d91(%rip),%rax
mov    (%rax),%eax
mov    0x2dc8(%rip),%rcx
or     (%rcx),%eax
mov    %eax,-0xa8(%rbp)
cmpl   $0x4,-0x8(%rbp)
je     125b <main+0x7b>
mov    0x2d77(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xdaf(%rip),%rsi
call   10a0 <fprintf@plt>
jmp    1a09 <main+0x829>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xdb2(%rip),%rsi
call   10f0 <fopen@plt>
mov    %rax,-0xc8(%rbp)
cmp    $0x0,%rax
jne    1292 <main+0xb2>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1100 <perror@plt>
jmp    1a09 <main+0x829>
mov    -0xc8(%rbp),%rdi
mov    0x2d28(%rip),%rax
mov    (%rax),%edx
xor    %eax,%eax
mov    %eax,%esi
call   10c0 <fseek@plt>
mov    -0xc8(%rbp),%rdi
call   10b0 <ftell@plt>
mov    %eax,-0xcc(%rbp)
mov    -0xc8(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
lea    0xd44(%rip),%rsi
call   10f0 <fopen@plt>
mov    %rax,-0xc8(%rbp)
cmp    $0x0,%rax
jne    1300 <main+0x120>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1100 <perror@plt>
jmp    1a09 <main+0x829>
mov    -0xc8(%rbp),%rdi
mov    0x2cba(%rip),%rax
mov    (%rax),%edx
xor    %eax,%eax
mov    %eax,%esi
call   10c0 <fseek@plt>
mov    -0xc8(%rbp),%rdi
call   10b0 <ftell@plt>
mov    %eax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rdi
call   1040 <fclose@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2c8a(%rip),%rax
mov    (%rax),%esi
mov    0x2ca9(%rip),%rax
or     (%rax),%esi
mov    $0x0,%al
call   10e0 <open@plt>
mov    %eax,-0x48(%rbp)
cmp    $0x0,%eax
jge    1376 <main+0x196>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1100 <perror@plt>
jmp    1a09 <main+0x829>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
mov    0x2c4b(%rip),%rax
mov    (%rax),%esi
mov    0x2c6a(%rip),%rax
or     (%rax),%esi
mov    $0x0,%al
call   10e0 <open@plt>
mov    %eax,-0x4c(%rbp)
cmp    $0x0,%eax
jge    13b5 <main+0x1d5>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1100 <perror@plt>
jmp    1a01 <main+0x821>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
mov    0x2c0c(%rip),%rax
mov    (%rax),%esi
mov    0x2c2b(%rip),%rax
or     (%rax),%esi
mov    $0x1a4,%edx
mov    $0x0,%al
call   10e0 <open@plt>
mov    %eax,-0x50(%rbp)
cmp    $0x0,%eax
jge    13f9 <main+0x219>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   1100 <perror@plt>
jmp    19f9 <main+0x819>
mov    -0x50(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1030 <write@plt>
mov    -0x50(%rbp),%edi
mov    -0xcc(%rbp),%esi
add    -0xd0(%rbp),%esi
call   1070 <ftruncate@plt>
mov    -0xcc(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    0x2bb2(%rip),%rax
mov    (%rax),%ecx
mov    -0x48(%rbp),%r8d
xor    %r9d,%r9d
mov    %r9d,%edi
call   1050 <mmap@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    145e <main+0x27e>
lea    0xbcb(%rip),%rdi
call   1100 <perror@plt>
jmp    19f1 <main+0x811>
mov    -0xd0(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    0x2b6f(%rip),%rax
mov    (%rax),%ecx
mov    -0x4c(%rbp),%r8d
xor    %r9d,%r9d
mov    %r9d,%edi
call   1050 <mmap@plt>
mov    %rax,-0x60(%rbp)
cmp    $0x0,%rax
jne    14a1 <main+0x2c1>
lea    0xb88(%rip),%rdi
call   1100 <perror@plt>
jmp    19e2 <main+0x802>
mov    -0xcc(%rbp),%esi
add    -0xd0(%rbp),%esi
mov    -0xa8(%rbp),%edx
mov    0x2b26(%rip),%rax
mov    (%rax),%ecx
mov    -0x50(%rbp),%r8d
xor    %r9d,%r9d
mov    %r9d,%edi
call   1050 <mmap@plt>
mov    %rax,-0x68(%rbp)
cmp    $0x0,%rax
jne    14ea <main+0x30a>
lea    0xb3f(%rip),%rdi
call   1100 <perror@plt>
jmp    19d3 <main+0x7f3>
lea    -0x38(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1080 <gettimeofday@plt>
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0xcc(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0xd0(%rbp),%eax
mov    %eax,-0x98(%rbp)
movl   $0x1,-0xa4(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xb0(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x94(%rbp)
mov    %al,-0xd1(%rbp)
je     1564 <main+0x384>
cmpl   $0x0,-0x98(%rbp)
setne  %al
mov    %al,-0xd1(%rbp)
mov    -0xd1(%rbp),%al
test   $0x1,%al
jne    1577 <main+0x397>
jmp    1767 <main+0x587>
cmpl   $0x1,-0xa4(%rbp)
jne    166a <main+0x48a>
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x78(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1665 <main+0x485>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
movl   $0x2,-0xa4(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xb8(%rbp)
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xc0(%rbp)
mov    -0x1(%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0xc0(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jne    165b <main+0x47b>
mov    -0xb8(%rbp),%rax
mov    (%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0x80(%rbp),%rax
mov    %rax,-0xb0(%rbp)
jmp    1660 <main+0x480>
jmp    15e8 <main+0x408>
jmp    1665 <main+0x485>
jmp    1762 <main+0x582>
cmpl   $0x2,-0xa4(%rbp)
jne    175d <main+0x57d>
mov    -0x98(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x80(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1758 <main+0x578>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
movl   $0x1,-0xa4(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xb8(%rbp)
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xc0(%rbp)
mov    -0x1(%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0xc0(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jne    174e <main+0x56e>
mov    -0xb8(%rbp),%rax
mov    (%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0x78(%rbp),%rax
mov    %rax,-0xb0(%rbp)
jmp    1753 <main+0x573>
jmp    16db <main+0x4fb>
jmp    1758 <main+0x578>
jmp    175d <main+0x57d>
jmp    1762 <main+0x582>
jmp    153f <main+0x35f>
jmp    176c <main+0x58c>
cmpl   $0x0,-0x94(%rbp)
je     1855 <main+0x675>
mov    -0x94(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x94(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x78(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1850 <main+0x670>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x78(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xb8(%rbp)
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xc0(%rbp)
mov    -0x1(%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0xc0(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jne    1846 <main+0x666>
mov    -0xb8(%rbp),%rax
mov    (%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0x78(%rbp),%rax
mov    %rax,-0xb0(%rbp)
jmp    184b <main+0x66b>
jmp    17d3 <main+0x5f3>
jmp    1850 <main+0x670>
jmp    176c <main+0x58c>
jmp    185a <main+0x67a>
cmpl   $0x0,-0x98(%rbp)
je     1943 <main+0x763>
mov    -0x98(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x80(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    193e <main+0x75e>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xb8(%rbp)
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xc0(%rbp)
mov    -0x1(%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0xc0(%rbp),%rax
cmp    -0xb0(%rbp),%rax
jne    1934 <main+0x754>
mov    -0xb8(%rbp),%rax
mov    (%rax),%cl
mov    -0x88(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x88(%rbp)
mov    %cl,(%rax)
mov    -0x80(%rbp),%rax
mov    %rax,-0xb0(%rbp)
jmp    1939 <main+0x759>
jmp    18c1 <main+0x6e1>
jmp    193e <main+0x75e>
jmp    185a <main+0x67a>
lea    -0x40(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1080 <gettimeofday@plt>
mov    -0x20(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x40(%rbp),%eax
sub    -0x38(%rbp),%eax
imul   $0xf4240,%eax,%eax
mov    -0x3c(%rbp),%ecx
sub    -0x34(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
movslq %eax,%rsi
mov    -0x44(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
movslq %edx,%rdx
lea    0x694(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
lea    0x699(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0xcc(%rbp),%esi
add    -0xd0(%rbp),%esi
call   10d0 <munmap@plt>
mov    -0x60(%rbp),%rdi
mov    -0xd0(%rbp),%esi
call   10d0 <munmap@plt>
mov    -0x58(%rbp),%rdi
mov    -0xcc(%rbp),%esi
call   10d0 <munmap@plt>
mov    -0x50(%rbp),%edi
call   1090 <close@plt>
mov    -0x4c(%rbp),%edi
call   1090 <close@plt>
mov    -0x48(%rbp),%edi
call   1090 <close@plt>
mov    -0x14(%rbp),%eax
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %rsi,%rbp
cmp    $0x4,%edi
jne    1784 <main+0x5a4>
mov    0x2daf(%rip),%rax
mov    0x2de8(%rip),%rcx
mov    (%rcx),%r14d
or     (%rax),%r14d
mov    0x8(%rbp),%rdi
lea    0xe03(%rip),%rsi
call   10f0 <fopen@plt>
test   %rax,%rax
je     1cb3 <main+0xad3>
mov    %rax,%rbx
mov    0x2d97(%rip),%r15
mov    (%r15),%edx
mov    %rax,%rdi
xor    %esi,%esi
call   10c0 <fseek@plt>
mov    %rbx,%rdi
call   10b0 <ftell@plt>
mov    %rax,0x40(%rsp)
mov    %rbx,%rdi
call   1040 <fclose@plt>
mov    0x10(%rbp),%rdi
lea    0xdbe(%rip),%rsi
call   10f0 <fopen@plt>
test   %rax,%rax
je     1cb9 <main+0xad9>
mov    %rax,%rbx
mov    (%r15),%edx
mov    %rax,%rdi
xor    %esi,%esi
call   10c0 <fseek@plt>
mov    %rbx,%rdi
call   10b0 <ftell@plt>
mov    %rax,0x30(%rsp)
mov    %rbx,%rdi
call   1040 <fclose@plt>
mov    0x8(%rbp),%rdi
mov    0x2d34(%rip),%r15
mov    0x2d55(%rip),%rbx
mov    (%rbx),%esi
or     (%r15),%esi
xor    %eax,%eax
call   10e0 <open@plt>
mov    %eax,0x14(%rsp)
test   %eax,%eax
js     1cb3 <main+0xad3>
mov    0x10(%rbp),%rdi
mov    (%rbx),%esi
or     (%r15),%esi
xor    %eax,%eax
call   10e0 <open@plt>
mov    %eax,0x10(%rsp)
test   %eax,%eax
js     1cc9 <main+0xae9>
mov    0x18(%rbp),%rdi
mov    (%rbx),%esi
or     (%r15),%esi
mov    $0x1a4,%edx
xor    %eax,%eax
call   10e0 <open@plt>
test   %eax,%eax
js     1cd9 <main+0xaf9>
mov    %eax,%ebx
mov    %eax,%edi
xor    %esi,%esi
xor    %edx,%edx
call   1030 <write@plt>
mov    0x40(%rsp),%rbp
mov    0x30(%rsp),%r12
lea    (%r12,%rbp,1),%esi
mov    %ebx,0xc(%rsp)
mov    %ebx,%edi
mov    %esi,0x8(%rsp)
call   1070 <ftruncate@plt>
mov    0x2cbb(%rip),%r15
mov    (%r15),%ecx
xor    %edi,%edi
mov    %ebp,%esi
mov    %r14d,%edx
mov    0x14(%rsp),%r8d
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,0x28(%rsp)
test   %rax,%rax
je     1ce9 <main+0xb09>
mov    (%r15),%ecx
xor    %edi,%edi
mov    %r12d,%esi
mov    %r14d,%edx
mov    0x10(%rsp),%r8d
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,0x20(%rsp)
test   %rax,%rax
je     1cfc <main+0xb1c>
mov    (%r15),%ecx
xor    %edi,%edi
mov    0x8(%rsp),%esi
mov    %r14d,%edx
mov    0xc(%rsp),%r8d
xor    %r9d,%r9d
call   1050 <mmap@plt>
mov    %rax,0x18(%rsp)
test   %rax,%rax
je     1d12 <main+0xb32>
xor    %r15d,%r15d
lea    0x68(%rsp),%rdi
xor    %esi,%esi
call   1080 <gettimeofday@plt>
mov    0x40(%rsp),%rax
test   %eax,%eax
je     17a7 <main+0x5c7>
mov    0x20(%rsp),%r11
mov    0x18(%rsp),%rdx
mov    0x28(%rsp),%rsi
mov    %rsi,%r13
mov    %eax,%r12d
mov    0x30(%rsp),%rcx
mov    %ecx,%r8d
mov    $0x0,%r9d
test   %ecx,%ecx
je     17c7 <main+0x5e7>
mov    $0x1,%edi
xor    %r9d,%r9d
pxor   %xmm0,%xmm0
mov    0x28(%rsp),%rdx
mov    %rdx,%rsi
xor    %r15d,%r15d
mov    %ecx,%r8d
mov    %eax,%r12d
mov    %rdx,%r13
mov    0x18(%rsp),%rdx
mov    0x20(%rsp),%r11
nopl   0x0(%rax,%rax,1)
cmp    $0x1,%edi
jne    1490 <main+0x2b0>
add    $0xffffffff,%r12d
lea    0x1(%r13),%r10
mov    $0x1,%edi
cmpb   $0xa,0x0(%r13)
jne    1761 <main+0x581>
mov    %r13,%rdi
sub    %rsi,%rdi
cmp    $0x20,%rdi
jb     144f <main+0x26f>
cmp    %r13,%rdx
jae    15d3 <main+0x3f3>
lea    (%rdx,%rdi,1),%rax
cmp    %rax,%rsi
jae    15d3 <main+0x3f3>
mov    %r13,%rax
mov    %eax,%ecx
sub    %esi,%ecx
mov    %rsi,%rdi
not    %rdi
add    %rax,%rdi
and    $0x7,%rcx
je     1508 <main+0x328>
nopl   0x0(%rax)
movzbl -0x1(%rax),%ebx
add    $0xffffffffffffffff,%rax
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1470 <main+0x290>
lea    -0x1(%rdx),%rbx
jmp    1508 <main+0x328>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%r8d
lea    0x1(%r11),%r10
mov    $0x2,%edi
cmpb   $0xa,(%r11)
jne    1500 <main+0x320>
mov    %r11,%rdi
sub    %rsi,%rdi
cmp    $0x20,%rdi
jb     14c5 <main+0x2e5>
cmp    %r11,%rdx
jae    1694 <main+0x4b4>
lea    (%rdx,%rdi,1),%rax
cmp    %rax,%rsi
jae    1694 <main+0x4b4>
mov    %r11,%rcx
mov    %ecx,%eax
sub    %esi,%eax
mov    %rsi,%rdi
not    %rdi
add    %rcx,%rdi
and    $0x7,%rax
je     1573 <main+0x393>
nop
movzbl -0x1(%rcx),%ebx
add    $0xffffffffffffffff,%rcx
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    14e0 <main+0x300>
lea    -0x1(%rdx),%rbx
jmp    1573 <main+0x393>
nopw   0x0(%rax,%rax,1)
mov    %r10,%r11
jmp    1764 <main+0x584>
mov    %rdx,%r14
cmp    $0x7,%rdi
jb     1680 <main+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x1(%rax),%ecx
mov    %cl,(%rdx)
movzbl -0x2(%rax),%ecx
mov    %cl,0x1(%rdx)
movzbl -0x3(%rax),%ecx
mov    %cl,0x2(%rdx)
movzbl -0x4(%rax),%ecx
mov    %cl,0x3(%rdx)
movzbl -0x5(%rax),%ecx
mov    %cl,0x4(%rdx)
movzbl -0x6(%rax),%ecx
mov    %cl,0x5(%rdx)
movzbl -0x7(%rax),%ecx
mov    %cl,0x6(%rdx)
movzbl -0x8(%rax),%ecx
add    $0xfffffffffffffff8,%rax
mov    %cl,0x7(%rdx)
add    $0x8,%rdx
cmp    %rsi,%rax
jne    1520 <main+0x340>
mov    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
mov    %rdx,%r14
jmp    1680 <main+0x4a0>
mov    %rdx,%r14
cmp    $0x7,%rdi
jb     1740 <main+0x560>
movzbl -0x1(%rcx),%eax
mov    %al,(%rdx)
movzbl -0x2(%rcx),%eax
mov    %al,0x1(%rdx)
movzbl -0x3(%rcx),%eax
mov    %al,0x2(%rdx)
movzbl -0x4(%rcx),%eax
mov    %al,0x3(%rdx)
movzbl -0x5(%rcx),%eax
mov    %al,0x4(%rdx)
movzbl -0x6(%rcx),%eax
mov    %al,0x5(%rdx)
movzbl -0x7(%rcx),%eax
mov    %al,0x6(%rdx)
movzbl -0x8(%rcx),%eax
add    $0xfffffffffffffff8,%rcx
mov    %al,0x7(%rdx)
add    $0x8,%rdx
cmp    %rsi,%rcx
jne    1580 <main+0x3a0>
mov    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
mov    %rdx,%r14
jmp    1740 <main+0x560>
mov    %rdi,%rbx
and    $0xffffffffffffffe0,%rbx
lea    (%rdx,%rbx,1),%r14
mov    %r13,%rax
sub    %rbx,%rax
lea    -0x10(%r13),%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rcx),%xmm1
movdqu (%rcx),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%rdx,%rbp,1)
movdqu %xmm1,0x10(%rdx,%rbp,1)
add    $0x20,%rbp
add    $0xffffffffffffffe0,%rcx
cmp    %rbp,%rbx
jne    15f0 <main+0x410>
cmp    %rbx,%rdi
jne    1774 <main+0x594>
add    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
nopl   (%rax)
add    $0x1,%r9
mov    $0x2,%edi
mov    %r13,%rax
mov    %r11,%r13
jmp    1752 <main+0x572>
mov    %rdi,%rbx
and    $0xffffffffffffffe0,%rbx
lea    (%rdx,%rbx,1),%r14
mov    %r11,%rcx
sub    %rbx,%rcx
lea    -0x10(%r11),%rax
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rax),%xmm1
movdqu (%rax),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,(%rdx,%rbp,1)
movdqu %xmm1,0x10(%rdx,%rbp,1)
add    $0x20,%rbp
add    $0xffffffffffffffe0,%rax
cmp    %rbp,%rbx
jne    16b0 <main+0x4d0>
cmp    %rbx,%rdi
jne    177c <main+0x59c>
add    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
nopl   0x0(%rax)
add    $0x1,%r15
mov    $0x1,%edi
mov    %r11,%rax
mov    %r10,%r11
mov    %r13,%r10
mov    %r13,%rsi
mov    (%rax),%al
add    $0x2,%rbx
mov    %al,(%r14)
mov    %rbx,%rdx
mov    %r10,%r13
test   %r12d,%r12d
je     17c7 <main+0x5e7>
test   %r8d,%r8d
jne    1410 <main+0x230>
jmp    17c7 <main+0x5e7>
mov    %r14,%rdx
jmp    1452 <main+0x272>
mov    %r14,%rdx
jmp    14c8 <main+0x2e8>
mov    0x282d(%rip),%rax
mov    (%rax),%edi
mov    0x0(%rbp),%rdx
lea    0x868(%rip),%rsi
call   10a0 <fprintf@plt>
mov    $0x1,%ebx
jmp    1ca2 <main+0xac2>
mov    0x20(%rsp),%r11
mov    0x18(%rsp),%rdx
mov    0x28(%rsp),%rsi
mov    %rsi,%r13
mov    %eax,%r12d
mov    0x30(%rsp),%rax
mov    %eax,%r8d
xor    %r9d,%r9d
mov    %r11,0x58(%rsp)
mov    %r8d,0x4c(%rsp)
test   %r12d,%r12d
je     19e1 <main+0x801>
xor    %r11d,%r11d
pxor   %xmm0,%xmm0
mov    %r13,%r10
mov    %r13,%rbp
mov    %r13,0x70(%rsp)
mov    %r15,0x50(%rsp)
jmp    183e <main+0x65e>
lea    (%r15,%rdx,1),%rdi
add    $0xffffffffffffffff,%rdi
mov    0x50(%rsp),%r15
mov    0x38(%rsp),%r9
mov    %ebx,%r12d
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    0x0(%rbp),%al
add    $0x2,%rdi
mov    %al,0x0(%r13)
mov    %rdi,%rdx
mov    %r8,%rsi
mov    0x70(%rsp),%r13
add    $0x1,%r11
add    $0x1,%r10
mov    %r8,%rbp
test   %r12d,%r12d
je     19e1 <main+0x801>
add    $0xffffffff,%r12d
lea    0x1(%rbp),%r8
cmpb   $0xa,0x0(%rbp)
jne    182a <main+0x64a>
mov    %r12d,%ebx
lea    (%r11,%r13,1),%r12
sub    %rsi,%r12
cmp    $0x20,%r12
jb     1872 <main+0x692>
cmp    %rbp,%rdx
jae    1913 <main+0x733>
lea    (%rdx,%r12,1),%rax
cmp    %rax,%rsi
jae    1913 <main+0x733>
mov    %rbp,%rax
mov    %ebx,%r12d
mov    %eax,%edi
sub    %esi,%edi
mov    %rsi,%rcx
not    %rcx
add    %rax,%rcx
and    $0x7,%rdi
je     18aa <main+0x6ca>
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rax),%ebx
add    $0xffffffffffffffff,%rax
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1890 <main+0x6b0>
lea    -0x1(%rdx),%rdi
jmp    18aa <main+0x6ca>
mov    %rdx,%r13
cmp    $0x7,%rcx
jb     1810 <main+0x630>
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rax),%ecx
mov    %cl,(%rdx)
movzbl -0x2(%rax),%ecx
mov    %cl,0x1(%rdx)
movzbl -0x3(%rax),%ecx
mov    %cl,0x2(%rdx)
movzbl -0x4(%rax),%ecx
mov    %cl,0x3(%rdx)
movzbl -0x5(%rax),%ecx
mov    %cl,0x4(%rdx)
movzbl -0x6(%rax),%ecx
mov    %cl,0x5(%rdx)
movzbl -0x7(%rax),%ecx
mov    %cl,0x6(%rdx)
movzbl -0x8(%rax),%ecx
add    $0xfffffffffffffff8,%rax
mov    %cl,0x7(%rdx)
add    $0x8,%rdx
cmp    %rsi,%rax
jne    18c0 <main+0x6e0>
mov    %rdx,%rdi
add    $0xffffffffffffffff,%rdi
mov    %rdx,%r13
jmp    1810 <main+0x630>
mov    %r9,0x38(%rsp)
mov    %r12,%r15
and    $0xffffffffffffffe0,%r15
lea    (%rdx,%r15,1),%r13
mov    %rbp,%rax
sub    %r15,%rax
lea    0x10(%rdx),%r14
mov    %r10,%rcx
sub    %rsi,%rcx
and    $0xffffffffffffffe0,%rcx
neg    %rcx
xor    %r9d,%r9d
nopl   (%rax)
movdqu -0x20(%rbp,%r9,1),%xmm1
movdqu -0x10(%rbp,%r9,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%r14)
movdqu %xmm1,(%r14)
add    $0xffffffffffffffe0,%r9
add    $0x20,%r14
cmp    %r9,%rcx
jne    1940 <main+0x760>
cmp    %r15,%r12
je     17f3 <main+0x613>
mov    %r13,%rdx
mov    0x50(%rsp),%r15
mov    0x38(%rsp),%r9
jmp    1875 <main+0x695>
mov    0x4c(%rsp),%r13d
test   %r13d,%r13d
mov    %r9,0x38(%rsp)
je     1be2 <main+0xa02>
xor    %r8d,%r8d
pxor   %xmm0,%xmm0
mov    0x58(%rsp),%rax
mov    %rax,%r14
mov    %rax,%rbp
jmp    1a4d <main+0x86d>
lea    (%r15,%rdx,1),%rdi
add    $0xffffffffffffffff,%rdi
mov    %r12,%r15
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r15
mov    0x0(%rbp),%al
add    $0x2,%rdi
mov    %al,(%r11)
mov    %rdi,%rdx
mov    %r10,%rsi
mov    0x58(%rsp),%rax
add    $0x1,%r8
add    $0x1,%r14
mov    %r10,%rbp
test   %r13d,%r13d
je     1be2 <main+0xa02>
add    $0xffffffff,%r13d
lea    0x1(%rbp),%r10
cmpb   $0xa,0x0(%rbp)
jne    1a39 <main+0x859>
lea    (%r8,%rax,1),%r9
sub    %rsi,%r9
cmp    $0x20,%r9
jb     1a7e <main+0x89e>
cmp    %rbp,%rdx
jae    1b23 <main+0x943>
lea    (%rdx,%r9,1),%rax
cmp    %rax,%rsi
jae    1b23 <main+0x943>
mov    %rbp,%rax
mov    %eax,%edi
sub    %esi,%edi
mov    %rsi,%rcx
not    %rcx
add    %rax,%rcx
and    $0x7,%rdi
je     1aba <main+0x8da>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x1(%rax),%ebx
add    $0xffffffffffffffff,%rax
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1aa0 <main+0x8c0>
lea    -0x1(%rdx),%rdi
jmp    1aba <main+0x8da>
mov    %rdx,%r11
cmp    $0x7,%rcx
jb     1a20 <main+0x840>
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rax),%ecx
mov    %cl,(%rdx)
movzbl -0x2(%rax),%ecx
mov    %cl,0x1(%rdx)
movzbl -0x3(%rax),%ecx
mov    %cl,0x2(%rdx)
movzbl -0x4(%rax),%ecx
mov    %cl,0x3(%rdx)
movzbl -0x5(%rax),%ecx
mov    %cl,0x4(%rdx)
movzbl -0x6(%rax),%ecx
mov    %cl,0x5(%rdx)
movzbl -0x7(%rax),%ecx
mov    %cl,0x6(%rdx)
movzbl -0x8(%rax),%ecx
add    $0xfffffffffffffff8,%rax
mov    %cl,0x7(%rdx)
add    $0x8,%rdx
cmp    %rsi,%rax
jne    1ad0 <main+0x8f0>
mov    %rdx,%rdi
add    $0xffffffffffffffff,%rdi
mov    %rdx,%r11
jmp    1a20 <main+0x840>
mov    %r15,%r12
mov    %r9,%r15
and    $0xffffffffffffffe0,%r15
lea    (%rdx,%r15,1),%r11
mov    %rbp,%rax
sub    %r15,%rax
lea    0x10(%rdx),%rdi
mov    %r14,%rcx
sub    %rsi,%rcx
and    $0xffffffffffffffe0,%rcx
neg    %rcx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movdqu -0x20(%rbp,%rbx,1),%xmm1
movdqu -0x10(%rbp,%rbx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rdi)
movdqu %xmm1,(%rdi)
add    $0xffffffffffffffe0,%rbx
add    $0x20,%rdi
cmp    %rbx,%rcx
jne    1b50 <main+0x970>
cmp    %r15,%r9
je     1a08 <main+0x828>
mov    %r11,%rdx
mov    %r12,%r15
jmp    1a81 <main+0x8a1>
xor    %ebx,%ebx
lea    0x60(%rsp),%rdi
xor    %esi,%esi
call   1080 <gettimeofday@plt>
mov    0x38(%rsp),%rbp
lea    (%r15,%rbp,1),%r14
mov    0x60(%rsp),%eax
mov    0x64(%rsp),%ecx
sub    0x68(%rsp),%eax
imul   $0xf4240,%eax,%eax
sub    0x6c(%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    0x3ed(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x3fe(%rip),%rdi
mov    %rbp,%rsi
mov    %r15,%rdx
mov    %r14,%rcx
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x18(%rsp),%rdi
mov    0x8(%rsp),%esi
call   10d0 <munmap@plt>
mov    0x20(%rsp),%rdi
mov    0x30(%rsp),%rsi
call   10d0 <munmap@plt>
mov    0x28(%rsp),%rdi
mov    0x40(%rsp),%rsi
call   10d0 <munmap@plt>
mov    0xc(%rsp),%edi
call   1090 <close@plt>
mov    0x10(%rsp),%edi
call   1090 <close@plt>
mov    0x14(%rsp),%edi
call   1090 <close@plt>
mov    %ebx,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x8(%rbp),%rdi
jmp    1cbd <main+0xadd>
mov    0x10(%rbp),%rdi
call   1100 <perror@plt>
mov    $0x1,%ebx
jmp    1ca2 <main+0xac2>
mov    0x10(%rbp),%rdi
call   1100 <perror@plt>
mov    $0x1,%ebx
jmp    1c99 <main+0xab9>
mov    0x18(%rbp),%rdi
call   1100 <perror@plt>
mov    $0x1,%ebx
jmp    1c90 <main+0xab0>
lea    0x32f(%rip),%rdi
call   1100 <perror@plt>
mov    $0x1,%ebx
jmp    1c87 <main+0xaa7>
lea    0x31c(%rip),%rdi
call   1100 <perror@plt>
mov    $0x1,%ebx
jmp    1c78 <main+0xa98>
lea    0x306(%rip),%rdi
call   1100 <perror@plt>
mov    $0x1,%ebx
jmp    1c69 <main+0xa89>

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

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"
@.str.1 = [3 x i8] c"rb\00"
@SEEK_END = global i32 0
@O_RDWR = global i32 0
@O_CREAT = global i32 0
@MAP_SHARED = global i32 0
@.str.2 = [11 x i8] c"mmap error\00"
@.str.3 = [31 x i8] c"Processing time = %d.%06d sec\0A\00"
@.str.4 = [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)
br label %644
15: ; preds = %2
%16 = getelementptr inbounds i8*, i8** %1, i64 1
%17 = load i8*, i8** %16
%18 = tail call i32* @fopen(i8* %17, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%19 = icmp eq i32* %18, null
br i1 %19, label %20, label %23
20: ; preds = %15
%21 = load i8*, i8** %16
%22 = tail call i32 @perror(i8* %21)
br label %644
23: ; preds = %15
%24 = load i32, i32* @SEEK_END
%25 = tail call i32 @fseek(i32* %18, i64 0, i32 %24)
%26 = tail call i32 @ftell(i32* %18)
%27 = tail call i32 @fclose(i32* %18)
%28 = getelementptr inbounds i8*, i8** %1, i64 2
%29 = load i8*, i8** %28
%30 = tail call i32* @fopen(i8* %29, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%31 = icmp eq i32* %30, null
br i1 %31, label %32, label %35
32: ; preds = %23
%33 = load i8*, i8** %28
%34 = tail call i32 @perror(i8* %33)
br label %644
35: ; preds = %23
%36 = load i32, i32* @SEEK_END
%37 = tail call i32 @fseek(i32* %30, i64 0, i32 %36)
%38 = tail call i32 @ftell(i32* %30)
%39 = tail call i32 @fclose(i32* %30)
%40 = load i8*, i8** %16
%41 = load i32, i32* @O_RDWR
%42 = load i32, i32* @O_CREAT
%43 = or i32 %42, %41
%44 = tail call i32 (i8*, i32, ...) @open(i8* %40, i32 %43)
%45 = icmp slt i32 %44, 0
br i1 %45, label %46, label %49
46: ; preds = %35
%47 = load i8*, i8** %16
%48 = tail call i32 @perror(i8* %47)
br label %644
49: ; preds = %35
%50 = load i8*, i8** %28
%51 = load i32, i32* @O_RDWR
%52 = load i32, i32* @O_CREAT
%53 = or i32 %52, %51
%54 = tail call i32 (i8*, i32, ...) @open(i8* %50, i32 %53)
%55 = icmp slt i32 %54, 0
br i1 %55, label %56, label %59
56: ; preds = %49
%57 = load i8*, i8** %28
%58 = tail call i32 @perror(i8* %57)
br label %641
59: ; preds = %49
%60 = getelementptr inbounds i8*, i8** %1, i64 3
%61 = load i8*, i8** %60
%62 = load i32, i32* @O_RDWR
%63 = load i32, i32* @O_CREAT
%64 = or i32 %63, %62
%65 = tail call i32 (i8*, i32, ...) @open(i8* %61, i32 %64, i32 420)
%66 = icmp slt i32 %65, 0
br i1 %66, label %67, label %70
67: ; preds = %59
%68 = load i8*, i8** %60
%69 = tail call i32 @perror(i8* %68)
br label %638
70: ; preds = %59
%71 = tail call i32 @write(i32 %65, i32* null, i32 0)
%72 = add nsw i32 %38, %26
%73 = tail call i32 @ftruncate(i32 %65, i32 %72)
%74 = load i32, i32* @MAP_SHARED
%75 = tail call i8* @mmap(i32 0, i32 %26, i32 %9, i32 %74, i32 %44, i32 0)
%76 = icmp eq i8* %75, null
br i1 %76, label %77, label %79
77: ; preds = %70
%78 = tail call i32 @perror(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %635
79: ; preds = %70
%80 = load i32, i32* @MAP_SHARED
%81 = tail call i8* @mmap(i32 0, i32 %38, i32 %9, i32 %80, i32 %54, i32 0)
%82 = icmp eq i8* %81, null
br i1 %82, label %83, label %85
83: ; preds = %79
%84 = tail call i32 @perror(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %632
85: ; preds = %79
%86 = load i32, i32* @MAP_SHARED
%87 = tail call i8* @mmap(i32 0, i32 %72, i32 %9, i32 %86, i32 %65, i32 0)
%88 = icmp eq i8* %87, null
br i1 %88, label %89, label %91
89: ; preds = %85
%90 = tail call i32 @perror(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.2, i64 0, i64 0))
br label %629
91: ; preds = %85
%92 = call i32 @gettimeofday(%struct.timeval* %3, i32* null)
%93 = icmp ne i32 %26, 0
%94 = icmp ne i32 %38, 0
%95 = and i1 %93, %94
br i1 %95, label %111, label %96
96: ; preds = %347, %91
%97 = phi i8* [ %81, %91 ], [ %348, %347 ]
%98 = phi i8* [ %87, %91 ], [ %349, %347 ]
%99 = phi i8* [ %75, %91 ], [ %350, %347 ]
%100 = phi i32 [ %26, %91 ], [ %351, %347 ]
%101 = phi i32 [ %38, %91 ], [ %352, %347 ]
%102 = phi i64 [ 0, %91 ], [ %354, %347 ]
%103 = phi i8* [ %75, %91 ], [ %355, %347 ]
%104 = phi i64 [ 0, %91 ], [ %356, %347 ]
%105 = ptrtoint i8* %97 to i64
%106 = ptrtoint i8* %99 to i64
%107 = icmp eq i32 %100, 0
br i1 %107, label %360, label %108
108: ; preds = %96
%109 = sub i64 0, %106
%110 = getelementptr i8, i8* %99, i64 %109
br label %368
111: ; preds = %91, %347
%112 = phi i64 [ %356, %347 ], [ 0, %91 ]
%113 = phi i8* [ %355, %347 ], [ %75, %91 ]
%114 = phi i64 [ %354, %347 ], [ 0, %91 ]
%115 = phi i32 [ %353, %347 ], [ 1, %91 ]
%116 = phi i32 [ %352, %347 ], [ %38, %91 ]
%117 = phi i32 [ %351, %347 ], [ %26, %91 ]
%118 = phi i8* [ %350, %347 ], [ %75, %91 ]
%119 = phi i8* [ %349, %347 ], [ %87, %91 ]
%120 = phi i8* [ %348, %347 ], [ %81, %91 ]
%121 = ptrtoint i8* %113 to i64
%122 = ptrtoint i8* %120 to i64
%123 = ptrtoint i8* %113 to i64
%124 = ptrtoint i8* %118 to i64
%125 = ptrtoint i8* %113 to i64
%126 = icmp eq i32 %115, 1
br i1 %126, label %127, label %230
127: ; preds = %111
%128 = add nsw i32 %117, -1
%129 = getelementptr inbounds i8, i8* %118, i64 1
%130 = load i8, i8* %118
%131 = icmp eq i8 %130, 10
br i1 %131, label %132, label %347
132: ; preds = %127
%133 = sub i64 %124, %123
%134 = icmp ult i64 %133, 32
br i1 %134, label %172, label %135
135: ; preds = %132
%136 = sub i64 %124, %125
%137 = getelementptr i8, i8* %119, i64 %136
%138 = sub i64 %125, %124
%139 = getelementptr i8, i8* %118, i64 %138
%140 = icmp ult i8* %119, %118
%141 = icmp ult i8* %139, %137
%142 = and i1 %140, %141
br i1 %142, label %172, label %143
143: ; preds = %135
%144 = and i64 %133, -32
%145 = getelementptr i8, i8* %119, i64 %144
%146 = sub i64 0, %144
%147 = getelementptr i8, i8* %118, i64 %146
%148 = getelementptr i8, i8* %118, i64 -1
br label %149
149: ; preds = %149, %143
%150 = phi i64 [ 0, %143 ], [ %166, %149 ]
%151 = getelementptr i8, i8* %119, i64 %150
%152 = sub i64 0, %150
%153 = getelementptr inbounds i8, i8* %148, i64 %152
%154 = getelementptr inbounds i8, i8* %153, i64 -15
%155 = bitcast i8* %154 to <16 x i8>*
%156 = load <16 x i8>, <16 x i8>* %155
%157 = shufflevector <16 x i8> %156, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%158 = getelementptr inbounds i8, i8* %153, i64 -16
%159 = getelementptr inbounds i8, i8* %158, i64 -15
%160 = bitcast i8* %159 to <16 x i8>*
%161 = load <16 x i8>, <16 x i8>* %160
%162 = shufflevector <16 x i8> %161, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%163 = bitcast i8* %151 to <16 x i8>*
store <16 x i8> %157, <16 x i8>* %163
%164 = getelementptr i8, i8* %151, i64 16
%165 = bitcast i8* %164 to <16 x i8>*
store <16 x i8> %162, <16 x i8>* %165
%166 = add nuw i64 %150, 32
%167 = icmp eq i64 %166, %144
br i1 %167, label %168, label %149
168: ; preds = %149
%169 = icmp eq i64 %133, %144
%170 = add i64 %144, -1
%171 = getelementptr i8, i8* %119, i64 %170
br i1 %169, label %226, label %172
172: ; preds = %135, %132, %168
%173 = phi i8* [ %119, %135 ], [ %119, %132 ], [ %145, %168 ]
%174 = phi i8* [ %118, %135 ], [ %118, %132 ], [ %147, %168 ]
%175 = ptrtoint i8* %174 to i64
%176 = sub i64 %175, %121
%177 = xor i64 %121, -1
%178 = add i64 %177, %175
%179 = and i64 %176, 7
%180 = icmp eq i64 %179, 0
br i1 %180, label %190, label %181
181: ; preds = %172, %181
%182 = phi i8* [ %187, %181 ], [ %173, %172 ]
%183 = phi i8* [ %185, %181 ], [ %174, %172 ]
%184 = phi i64 [ %188, %181 ], [ 0, %172 ]
%185 = getelementptr inbounds i8, i8* %183, i64 -1
%186 = load i8, i8* %185
%187 = getelementptr inbounds i8, i8* %182, i64 1
store i8 %186, i8* %182
%188 = add i64 %184, 1
%189 = icmp eq i64 %188, %179
br i1 %189, label %190, label %181
190: ; preds = %181, %172
%191 = phi i8* [ undef, %172 ], [ %182, %181 ]
%192 = phi i8* [ undef, %172 ], [ %187, %181 ]
%193 = phi i8* [ %173, %172 ], [ %187, %181 ]
%194 = phi i8* [ %174, %172 ], [ %185, %181 ]
%195 = icmp ult i64 %178, 7
br i1 %195, label %226, label %196
196: ; preds = %190, %196
%197 = phi i8* [ %222, %196 ], [ %193, %190 ]
%198 = phi i8* [ %220, %196 ], [ %194, %190 ]
%199 = getelementptr inbounds i8, i8* %198, i64 -1
%200 = load i8, i8* %199
%201 = getelementptr inbounds i8, i8* %197, i64 1
store i8 %200, i8* %197
%202 = getelementptr inbounds i8, i8* %198, i64 -2
%203 = load i8, i8* %202
%204 = getelementptr inbounds i8, i8* %197, i64 2
store i8 %203, i8* %201
%205 = getelementptr inbounds i8, i8* %198, i64 -3
%206 = load i8, i8* %205
%207 = getelementptr inbounds i8, i8* %197, i64 3
store i8 %206, i8* %204
%208 = getelementptr inbounds i8, i8* %198, i64 -4
%209 = load i8, i8* %208
%210 = getelementptr inbounds i8, i8* %197, i64 4
store i8 %209, i8* %207
%211 = getelementptr inbounds i8, i8* %198, i64 -5
%212 = load i8, i8* %211
%213 = getelementptr inbounds i8, i8* %197, i64 5
store i8 %212, i8* %210
%214 = getelementptr inbounds i8, i8* %198, i64 -6
%215 = load i8, i8* %214
%216 = getelementptr inbounds i8, i8* %197, i64 6
store i8 %215, i8* %213
%217 = getelementptr inbounds i8, i8* %198, i64 -7
%218 = load i8, i8* %217
%219 = getelementptr inbounds i8, i8* %197, i64 7
store i8 %218, i8* %216
%220 = getelementptr inbounds i8, i8* %198, i64 -8
%221 = load i8, i8* %220
%222 = getelementptr inbounds i8, i8* %197, i64 8
store i8 %221, i8* %219
%223 = icmp eq i8* %220, %113
br i1 %223, label %224, label %196
224: ; preds = %196
%225 = getelementptr inbounds i8, i8* %197, i64 7
br label %226
226: ; preds = %224, %190, %168
%227 = phi i8* [ %171, %168 ], [ %191, %190 ], [ %225, %224 ]
%228 = phi i8* [ %145, %168 ], [ %192, %190 ], [ %222, %224 ]
%229 = add nsw i64 %112, 1
br label %333
230: ; preds = %111
%231 = add nsw i32 %116, -1
%232 = getelementptr inbounds i8, i8* %120, i64 1
%233 = load i8, i8* %120
%234 = icmp eq i8 %233, 10
br i1 %234, label %235, label %347
235: ; preds = %230
%236 = sub i64 %122, %121
%237 = icmp ult i64 %236, 32
br i1 %237, label %275, label %238
238: ; preds = %235
%239 = sub i64 %122, %123
%240 = getelementptr i8, i8* %119, i64 %239
%241 = sub i64 %123, %122
%242 = getelementptr i8, i8* %120, i64 %241
%243 = icmp ult i8* %119, %120
%244 = icmp ult i8* %242, %240
%245 = and i1 %243, %244
br i1 %245, label %275, label %246
246: ; preds = %238
%247 = and i64 %236, -32
%248 = getelementptr i8, i8* %119, i64 %247
%249 = sub i64 0, %247
%250 = getelementptr i8, i8* %120, i64 %249
%251 = getelementptr i8, i8* %120, i64 -1
br label %252
252: ; preds = %252, %246
%253 = phi i64 [ 0, %246 ], [ %269, %252 ]
%254 = getelementptr i8, i8* %119, i64 %253
%255 = sub i64 0, %253
%256 = getelementptr inbounds i8, i8* %251, i64 %255
%257 = getelementptr inbounds i8, i8* %256, i64 -15
%258 = bitcast i8* %257 to <16 x i8>*
%259 = load <16 x i8>, <16 x i8>* %258
%260 = shufflevector <16 x i8> %259, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%261 = getelementptr inbounds i8, i8* %256, i64 -16
%262 = getelementptr inbounds i8, i8* %261, i64 -15
%263 = bitcast i8* %262 to <16 x i8>*
%264 = load <16 x i8>, <16 x i8>* %263
%265 = shufflevector <16 x i8> %264, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%266 = bitcast i8* %254 to <16 x i8>*
store <16 x i8> %260, <16 x i8>* %266
%267 = getelementptr i8, i8* %254, i64 16
%268 = bitcast i8* %267 to <16 x i8>*
store <16 x i8> %265, <16 x i8>* %268
%269 = add nuw i64 %253, 32
%270 = icmp eq i64 %269, %247
br i1 %270, label %271, label %252
271: ; preds = %252
%272 = icmp eq i64 %236, %247
%273 = add i64 %247, -1
%274 = getelementptr i8, i8* %119, i64 %273
br i1 %272, label %329, label %275
275: ; preds = %238, %235, %271
%276 = phi i8* [ %119, %238 ], [ %119, %235 ], [ %248, %271 ]
%277 = phi i8* [ %120, %238 ], [ %120, %235 ], [ %250, %271 ]
%278 = ptrtoint i8* %277 to i64
%279 = sub i64 %278, %121
%280 = xor i64 %121, -1
%281 = add i64 %280, %278
%282 = and i64 %279, 7
%283 = icmp eq i64 %282, 0
br i1 %283, label %293, label %284
284: ; preds = %275, %284
%285 = phi i8* [ %290, %284 ], [ %276, %275 ]
%286 = phi i8* [ %288, %284 ], [ %277, %275 ]
%287 = phi i64 [ %291, %284 ], [ 0, %275 ]
%288 = getelementptr inbounds i8, i8* %286, i64 -1
%289 = load i8, i8* %288
%290 = getelementptr inbounds i8, i8* %285, i64 1
store i8 %289, i8* %285
%291 = add i64 %287, 1
%292 = icmp eq i64 %291, %282
br i1 %292, label %293, label %284
293: ; preds = %284, %275
%294 = phi i8* [ undef, %275 ], [ %285, %284 ]
%295 = phi i8* [ undef, %275 ], [ %290, %284 ]
%296 = phi i8* [ %276, %275 ], [ %290, %284 ]
%297 = phi i8* [ %277, %275 ], [ %288, %284 ]
%298 = icmp ult i64 %281, 7
br i1 %298, label %329, label %299
299: ; preds = %293, %299
%300 = phi i8* [ %325, %299 ], [ %296, %293 ]
%301 = phi i8* [ %323, %299 ], [ %297, %293 ]
%302 = getelementptr inbounds i8, i8* %301, i64 -1
%303 = load i8, i8* %302
%304 = getelementptr inbounds i8, i8* %300, i64 1
store i8 %303, i8* %300
%305 = getelementptr inbounds i8, i8* %301, i64 -2
%306 = load i8, i8* %305
%307 = getelementptr inbounds i8, i8* %300, i64 2
store i8 %306, i8* %304
%308 = getelementptr inbounds i8, i8* %301, i64 -3
%309 = load i8, i8* %308
%310 = getelementptr inbounds i8, i8* %300, i64 3
store i8 %309, i8* %307
%311 = getelementptr inbounds i8, i8* %301, i64 -4
%312 = load i8, i8* %311
%313 = getelementptr inbounds i8, i8* %300, i64 4
store i8 %312, i8* %310
%314 = getelementptr inbounds i8, i8* %301, i64 -5
%315 = load i8, i8* %314
%316 = getelementptr inbounds i8, i8* %300, i64 5
store i8 %315, i8* %313
%317 = getelementptr inbounds i8, i8* %301, i64 -6
%318 = load i8, i8* %317
%319 = getelementptr inbounds i8, i8* %300, i64 6
store i8 %318, i8* %316
%320 = getelementptr inbounds i8, i8* %301, i64 -7
%321 = load i8, i8* %320
%322 = getelementptr inbounds i8, i8* %300, i64 7
store i8 %321, i8* %319
%323 = getelementptr inbounds i8, i8* %301, i64 -8
%324 = load i8, i8* %323
%325 = getelementptr inbounds i8, i8* %300, i64 8
store i8 %324, i8* %322
%326 = icmp eq i8* %323, %113
br i1 %326, label %327, label %299
327: ; preds = %299
%328 = getelementptr inbounds i8, i8* %300, i64 7
br label %329
329: ; preds = %327, %293, %271
%330 = phi i8* [ %274, %271 ], [ %294, %293 ], [ %328, %327 ]
%331 = phi i8* [ %248, %271 ], [ %295, %293 ], [ %325, %327 ]
%332 = add nsw i64 %114, 1
br label %333
333: ; preds = %226, %329
%334 = phi i8* [ %120, %329 ], [ %118, %226 ]
%335 = phi i8* [ %330, %329 ], [ %227, %226 ]
%336 = phi i8* [ %331, %329 ], [ %228, %226 ]
%337 = phi i8* [ %232, %329 ], [ %120, %226 ]
%338 = phi i8* [ %118, %329 ], [ %129, %226 ]
%339 = phi i32 [ %117, %329 ], [ %128, %226 ]
%340 = phi i32 [ %231, %329 ], [ %116, %226 ]
%341 = phi i32 [ 1, %329 ], [ 2, %226 ]
%342 = phi i64 [ %332, %329 ], [ %114, %226 ]
%343 = phi i8* [ %118, %329 ], [ %120, %226 ]
%344 = phi i64 [ %112, %329 ], [ %229, %226 ]
%345 = load i8, i8* %334
%346 = getelementptr inbounds i8, i8* %335, i64 2
store i8 %345, i8* %336
br label %347
347: ; preds = %333, %230, %127
%348 = phi i8* [ %120, %127 ], [ %232, %230 ], [ %337, %333 ]
%349 = phi i8* [ %119, %127 ], [ %119, %230 ], [ %346, %333 ]
%350 = phi i8* [ %129, %127 ], [ %118, %230 ], [ %338, %333 ]
%351 = phi i32 [ %128, %127 ], [ %117, %230 ], [ %339, %333 ]
%352 = phi i32 [ %116, %127 ], [ %231, %230 ], [ %340, %333 ]
%353 = phi i32 [ 1, %127 ], [ 2, %230 ], [ %341, %333 ]
%354 = phi i64 [ %114, %127 ], [ %114, %230 ], [ %342, %333 ]
%355 = phi i8* [ %113, %127 ], [ %113, %230 ], [ %343, %333 ]
%356 = phi i64 [ %112, %127 ], [ %112, %230 ], [ %344, %333 ]
%357 = icmp ne i32 %351, 0
%358 = icmp ne i32 %352, 0
%359 = select i1 %357, i1 %358, i1 false
br i1 %359, label %111, label %96
360: ; preds = %481, %96
%361 = phi i8* [ %98, %96 ], [ %482, %481 ]
%362 = phi i8* [ %103, %96 ], [ %483, %481 ]
%363 = phi i64 [ %104, %96 ], [ %484, %481 ]
%364 = icmp eq i32 %101, 0
br i1 %364, label %606, label %365
365: ; preds = %360
%366 = sub i64 0, %105
%367 = getelementptr i8, i8* %97, i64 %366
br label %487
368: ; preds = %108, %481
%369 = phi i64 [ 0, %108 ], [ %486, %481 ]
%370 = phi i64 [ %104, %108 ], [ %484, %481 ]
%371 = phi i8* [ %103, %108 ], [ %483, %481 ]
%372 = phi i32 [ %100, %108 ], [ %377, %481 ]
%373 = phi i8* [ %99, %108 ], [ %378, %481 ]
%374 = phi i8* [ %98, %108 ], [ %482, %481 ]
%375 = ptrtoint i8* %371 to i64
%376 = add i64 %369, %106
%377 = add nsw i32 %372, -1
%378 = getelementptr inbounds i8, i8* %373, i64 1
%379 = load i8, i8* %373
%380 = icmp eq i8 %379, 10
br i1 %380, label %381, label %481
381: ; preds = %368
%382 = add i64 %369, %106
%383 = sub i64 %382, %375
%384 = icmp ult i64 %383, 32
br i1 %384, label %421, label %385
385: ; preds = %381
%386 = sub i64 %376, %375
%387 = getelementptr i8, i8* %374, i64 %386
%388 = getelementptr i8, i8* %110, i64 %375
%389 = icmp ult i8* %374, %373
%390 = icmp ult i8* %388, %387
%391 = and i1 %389, %390
br i1 %391, label %421, label %392
392: ; preds = %385
%393 = and i64 %383, -32
%394 = getelementptr i8, i8* %374, i64 %393
%395 = sub i64 0, %393
%396 = getelementptr i8, i8* %373, i64 %395
%397 = getelementptr i8, i8* %373, i64 -1
br label %398
398: ; preds = %398, %392
%399 = phi i64 [ 0, %392 ], [ %415, %398 ]
%400 = getelementptr i8, i8* %374, i64 %399
%401 = sub i64 0, %399
%402 = getelementptr inbounds i8, i8* %397, i64 %401
%403 = getelementptr inbounds i8, i8* %402, i64 -15
%404 = bitcast i8* %403 to <16 x i8>*
%405 = load <16 x i8>, <16 x i8>* %404
%406 = shufflevector <16 x i8> %405, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%407 = getelementptr inbounds i8, i8* %402, i64 -16
%408 = getelementptr inbounds i8, i8* %407, i64 -15
%409 = bitcast i8* %408 to <16 x i8>*
%410 = load <16 x i8>, <16 x i8>* %409
%411 = shufflevector <16 x i8> %410, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%412 = bitcast i8* %400 to <16 x i8>*
store <16 x i8> %406, <16 x i8>* %412
%413 = getelementptr i8, i8* %400, i64 16
%414 = bitcast i8* %413 to <16 x i8>*
store <16 x i8> %411, <16 x i8>* %414
%415 = add nuw i64 %399, 32
%416 = icmp eq i64 %415, %393
br i1 %416, label %417, label %398
417: ; preds = %398
%418 = icmp eq i64 %383, %393
%419 = add i64 %393, -1
%420 = getelementptr i8, i8* %374, i64 %419
br i1 %418, label %475, label %421
421: ; preds = %385, %381, %417
%422 = phi i8* [ %374, %385 ], [ %374, %381 ], [ %394, %417 ]
%423 = phi i8* [ %373, %385 ], [ %373, %381 ], [ %396, %417 ]
%424 = ptrtoint i8* %423 to i64
%425 = sub i64 %424, %375
%426 = xor i64 %375, -1
%427 = add i64 %426, %424
%428 = and i64 %425, 7
%429 = icmp eq i64 %428, 0
br i1 %429, label %439, label %430
430: ; preds = %421, %430
%431 = phi i8* [ %436, %430 ], [ %422, %421 ]
%432 = phi i8* [ %434, %430 ], [ %423, %421 ]
%433 = phi i64 [ %437, %430 ], [ 0, %421 ]
%434 = getelementptr inbounds i8, i8* %432, i64 -1
%435 = load i8, i8* %434
%436 = getelementptr inbounds i8, i8* %431, i64 1
store i8 %435, i8* %431
%437 = add i64 %433, 1
%438 = icmp eq i64 %437, %428
br i1 %438, label %439, label %430
439: ; preds = %430, %421
%440 = phi i8* [ undef, %421 ], [ %431, %430 ]
%441 = phi i8* [ undef, %421 ], [ %436, %430 ]
%442 = phi i8* [ %422, %421 ], [ %436, %430 ]
%443 = phi i8* [ %423, %421 ], [ %434, %430 ]
%444 = icmp ult i64 %427, 7
br i1 %444, label %475, label %445
445: ; preds = %439, %445
%446 = phi i8* [ %471, %445 ], [ %442, %439 ]
%447 = phi i8* [ %469, %445 ], [ %443, %439 ]
%448 = getelementptr inbounds i8, i8* %447, i64 -1
%449 = load i8, i8* %448
%450 = getelementptr inbounds i8, i8* %446, i64 1
store i8 %449, i8* %446
%451 = getelementptr inbounds i8, i8* %447, i64 -2
%452 = load i8, i8* %451
%453 = getelementptr inbounds i8, i8* %446, i64 2
store i8 %452, i8* %450
%454 = getelementptr inbounds i8, i8* %447, i64 -3
%455 = load i8, i8* %454
%456 = getelementptr inbounds i8, i8* %446, i64 3
store i8 %455, i8* %453
%457 = getelementptr inbounds i8, i8* %447, i64 -4
%458 = load i8, i8* %457
%459 = getelementptr inbounds i8, i8* %446, i64 4
store i8 %458, i8* %456
%460 = getelementptr inbounds i8, i8* %447, i64 -5
%461 = load i8, i8* %460
%462 = getelementptr inbounds i8, i8* %446, i64 5
store i8 %461, i8* %459
%463 = getelementptr inbounds i8, i8* %447, i64 -6
%464 = load i8, i8* %463
%465 = getelementptr inbounds i8, i8* %446, i64 6
store i8 %464, i8* %462
%466 = getelementptr inbounds i8, i8* %447, i64 -7
%467 = load i8, i8* %466
%468 = getelementptr inbounds i8, i8* %446, i64 7
store i8 %467, i8* %465
%469 = getelementptr inbounds i8, i8* %447, i64 -8
%470 = load i8, i8* %469
%471 = getelementptr inbounds i8, i8* %446, i64 8
store i8 %470, i8* %468
%472 = icmp eq i8* %469, %371
br i1 %472, label %473, label %445
473: ; preds = %445
%474 = getelementptr inbounds i8, i8* %446, i64 7
br label %475
475: ; preds = %473, %439, %417
%476 = phi i8* [ %420, %417 ], [ %440, %439 ], [ %474, %473 ]
%477 = phi i8* [ %394, %417 ], [ %441, %439 ], [ %471, %473 ]
%478 = add nsw i64 %370, 1
%479 = load i8, i8* %373
%480 = getelementptr inbounds i8, i8* %476, i64 2
store i8 %479, i8* %477
br label %481
481: ; preds = %475, %368
%482 = phi i8* [ %480, %475 ], [ %374, %368 ]
%483 = phi i8* [ %378, %475 ], [ %371, %368 ]
%484 = phi i64 [ %478, %475 ], [ %370, %368 ]
%485 = icmp eq i32 %377, 0
%486 = add i64 %369, 1
br i1 %485, label %360, label %368
487: ; preds = %365, %600
%488 = phi i64 [ 0, %365 ], [ %605, %600 ]
%489 = phi i8* [ %362, %365 ], [ %603, %600 ]
%490 = phi i64 [ %102, %365 ], [ %602, %600 ]
%491 = phi i32 [ %101, %365 ], [ %496, %600 ]
%492 = phi i8* [ %361, %365 ], [ %601, %600 ]
%493 = phi i8* [ %97, %365 ], [ %497, %600 ]
%494 = ptrtoint i8* %489 to i64
%495 = add i64 %488, %105
%496 = add nsw i32 %491, -1
%497 = getelementptr inbounds i8, i8* %493, i64 1
%498 = load i8, i8* %493
%499 = icmp eq i8 %498, 10
br i1 %499, label %500, label %600
500: ; preds = %487
%501 = add i64 %488, %105
%502 = sub i64 %501, %494
%503 = icmp ult i64 %502, 32
br i1 %503, label %540, label %504
504: ; preds = %500
%505 = sub i64 %495, %494
%506 = getelementptr i8, i8* %492, i64 %505
%507 = getelementptr i8, i8* %367, i64 %494
%508 = icmp ult i8* %492, %493
%509 = icmp ult i8* %507, %506
%510 = and i1 %508, %509
br i1 %510, label %540, label %511
511: ; preds = %504
%512 = and i64 %502, -32
%513 = getelementptr i8, i8* %492, i64 %512
%514 = sub i64 0, %512
%515 = getelementptr i8, i8* %493, i64 %514
%516 = getelementptr i8, i8* %493, i64 -1
br label %517
517: ; preds = %517, %511
%518 = phi i64 [ 0, %511 ], [ %534, %517 ]
%519 = getelementptr i8, i8* %492, i64 %518
%520 = sub i64 0, %518
%521 = getelementptr inbounds i8, i8* %516, i64 %520
%522 = getelementptr inbounds i8, i8* %521, i64 -15
%523 = bitcast i8* %522 to <16 x i8>*
%524 = load <16 x i8>, <16 x i8>* %523
%525 = shufflevector <16 x i8> %524, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%526 = getelementptr inbounds i8, i8* %521, i64 -16
%527 = getelementptr inbounds i8, i8* %526, i64 -15
%528 = bitcast i8* %527 to <16 x i8>*
%529 = load <16 x i8>, <16 x i8>* %528
%530 = shufflevector <16 x i8> %529, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%531 = bitcast i8* %519 to <16 x i8>*
store <16 x i8> %525, <16 x i8>* %531
%532 = getelementptr i8, i8* %519, i64 16
%533 = bitcast i8* %532 to <16 x i8>*
store <16 x i8> %530, <16 x i8>* %533
%534 = add nuw i64 %518, 32
%535 = icmp eq i64 %534, %512
br i1 %535, label %536, label %517
536: ; preds = %517
%537 = icmp eq i64 %502, %512
%538 = add i64 %512, -1
%539 = getelementptr i8, i8* %492, i64 %538
br i1 %537, label %594, label %540
540: ; preds = %504, %500, %536
%541 = phi i8* [ %492, %504 ], [ %492, %500 ], [ %513, %536 ]
%542 = phi i8* [ %493, %504 ], [ %493, %500 ], [ %515, %536 ]
%543 = ptrtoint i8* %542 to i64
%544 = sub i64 %543, %494
%545 = xor i64 %494, -1
%546 = add i64 %545, %543
%547 = and i64 %544, 7
%548 = icmp eq i64 %547, 0
br i1 %548, label %558, label %549
549: ; preds = %540, %549
%550 = phi i8* [ %555, %549 ], [ %541, %540 ]
%551 = phi i8* [ %553, %549 ], [ %542, %540 ]
%552 = phi i64 [ %556, %549 ], [ 0, %540 ]
%553 = getelementptr inbounds i8, i8* %551, i64 -1
%554 = load i8, i8* %553
%555 = getelementptr inbounds i8, i8* %550, i64 1
store i8 %554, i8* %550
%556 = add i64 %552, 1
%557 = icmp eq i64 %556, %547
br i1 %557, label %558, label %549
558: ; preds = %549, %540
%559 = phi i8* [ undef, %540 ], [ %550, %549 ]
%560 = phi i8* [ undef, %540 ], [ %555, %549 ]
%561 = phi i8* [ %541, %540 ], [ %555, %549 ]
%562 = phi i8* [ %542, %540 ], [ %553, %549 ]
%563 = icmp ult i64 %546, 7
br i1 %563, label %594, label %564
564: ; preds = %558, %564
%565 = phi i8* [ %590, %564 ], [ %561, %558 ]
%566 = phi i8* [ %588, %564 ], [ %562, %558 ]
%567 = getelementptr inbounds i8, i8* %566, i64 -1
%568 = load i8, i8* %567
%569 = getelementptr inbounds i8, i8* %565, i64 1
store i8 %568, i8* %565
%570 = getelementptr inbounds i8, i8* %566, i64 -2
%571 = load i8, i8* %570
%572 = getelementptr inbounds i8, i8* %565, i64 2
store i8 %571, i8* %569
%573 = getelementptr inbounds i8, i8* %566, i64 -3
%574 = load i8, i8* %573
%575 = getelementptr inbounds i8, i8* %565, i64 3
store i8 %574, i8* %572
%576 = getelementptr inbounds i8, i8* %566, i64 -4
%577 = load i8, i8* %576
%578 = getelementptr inbounds i8, i8* %565, i64 4
store i8 %577, i8* %575
%579 = getelementptr inbounds i8, i8* %566, i64 -5
%580 = load i8, i8* %579
%581 = getelementptr inbounds i8, i8* %565, i64 5
store i8 %580, i8* %578
%582 = getelementptr inbounds i8, i8* %566, i64 -6
%583 = load i8, i8* %582
%584 = getelementptr inbounds i8, i8* %565, i64 6
store i8 %583, i8* %581
%585 = getelementptr inbounds i8, i8* %566, i64 -7
%586 = load i8, i8* %585
%587 = getelementptr inbounds i8, i8* %565, i64 7
store i8 %586, i8* %584
%588 = getelementptr inbounds i8, i8* %566, i64 -8
%589 = load i8, i8* %588
%590 = getelementptr inbounds i8, i8* %565, i64 8
store i8 %589, i8* %587
%591 = icmp eq i8* %588, %489
br i1 %591, label %592, label %564
592: ; preds = %564
%593 = getelementptr inbounds i8, i8* %565, i64 7
br label %594
594: ; preds = %592, %558, %536
%595 = phi i8* [ %539, %536 ], [ %559, %558 ], [ %593, %592 ]
%596 = phi i8* [ %513, %536 ], [ %560, %558 ], [ %590, %592 ]
%597 = add nsw i64 %490, 1
%598 = load i8, i8* %493
%599 = getelementptr inbounds i8, i8* %595, i64 2
store i8 %598, i8* %596
br label %600
600: ; preds = %594, %487
%601 = phi i8* [ %599, %594 ], [ %492, %487 ]
%602 = phi i64 [ %597, %594 ], [ %490, %487 ]
%603 = phi i8* [ %497, %594 ], [ %489, %487 ]
%604 = icmp eq i32 %496, 0
%605 = add i64 %488, 1
br i1 %604, label %606, label %487
606: ; preds = %600, %360
%607 = phi i64 [ %102, %360 ], [ %602, %600 ]
%608 = call i32 @gettimeofday(%struct.timeval* %4, i32* null)
%609 = add nsw i64 %607, %363
%610 = getelementptr inbounds %struct.timeval, %struct.timeval* %4, i64 0, i32 0
%611 = load i32, i32* %610
%612 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 0
%613 = load i32, i32* %612
%614 = sub nsw i32 %611, %613
%615 = mul nsw i32 %614, 1000000
%616 = getelementptr inbounds %struct.timeval, %struct.timeval* %4, i64 0, i32 1
%617 = load i32, i32* %616
%618 = getelementptr inbounds %struct.timeval, %struct.timeval* %3, i64 0, i32 1
%619 = load i32, i32* %618
%620 = sub nsw i32 %617, %619
%621 = add nsw i32 %620, %615
%622 = sdiv i32 %621, 1000000
%623 = sext i32 %622 to i64
%624 = srem i32 %621, 1000000
%625 = sext i32 %624 to i64
%626 = tail call i32 (i8*, i64, i64, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.3, i64 0, i64 0), i64 %623, i64 %625)
%627 = tail call i32 (i8*, i64, i64, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.4, i64 0, i64 0), i64 %363, i64 %607, i64 %609)
%628 = tail call i32 @munmap(i8* %87, i32 %72)
br label %629
629: ; preds = %606, %89
%630 = phi i32 [ 1, %89 ], [ 0, %606 ]
%631 = tail call i32 @munmap(i8* %81, i32 %38)
br label %632
632: ; preds = %629, %83
%633 = phi i32 [ 1, %83 ], [ %630, %629 ]
%634 = tail call i32 @munmap(i8* %75, i32 %26)
br label %635
635: ; preds = %632, %77
%636 = phi i32 [ 1, %77 ], [ %633, %632 ]
%637 = tail call i32 @close(i32 %65)
br label %638
638: ; preds = %635, %67
%639 = phi i32 [ 1, %67 ], [ %636, %635 ]
%640 = tail call i32 @close(i32 %54)
br label %641
641: ; preds = %638, %56
%642 = phi i32 [ 1, %56 ], [ %639, %638 ]
%643 = tail call i32 @close(i32 %44)
br label %644
644: ; preds = %641, %46, %32, %20, %11
%645 = phi i32 [ 1, %11 ], [ 1, %20 ], [ 1, %32 ], [ 1, %46 ], [ %642, %641 ]
ret i32 %645
}