#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;
};
struct stat {
  int st_size;
};

/* Variables and functions */
int /*<<< orphan*/ MAP_SHARED;
int O_CREAT;
int O_RDWR;
int O_TRUNC;
int PROT_READ;
int PROT_WRITE;
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ fstat(int, struct stat *);
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 *, int, int, ...);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ write(int, int /*<<< orphan*/ *, int /*<<< orphan*/);
int main(int argc, char *argv[]) {
  int ret = 1;
  int 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;
  int currentFile;
  int flag = PROT_WRITE | PROT_READ;
  char *head, *tail, *index;
  int filesize1, filesize2;
  struct stat tempbuf1, tempbuf2;
  if (argc != 4) {
    fprintf(stderr, "usage: %s file1 file2 fout\n", argv[0]);
    goto leave0;
  }
  if ((fd1 = open(argv[1], O_RDWR)) < 0) {
    perror(argv[1]);
    goto leave0;
  }
  if ((fd2 = open(argv[2], O_RDWR)) < 0) {
    perror(argv[2]);
    goto leave1;
  }
  fstat(fd1, &tempbuf1);
  fstat(fd2, &tempbuf2);
  filesize1 = tempbuf1.st_size;
  filesize2 = tempbuf2.st_size;
  printf("size1 : %d, size2 : %d", filesize1, filesize2);
  if ((fdout = open(argv[3], O_RDWR | O_CREAT | O_TRUNC, 0644)) < 0) {
    perror(argv[3]);
    goto leave2;
  }
  write(fdout, NULL, 0);
  ftruncate(fdout, filesize1 + filesize2);
  if ((file1 = mmap(0, filesize1, flag, MAP_SHARED, fd1, 0)) == NULL) {
    perror("mmap error");
    goto leave3;
  }
  if ((file2 = mmap(0, filesize2, flag, MAP_SHARED, fd2, 0)) == NULL) {
    perror("mmap error");
    goto leave4;
  }
  if ((fileout = mmap(0, filesize1 + filesize2, flag, MAP_SHARED, fdout, 0)) ==
      NULL) {
    perror("mmap error");
    goto leave5;
  }
  gettimeofday(&before, NULL);
  pfile1 = file1;
  pfile2 = file2;
  pfileout = fileout;
  rsize1 = filesize1;
  rsize2 = filesize2;
  currentFile = 1;
  head = pfile1;
  while (rsize1 && rsize2) {
    if (currentFile == 1) {
      rsize1--;
      if ((*pfile1++) == '\n') {
        line1++;
        currentFile = 2;
        tail = pfile1;
        index = --tail;
        while (1) {
          *pfileout++ = *(--index);
          if (index == head) {
            *pfileout++ = *tail;
            head = pfile2;
            break;
          }
        }
      }
    } else if (currentFile == 2) {
      rsize2--;
      if ((*pfile2++) == '\n') {
        line2++;
        currentFile = 1;
        tail = pfile2;
        index = --tail;
        while (1) {
          *pfileout++ = *(--index);
          if (index == head) {
            *pfileout++ = *tail;
            head = pfile1;
            break;
          }
        }
      }
    }
  }
  while (rsize1) {
    rsize1--;
    if ((*pfile1++) == '\n') {
      line1++;
      tail = pfile1;
      index = --tail;
      while (1) {
        *pfileout++ = *(--index);
        if (index == head) {
          *pfileout++ = *tail;
          head = pfile1;
          break;
        }
      }
    }
  }
  while (rsize2) {
    rsize2--;
    if ((*pfile2++) == '\n') {
      line2++;
      tail = pfile2;
      index = --tail;
      while (1) {
        *pfileout++ = *(--index);
        if (index == head) {
          *pfileout++ = *tail;
          head = 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 = %d, File2= %d, Total = %d Lines\n", line1, line2, lineout);
  ret = 0;
leave6:
  munmap(fileout, filesize1 + filesize2);
leave5:
  munmap(file2, filesize2);
leave4:
  munmap(file1, filesize1);
leave3:
  close(fdout);
leave2:
  close(fd2);
leave1:
  close(fd1);
leave0:
  return ret;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x1,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    0x2dc4(%rip),%rax
mov    (%rax),%eax
mov    0x2df3(%rip),%rcx
or     (%rcx),%eax
mov    %eax,-0x90(%rbp)
cmpl   $0x4,-0x8(%rbp)
je     1228 <main+0x78>
mov    0x2daa(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xde2(%rip),%rsi
call   1090 <fprintf@plt>
jmp    18f8 <main+0x748>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2d91(%rip),%rax
mov    (%rax),%esi
mov    $0x0,%al
call   10b0 <open@plt>
mov    %eax,-0x38(%rbp)
cmp    $0x0,%eax
jge    125e <main+0xae>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   10c0 <perror@plt>
jmp    18f8 <main+0x748>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
mov    0x2d5b(%rip),%rax
mov    (%rax),%esi
mov    $0x0,%al
call   10b0 <open@plt>
mov    %eax,-0x3c(%rbp)
cmp    $0x0,%eax
jge    1294 <main+0xe4>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   10c0 <perror@plt>
jmp    18f0 <main+0x740>
mov    -0x38(%rbp),%edi
lea    -0xb8(%rbp),%rsi
call   10d0 <fstat@plt>
mov    -0x3c(%rbp),%edi
lea    -0xc0(%rbp),%rsi
call   10d0 <fstat@plt>
mov    -0xb8(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xc0(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0xac(%rbp),%esi
mov    -0xb0(%rbp),%edx
lea    0xd3f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
mov    0x2cd5(%rip),%rax
mov    (%rax),%esi
mov    0x2cfc(%rip),%rax
or     (%rax),%esi
mov    0x2ceb(%rip),%rax
or     (%rax),%esi
mov    $0x1a4,%edx
mov    $0x0,%al
call   10b0 <open@plt>
mov    %eax,-0x40(%rbp)
cmp    $0x0,%eax
jge    1331 <main+0x181>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rdi
call   10c0 <perror@plt>
jmp    18e8 <main+0x738>
mov    -0x40(%rbp),%edi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1030 <write@plt>
mov    -0x40(%rbp),%edi
mov    -0xac(%rbp),%esi
add    -0xb0(%rbp),%esi
call   1060 <ftruncate@plt>
mov    -0xac(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    0x2c72(%rip),%rax
mov    (%rax),%ecx
mov    -0x38(%rbp),%r8d
xor    %r9d,%r9d
mov    %r9d,%edi
call   1040 <mmap@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
jne    1396 <main+0x1e6>
lea    0xca7(%rip),%rdi
call   10c0 <perror@plt>
jmp    18e0 <main+0x730>
mov    -0xb0(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    0x2c2f(%rip),%rax
mov    (%rax),%ecx
mov    -0x3c(%rbp),%r8d
xor    %r9d,%r9d
mov    %r9d,%edi
call   1040 <mmap@plt>
mov    %rax,-0x50(%rbp)
cmp    $0x0,%rax
jne    13d9 <main+0x229>
lea    0xc64(%rip),%rdi
call   10c0 <perror@plt>
jmp    18d1 <main+0x721>
mov    -0xac(%rbp),%esi
add    -0xb0(%rbp),%esi
mov    -0x90(%rbp),%edx
mov    0x2be6(%rip),%rax
mov    (%rax),%ecx
mov    -0x40(%rbp),%r8d
xor    %r9d,%r9d
mov    %r9d,%edi
call   1040 <mmap@plt>
mov    %rax,-0x58(%rbp)
cmp    $0x0,%rax
jne    1422 <main+0x272>
lea    0xc1b(%rip),%rdi
call   10c0 <perror@plt>
jmp    18c2 <main+0x712>
lea    -0x28(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1070 <gettimeofday@plt>
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0xb0(%rbp),%eax
mov    %eax,-0x88(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x98(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x84(%rbp)
mov    %al,-0xc1(%rbp)
je     1499 <main+0x2e9>
cmpl   $0x0,-0x88(%rbp)
setne  %al
mov    %al,-0xc1(%rbp)
mov    -0xc1(%rbp),%al
test   $0x1,%al
jne    14ac <main+0x2fc>
jmp    167e <main+0x4ce>
cmpl   $0x1,-0x8c(%rbp)
jne    1590 <main+0x3e0>
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x68(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    158b <main+0x3db>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x2,-0x8c(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xa0(%rbp)
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xa8(%rbp)
mov    -0x1(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0xa8(%rbp),%rax
cmp    -0x98(%rbp),%rax
jne    1581 <main+0x3d1>
mov    -0xa0(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0x70(%rbp),%rax
mov    %rax,-0x98(%rbp)
jmp    1586 <main+0x3d6>
jmp    151a <main+0x36a>
jmp    158b <main+0x3db>
jmp    1679 <main+0x4c9>
cmpl   $0x2,-0x8c(%rbp)
jne    1674 <main+0x4c4>
mov    -0x88(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x70(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    166f <main+0x4bf>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xa0(%rbp)
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xa8(%rbp)
mov    -0x1(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0xa8(%rbp),%rax
cmp    -0x98(%rbp),%rax
jne    1665 <main+0x4b5>
mov    -0xa0(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,-0x98(%rbp)
jmp    166a <main+0x4ba>
jmp    15fe <main+0x44e>
jmp    166f <main+0x4bf>
jmp    1674 <main+0x4c4>
jmp    1679 <main+0x4c9>
jmp    1474 <main+0x2c4>
jmp    1683 <main+0x4d3>
cmpl   $0x0,-0x84(%rbp)
je     175d <main+0x5ad>
mov    -0x84(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x68(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1758 <main+0x5a8>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xa0(%rbp)
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xa8(%rbp)
mov    -0x1(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0xa8(%rbp),%rax
cmp    -0x98(%rbp),%rax
jne    174e <main+0x59e>
mov    -0xa0(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0x68(%rbp),%rax
mov    %rax,-0x98(%rbp)
jmp    1753 <main+0x5a3>
jmp    16e7 <main+0x537>
jmp    1758 <main+0x5a8>
jmp    1683 <main+0x4d3>
jmp    1762 <main+0x5b2>
cmpl   $0x0,-0x88(%rbp)
je     183c <main+0x68c>
mov    -0x88(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x70(%rbp)
movsbl (%rax),%eax
cmp    $0xa,%eax
jne    1837 <main+0x687>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0xa0(%rbp)
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0xa8(%rbp)
mov    -0x1(%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0xa8(%rbp),%rax
cmp    -0x98(%rbp),%rax
jne    182d <main+0x67d>
mov    -0xa0(%rbp),%rax
mov    (%rax),%cl
mov    -0x78(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x78(%rbp)
mov    %cl,(%rax)
mov    -0x70(%rbp),%rax
mov    %rax,-0x98(%rbp)
jmp    1832 <main+0x682>
jmp    17c6 <main+0x616>
jmp    1837 <main+0x687>
jmp    1762 <main+0x5b2>
lea    -0x30(%rbp),%rdi
xor    %eax,%eax
mov    %eax,%esi
call   1070 <gettimeofday@plt>
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x30(%rbp),%eax
sub    -0x28(%rbp),%eax
imul   $0xf4240,%eax,%eax
mov    -0x2c(%rbp),%ecx
sub    -0x24(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x34(%rbp),%eax
mov    $0xf4240,%ecx
cltd
idiv   %ecx
lea    0x7b6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x18(%rbp),%esi
mov    -0x1c(%rbp),%edx
mov    -0x20(%rbp),%ecx
lea    0x7be(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x58(%rbp),%rdi
mov    -0xac(%rbp),%esi
add    -0xb0(%rbp),%esi
call   10a0 <munmap@plt>
mov    -0x50(%rbp),%rdi
mov    -0xb0(%rbp),%esi
call   10a0 <munmap@plt>
mov    -0x48(%rbp),%rdi
mov    -0xac(%rbp),%esi
call   10a0 <munmap@plt>
mov    -0x40(%rbp),%edi
call   1080 <close@plt>
mov    -0x3c(%rbp),%edi
call   1080 <close@plt>
mov    -0x38(%rbp),%edi
call   1080 <close@plt>
mov    -0x14(%rbp),%eax
add    $0xd0,%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    173d <main+0x58d>
mov    0x2ddf(%rip),%rax
mov    0x2e10(%rip),%rcx
mov    (%rcx),%r12d
or     (%rax),%r12d
mov    0x8(%rbp),%rdi
mov    0x2ddf(%rip),%r14
mov    (%r14),%esi
xor    %eax,%eax
call   10b0 <open@plt>
test   %eax,%eax
js     1c69 <main+0xab9>
mov    %eax,0x10(%rsp)
mov    0x10(%rbp),%rdi
mov    (%r14),%esi
xor    %eax,%eax
call   10b0 <open@plt>
test   %eax,%eax
js     1c79 <main+0xac9>
lea    0x40(%rsp),%rsi
mov    0x10(%rsp),%r15d
mov    %eax,%ebx
mov    %r15d,%edi
call   10d0 <fstat@plt>
lea    0x38(%rsp),%rsi
mov    %ebx,0x4(%rsp)
mov    %ebx,%edi
call   10d0 <fstat@plt>
mov    0x40(%rsp),%ebx
mov    0x38(%rsp),%r13d
lea    0xdd3(%rip),%rdi
mov    %ebx,%esi
mov    %r13d,%edx
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x2d9c(%rip),%rax
mov    (%rax),%esi
or     (%r14),%esi
mov    0x18(%rbp),%rdi
mov    0x2d84(%rip),%rax
or     (%rax),%esi
mov    $0x1a4,%edx
xor    %eax,%eax
call   10b0 <open@plt>
test   %eax,%eax
js     1c89 <main+0xad9>
mov    %eax,%ebp
mov    %eax,%edi
xor    %esi,%esi
xor    %edx,%edx
call   1030 <write@plt>
lea    (%rbx,%r13,1),%esi
mov    %ebp,0xc(%rsp)
mov    %ebp,%edi
mov    %esi,0x8(%rsp)
call   1060 <ftruncate@plt>
mov    0x2d2f(%rip),%rbp
mov    0x0(%rbp),%ecx
xor    %edi,%edi
mov    %rbx,0x50(%rsp)
mov    %ebx,%esi
mov    %r12d,%edx
mov    %r15d,%r8d
xor    %r9d,%r9d
call   1040 <mmap@plt>
mov    %rax,0x20(%rsp)
test   %rax,%rax
je     1c99 <main+0xae9>
mov    0x0(%rbp),%ecx
xor    %edi,%edi
mov    %r13,0x30(%rsp)
mov    %r13d,%esi
mov    %r12d,%edx
mov    0x4(%rsp),%r8d
xor    %r9d,%r9d
call   1040 <mmap@plt>
mov    %rax,0x18(%rsp)
test   %rax,%rax
je     1cac <main+0xafc>
mov    0x0(%rbp),%ecx
xor    %edi,%edi
mov    0x8(%rsp),%esi
mov    %r12d,%edx
mov    0xc(%rsp),%r8d
xor    %r9d,%r9d
call   1040 <mmap@plt>
test   %rax,%rax
je     1cc2 <main+0xb12>
mov    %rax,%rbx
lea    0x68(%rsp),%rdi
xor    %esi,%esi
call   1070 <gettimeofday@plt>
mov    0x50(%rsp),%rax
test   %eax,%eax
mov    %rbx,0x48(%rsp)
je     1760 <main+0x5b0>
mov    0x20(%rsp),%rsi
mov    %rsi,%rbp
mov    0x18(%rsp),%r11
mov    %rbx,%rdx
mov    %eax,%r14d
mov    0x30(%rsp),%rcx
mov    %ecx,%r8d
mov    $0x0,%r9d
test   %ecx,%ecx
mov    $0x0,%r12d
je     1781 <main+0x5d1>
mov    $0x1,%edi
xor    %r9d,%r9d
pxor   %xmm0,%xmm0
mov    0x20(%rsp),%rbp
mov    %rbp,%rsi
xor    %r12d,%r12d
mov    %ecx,%r8d
mov    %eax,%r14d
mov    0x48(%rsp),%rdx
mov    0x18(%rsp),%r11
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x1,%edi
jne    1420 <main+0x270>
add    $0xffffffff,%r14d
lea    0x1(%rbp),%r10
mov    $0x1,%edi
cmpb   $0xa,0x0(%rbp)
jne    14a0 <main+0x2f0>
mov    %rbp,%rdi
sub    %rsi,%rdi
cmp    $0x20,%rdi
jb     13de <main+0x22e>
cmp    %rbp,%rdx
jae    1583 <main+0x3d3>
lea    (%rdx,%rdi,1),%rax
cmp    %rax,%rsi
jae    1583 <main+0x3d3>
mov    %rbp,%rax
mov    %eax,%ecx
sub    %esi,%ecx
mov    %rsi,%rdi
not    %rdi
add    %rax,%rdi
and    $0x7,%rcx
je     14bb <main+0x30b>
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rax),%ebx
add    $0xffffffffffffffff,%rax
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1400 <main+0x250>
lea    -0x1(%rdx),%rbx
jmp    14bb <main+0x30b>
nopl   (%rax)
mov    %r14d,%r13d
add    $0xffffffff,%r8d
lea    0x1(%r11),%r14
mov    $0x2,%edi
cmpb   $0xa,(%r11)
jne    14b0 <main+0x300>
mov    %r11,%rdi
sub    %rsi,%rdi
cmp    $0x20,%rdi
jb     1458 <main+0x2a8>
cmp    %r11,%rdx
jae    1644 <main+0x494>
lea    (%rdx,%rdi,1),%rax
cmp    %rax,%rsi
jae    1644 <main+0x494>
mov    %r11,%rcx
mov    %ecx,%eax
sub    %esi,%eax
mov    %rsi,%rdi
not    %rdi
add    %rcx,%rdi
and    $0x7,%rax
je     1523 <main+0x373>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x1(%rcx),%ebx
add    $0xffffffffffffffff,%rcx
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    1480 <main+0x2d0>
lea    -0x1(%rdx),%rbx
jmp    1523 <main+0x373>
nopl   (%rax)
mov    %r10,%rbp
jmp    1717 <main+0x567>
nopl   0x0(%rax,%rax,1)
mov    %r14,%r11
mov    %r13d,%r14d
jmp    1717 <main+0x567>
mov    %rdx,%r15
cmp    $0x7,%rdi
jb     1630 <main+0x480>
nopl   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    14d0 <main+0x320>
mov    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
mov    %rdx,%r15
jmp    1630 <main+0x480>
mov    %rdx,%r15
cmp    $0x7,%rdi
jb     16f0 <main+0x540>
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    1530 <main+0x380>
mov    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
mov    %rdx,%r15
jmp    16f0 <main+0x540>
mov    %rdi,%rbx
and    $0xffffffffffffffe0,%rbx
lea    (%rdx,%rbx,1),%r15
mov    %rbp,%rax
sub    %rbx,%rax
mov    %rbp,%r13
lea    -0x10(%rbp),%rcx
xor    %ebp,%ebp
nopl   (%rax)
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    15a0 <main+0x3f0>
cmp    %rbx,%rdi
jne    1727 <main+0x577>
add    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
mov    %r13,%rbp
add    $0x1,%r9d
mov    $0x2,%edi
mov    %rbp,%rax
mov    %r11,%rbp
jmp    1705 <main+0x555>
mov    %rbp,%r10
mov    %rdi,%rbx
and    $0xffffffffffffffe0,%rbx
lea    (%rdx,%rbx,1),%r15
mov    %r11,%rcx
sub    %rbx,%rcx
lea    -0x10(%r11),%rax
xor    %ebp,%ebp
xchg   %ax,%ax
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    1660 <main+0x4b0>
cmp    %rbx,%rdi
jne    1732 <main+0x582>
add    %rdx,%rbx
add    $0xffffffffffffffff,%rbx
mov    %r10,%rbp
nopl   0x0(%rax)
add    $0x1,%r12d
mov    $0x1,%edi
mov    %r11,%rax
mov    %rbp,%r10
mov    %r14,%r11
mov    %r13d,%r14d
mov    %rbp,%rsi
mov    (%rax),%al
add    $0x2,%rbx
mov    %al,(%r15)
mov    %r10,%rbp
mov    %rbx,%rdx
test   %r14d,%r14d
je     1781 <main+0x5d1>
test   %r8d,%r8d
jne    13a0 <main+0x1f0>
jmp    1781 <main+0x5d1>
mov    %r15,%rdx
mov    %r13,%rbp
jmp    13e1 <main+0x231>
mov    %r15,%rdx
mov    %r10,%rbp
jmp    145b <main+0x2ab>
mov    0x2874(%rip),%rax
mov    (%rax),%edi
mov    0x0(%rbp),%rdx
lea    0x8af(%rip),%rsi
call   1090 <fprintf@plt>
mov    $0x1,%ebx
jmp    1c58 <main+0xaa8>
mov    0x20(%rsp),%rsi
mov    %rsi,%rbp
mov    0x18(%rsp),%r11
mov    %rbx,%rdx
mov    %eax,%r14d
mov    0x30(%rsp),%rax
mov    %eax,%r8d
xor    %r9d,%r9d
xor    %r12d,%r12d
mov    %r11,0x58(%rsp)
mov    %r8d,0x44(%rsp)
test   %r14d,%r14d
je     19a4 <main+0x7f4>
xor    %r11d,%r11d
pxor   %xmm0,%xmm0
mov    %rbp,%r10
mov    %rbp,%rax
mov    %rbp,0x70(%rsp)
jmp    17e9 <main+0x639>
lea    (%r14,%rdx,1),%rdi
add    $0xffffffffffffffff,%rdi
mov    %rbx,%r12
mov    0x28(%rsp),%r9
mov    0x14(%rsp),%r14d
nopl   (%rax)
add    $0x1,%r9d
mov    0x0(%rbp),%al
add    $0x2,%rdi
mov    %al,0x0(%r13)
mov    %rdi,%rdx
mov    %r8,%rsi
add    $0x1,%r11
add    $0x1,%r10
mov    %r8,%rbp
test   %r14d,%r14d
je     19a4 <main+0x7f4>
add    $0xffffffff,%r14d
lea    0x1(%rbp),%r8
cmpb   $0xa,0x0(%rbp)
jne    17d5 <main+0x625>
mov    %r12,%rbx
mov    0x70(%rsp),%rax
lea    (%r11,%rax,1),%r12
sub    %rsi,%r12
cmp    $0x20,%r12
jb     1822 <main+0x672>
cmp    %rbp,%rdx
jae    18c3 <main+0x713>
lea    (%rdx,%r12,1),%rax
cmp    %rax,%rsi
jae    18c3 <main+0x713>
mov    %rbp,%rax
mov    %rbx,%r12
mov    %eax,%edi
sub    %esi,%edi
mov    %rsi,%rcx
not    %rcx
add    %rax,%rcx
and    $0x7,%rdi
je     185a <main+0x6aa>
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rax),%ebx
add    $0xffffffffffffffff,%rax
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1840 <main+0x690>
lea    -0x1(%rdx),%rdi
jmp    185a <main+0x6aa>
mov    %rdx,%r13
cmp    $0x7,%rcx
jb     17c0 <main+0x610>
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    1870 <main+0x6c0>
mov    %rdx,%rdi
add    $0xffffffffffffffff,%rdi
mov    %rdx,%r13
jmp    17c0 <main+0x610>
mov    %r14d,0x14(%rsp)
mov    %r9,0x28(%rsp)
mov    %r12,%r14
and    $0xffffffffffffffe0,%r14
lea    (%rdx,%r14,1),%r13
mov    %rbp,%rax
sub    %r14,%rax
lea    0x10(%rdx),%r15
mov    %r10,%rcx
sub    %rsi,%rcx
and    $0xffffffffffffffe0,%rcx
neg    %rcx
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%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(%r15)
movdqu %xmm1,(%r15)
add    $0xffffffffffffffe0,%r9
add    $0x20,%r15
cmp    %r9,%rcx
jne    1900 <main+0x750>
cmp    %r14,%r12
je     17a8 <main+0x5f8>
mov    %r13,%rdx
mov    %rbx,%r12
mov    0x28(%rsp),%r9
mov    0x14(%rsp),%r14d
jmp    1828 <main+0x678>
mov    0x44(%rsp),%r13d
test   %r13d,%r13d
mov    %r9,0x28(%rsp)
je     1b9f <main+0x9ef>
xor    %r8d,%r8d
pxor   %xmm0,%xmm0
mov    0x58(%rsp),%rax
mov    %rax,%r15
mov    %rax,%rbp
jmp    1a0d <main+0x85d>
lea    (%r14,%rdx,1),%rdi
add    $0xffffffffffffffff,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12d
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,%r15
mov    %r10,%rbp
test   %r13d,%r13d
je     1b9f <main+0x9ef>
add    $0xffffffff,%r13d
lea    0x1(%rbp),%r10
cmpb   $0xa,0x0(%rbp)
jne    19f9 <main+0x849>
lea    (%r8,%rax,1),%r9
sub    %rsi,%r9
cmp    $0x20,%r9
jb     1a3e <main+0x88e>
cmp    %rbp,%rdx
jae    1ae3 <main+0x933>
lea    (%rdx,%r9,1),%rax
cmp    %rax,%rsi
jae    1ae3 <main+0x933>
mov    %rbp,%rax
mov    %eax,%edi
sub    %esi,%edi
mov    %rsi,%rcx
not    %rcx
add    %rax,%rcx
and    $0x7,%rdi
je     1a7a <main+0x8ca>
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    1a60 <main+0x8b0>
lea    -0x1(%rdx),%rdi
jmp    1a7a <main+0x8ca>
mov    %rdx,%r11
cmp    $0x7,%rcx
jb     19e0 <main+0x830>
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    1a90 <main+0x8e0>
mov    %rdx,%rdi
add    $0xffffffffffffffff,%rdi
mov    %rdx,%r11
jmp    19e0 <main+0x830>
mov    %r9,%r14
and    $0xffffffffffffffe0,%r14
lea    (%rdx,%r14,1),%r11
mov    %rbp,%rax
sub    %r14,%rax
lea    0x10(%rdx),%rdi
mov    %r15,%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    1b10 <main+0x960>
cmp    %r14,%r9
je     19cb <main+0x81b>
mov    %r11,%rdx
jmp    1a41 <main+0x891>
xor    %ebx,%ebx
lea    0x60(%rsp),%rdi
xor    %esi,%esi
call   1070 <gettimeofday@plt>
mov    0x28(%rsp),%rbp
lea    (%r12,%rbp,1),%r14d
mov    0x60(%rsp),%eax
sub    0x68(%rsp),%eax
mov    0x64(%rsp),%ecx
imul   $0xf4240,%eax,%eax
sub    0x6c(%rsp),%ecx
add    %eax,%ecx
movslq %ecx,%rdx
imul   $0x431bde83,%rdx,%rsi
mov    %rsi,%rax
shr    $0x3f,%rax
sar    $0x32,%rsi
add    %eax,%esi
imul   $0xf4240,%esi,%eax
sub    %eax,%edx
lea    0x44a(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0x45b(%rip),%rdi
mov    %ebp,%esi
mov    %r12d,%edx
mov    %r14d,%ecx
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x48(%rsp),%rdi
mov    0x8(%rsp),%esi
call   10a0 <munmap@plt>
mov    0x18(%rsp),%rdi
mov    0x30(%rsp),%rsi
call   10a0 <munmap@plt>
mov    0x20(%rsp),%rdi
mov    0x50(%rsp),%rsi
call   10a0 <munmap@plt>
mov    0xc(%rsp),%edi
call   1080 <close@plt>
mov    0x4(%rsp),%edi
call   1080 <close@plt>
mov    0x10(%rsp),%edi
call   1080 <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
call   10c0 <perror@plt>
mov    $0x1,%ebx
jmp    1c58 <main+0xaa8>
mov    0x10(%rbp),%rdi
call   10c0 <perror@plt>
mov    $0x1,%ebx
jmp    1c4f <main+0xa9f>
mov    0x18(%rbp),%rdi
call   10c0 <perror@plt>
mov    $0x1,%ebx
jmp    1c46 <main+0xa96>
lea    0x393(%rip),%rdi
call   10c0 <perror@plt>
mov    $0x1,%ebx
jmp    1c3d <main+0xa8d>
lea    0x380(%rip),%rdi
call   10c0 <perror@plt>
mov    $0x1,%ebx
jmp    1c2e <main+0xa7e>
lea    0x36a(%rip),%rdi
call   10c0 <perror@plt>
mov    $0x1,%ebx
jmp    1c1f <main+0xa6f>

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

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