#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 stat {
  unsigned long st_size;
  scalar_t__ st_ino;
};

/* Variables and functions */
int O_CREAT;
int O_RDWR;
int O_TRUNC;
int /*<<< orphan*/ SEEK_SET;
int /*<<< orphan*/ close(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ free(char *);
int fstat(int, struct stat *);
int lseek(int, unsigned long, int /*<<< orphan*/);
char *malloc(unsigned long);
int /*<<< orphan*/ memcpy(char *, char *, unsigned long);
int open(char *, int, int);
int /*<<< orphan*/ perror(char *);
int /*<<< orphan*/ printf(char *, ...);
int read(int, char *, unsigned long);
int /*<<< orphan*/ sleep(int);
int /*<<< orphan*/ stderr;
scalar_t__ strcmp(char *, char *);
unsigned long strtoul(char *, int /*<<< orphan*/ *, int);
int write(int, char *, unsigned long);
int main(int argc, char **argv) {
  int fd, i, rc = 0;
  unsigned long bytes, lbytes;
  struct stat st;
  char *str, *str2, *readbuf;
  if (argc != 3) {
    fprintf(stderr, "usage: %s <filename> <bytes>\n", argv[0]);
    do {
      rc = 1;
      goto out;
    } while (0);
  }
  bytes = strtoul(argv[2], NULL, 10);
  if (!bytes) {
    printf("No bytes!\n");
    do {
      rc = 2;
      goto out;
    } while (0);
  }
  if (bytes % 2) {
    printf("Need an even number of bytes!\n");
    do {
      rc = 3;
      goto out;
    } while (0);
  }
  lbytes = 3 * bytes / 2;
  str = malloc(bytes + 1);
  if (!str) {
    printf("No enough memory for %lu bytes.\n", bytes);
    do {
      rc = 4;
      goto out;
    } while (0);
  }
  str2 = malloc(lbytes + 1);
  if (!str2) {
    printf("No enough memory for %lu bytes.\n", lbytes);
    do {
      rc = 5;
      goto out_str;
    } while (0);
  }
  readbuf = malloc(bytes * 2);
  if (!readbuf) {
    printf("No enough memory for %lu bytes.\n", bytes * 2);
    do {
      rc = 6;
      goto out_str2;
    } while (0);
  }
  for (i = 0; i < bytes; i++)
    str[i] = 'a' + (i % 26);
  str[i] = '\0';
  memcpy(str2, str, bytes);
  memcpy(str2 + (bytes / 2), str, bytes);
  str2[lbytes] = '\0';
  if (bytes < 320)
    printf("First  String: %s\nSecond String: %s\n", str, str2);
  fd = open(argv[1], O_CREAT | O_RDWR | O_TRUNC, 0700);
  if (fd == -1) {
    printf("Could not open file %s.\n", argv[1]);
    do {
      rc = 7;
      goto out_readbuf;
    } while (0);
  }
  rc = write(fd, str, bytes);
  if (rc != bytes) {
    printf("Write failed!\n");
    do {
      rc = 8;
      goto out_fd;
    } while (0);
  }
  sleep(1);
  rc = fstat(fd, &st);
  if (rc < 0 || st.st_size != bytes) {
    printf("bad file %lu size first write %lu != %lu: rc %d\n",
           (unsigned long)st.st_ino, (unsigned long)st.st_size, bytes, rc);
    do {
      rc = 9;
      goto out_fd;
    } while (0);
  }
  rc = lseek(fd, bytes / 2, SEEK_SET);
  if (rc != bytes / 2) {
    printf("Seek failed!\n");
    do {
      rc = 10;
      goto out_fd;
    } while (0);
  }
  rc = write(fd, str, bytes);
  if (rc != bytes) {
    printf("Write failed!\n");
    do {
      rc = 11;
      goto out_fd;
    } while (0);
  }
  rc = fstat(fd, &st);
  if (rc < 0 || st.st_size != bytes + bytes / 2) {
    printf("bad file %lu size second write %lu != %lu: rc %d\n",
           (unsigned long)st.st_ino, (unsigned long)st.st_size, bytes, rc);
    do {
      rc = 12;
      goto out_fd;
    } while (0);
  }
  rc = lseek(fd, 0, SEEK_SET);
  if (rc != 0) {
    printf("Seek failed!\n");
    do {
      rc = 13;
      goto out_fd;
    } while (0);
  }
  rc = read(fd, readbuf, bytes * 2);
  if (rc != lbytes) {
    printf("Read %d bytes instead of %lu.\n", rc, lbytes);
    if (rc == -1)
      perror("");
    else
      printf("%s\n%s\n", readbuf, str2);
    rc = fstat(fd, &st);
    if (rc < 0 || st.st_size != bytes + bytes / 2) {
      printf("bad file size after read %lu != %lu: rc %d\n",
             (unsigned long)st.st_size, bytes + bytes / 2, rc);
      do {
        rc = 14;
        goto out_fd;
      } while (0);
    }
    do {
      rc = 15;
      goto out_fd;
    } while (0);
  }
  rc = 0;
  if (bytes < 320)
    printf("%s\n%s\n", readbuf, str2);
  if (strcmp(readbuf, str2)) {
    printf("No match!\n");
    do {
      rc = 16;
      goto out_fd;
    } while (0);
  }
  printf("Pass!\n");
out_fd:
  close(fd);
out_readbuf:
  free(readbuf);
out_str2:
  free(str2);
out_str:
  free(str);
out:
  return rc;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x8(%rbp)
je     123f <main+0x4f>
mov    0x2daa(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xdd2(%rip),%rsi
call   10a0 <fprintf@plt>
movl   $0x1,-0x1c(%rbp)
jmp    178f <main+0x59f>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
mov    $0xa,%edx
call   10f0 <strtoul@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    127e <main+0x8e>
lea    0xdb3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x2,-0x1c(%rbp)
jmp    178f <main+0x59f>
mov    -0x28(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     12aa <main+0xba>
lea    0xd92(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x3,-0x1c(%rbp)
jmp    178f <main+0x59f>
imul   $0x3,-0x28(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rdi
add    $0x1,%rdi
call   10c0 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    12f1 <main+0x101>
mov    -0x28(%rbp),%rsi
lea    0xd6a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x4,-0x1c(%rbp)
jmp    178f <main+0x59f>
mov    -0x30(%rbp),%rdi
add    $0x1,%rdi
call   10c0 <malloc@plt>
mov    %rax,-0x50(%rbp)
cmpq   $0x0,-0x50(%rbp)
jne    132b <main+0x13b>
mov    -0x30(%rbp),%rsi
lea    0xd30(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x5,-0x1c(%rbp)
jmp    1786 <main+0x596>
mov    -0x28(%rbp),%rdi
shl    $0x1,%rdi
call   10c0 <malloc@plt>
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
jne    1369 <main+0x179>
mov    -0x28(%rbp),%rsi
shl    $0x1,%rsi
lea    0xcf2(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x6,-0x1c(%rbp)
jmp    177d <main+0x58d>
movl   $0x0,-0x18(%rbp)
movslq -0x18(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    13a5 <main+0x1b5>
mov    -0x18(%rbp),%eax
mov    $0x1a,%ecx
cltd
idiv   %ecx
add    $0x61,%edx
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1370 <main+0x180>
mov    -0x48(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   10b0 <memcpy@plt>
mov    -0x50(%rbp),%rdi
mov    -0x28(%rbp),%rax
shr    $0x1,%rax
add    %rax,%rdi
mov    -0x48(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   10b0 <memcpy@plt>
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
cmpq   $0x140,-0x28(%rbp)
jae    140e <main+0x21e>
mov    -0x48(%rbp),%rsi
mov    -0x50(%rbp),%rdx
lea    0xc62(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
mov    0x2bdb(%rip),%rax
mov    (%rax),%esi
mov    0x2bb2(%rip),%rax
or     (%rax),%esi
mov    0x2bc1(%rip),%rax
or     (%rax),%esi
mov    $0x1c0,%edx
call   10d0 <open@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0xffffffff,-0x14(%rbp)
jne    146a <main+0x27a>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
lea    0xc37(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x7,-0x1c(%rbp)
jmp    1774 <main+0x584>
mov    -0x14(%rbp),%edi
mov    -0x48(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1040 <write@plt>
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
cmp    -0x28(%rbp),%rax
je     14a5 <main+0x2b5>
lea    0xc15(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x8,-0x1c(%rbp)
jmp    176c <main+0x57c>
mov    $0x1,%edi
call   1100 <sleep@plt>
mov    -0x14(%rbp),%edi
lea    -0x40(%rbp),%rsi
call   1110 <fstat@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     14d6 <main+0x2e6>
mov    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
je     1500 <main+0x310>
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
lea    0xbc9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x9,-0x1c(%rbp)
jmp    176c <main+0x57c>
mov    -0x14(%rbp),%edi
mov    -0x28(%rbp),%rsi
shr    $0x1,%rsi
mov    0x2aae(%rip),%rax
mov    (%rax),%edx
call   1060 <lseek@plt>
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0x1,%rcx
cmp    %rcx,%rax
je     154b <main+0x35b>
lea    0xbaf(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xa,-0x1c(%rbp)
jmp    176c <main+0x57c>
mov    -0x14(%rbp),%edi
mov    -0x48(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1040 <write@plt>
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
cmp    -0x28(%rbp),%rax
je     1586 <main+0x396>
lea    0xb34(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xb,-0x1c(%rbp)
jmp    176c <main+0x57c>
mov    -0x14(%rbp),%edi
lea    -0x40(%rbp),%rsi
call   1110 <fstat@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     15bb <main+0x3cb>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x28(%rbp),%rdx
shr    $0x1,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
je     15e5 <main+0x3f5>
mov    -0x38(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x1c(%rbp),%r8d
lea    0xb23(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xc,-0x1c(%rbp)
jmp    176c <main+0x57c>
mov    -0x14(%rbp),%edi
mov    0x29d1(%rip),%rax
mov    (%rax),%edx
xor    %eax,%eax
mov    %eax,%esi
call   1060 <lseek@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     1621 <main+0x431>
lea    0xad9(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xd,-0x1c(%rbp)
jmp    176c <main+0x57c>
mov    -0x14(%rbp),%edi
mov    -0x58(%rbp),%rsi
mov    -0x28(%rbp),%rdx
shl    $0x1,%rdx
call   1080 <read@plt>
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     1702 <main+0x512>
mov    -0x1c(%rbp),%esi
mov    -0x30(%rbp),%rdx
lea    0xad3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0xffffffff,-0x1c(%rbp)
jne    1676 <main+0x486>
lea    0xa49(%rip),%rdi
call   10e0 <perror@plt>
jmp    168c <main+0x49c>
mov    -0x58(%rbp),%rsi
mov    -0x50(%rbp),%rdx
lea    0xac1(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x14(%rbp),%edi
lea    -0x40(%rbp),%rsi
call   1110 <fstat@plt>
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     16c1 <main+0x4d1>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x28(%rbp),%rdx
shr    $0x1,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
je     16f1 <main+0x501>
mov    -0x40(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x28(%rbp),%rax
shr    $0x1,%rax
add    %rax,%rdx
mov    -0x1c(%rbp),%ecx
lea    0xa6f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xe,-0x1c(%rbp)
jmp    176c <main+0x57c>
jmp    16f6 <main+0x506>
movl   $0xf,-0x1c(%rbp)
jmp    176c <main+0x57c>
movl   $0x0,-0x1c(%rbp)
cmpq   $0x140,-0x28(%rbp)
jae    172d <main+0x53d>
mov    -0x58(%rbp),%rsi
mov    -0x50(%rbp),%rdx
lea    0xa20(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%rax
je     175e <main+0x56e>
lea    0xa2e(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x10,-0x1c(%rbp)
jmp    176c <main+0x57c>
lea    0xa1f(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x14(%rbp),%edi
call   1070 <close@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x1c(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rsi,%r15
cmp    $0x3,%edi
jne    12a7 <main+0xa7>
mov    0x10(%r15),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1100 <strtoul@plt>
test   %rax,%rax
je     12c9 <main+0xc9>
mov    %rax,%r14
test   $0x1,%r14b
jne    12df <main+0xdf>
lea    0x1(%r14),%rdi
call   10d0 <malloc@plt>
test   %rax,%rax
je     12f5 <main+0xf5>
mov    %rax,%r12
lea    (%r14,%r14,2),%r13
shr    %r13
lea    0x1(%r13),%rdi
call   10d0 <malloc@plt>
test   %rax,%rax
je     1310 <main+0x110>
mov    %rax,%rbp
lea    (%r14,%r14,1),%rbx
mov    %rbx,%rdi
call   10d0 <malloc@plt>
test   %rax,%rax
je     132b <main+0x12b>
mov    %rbp,0x8(%rsp)
cmp    $0x10,%r14
mov    %rax,0x10(%rsp)
mov    %rbx,0x30(%rsp)
jae    1346 <main+0x146>
xor    %r8d,%r8d
jmp    17f1 <main+0x5f1>
mov    0x2d1a(%rip),%rax
mov    (%rax),%edi
mov    (%r15),%rdx
lea    0xdd6(%rip),%rsi
call   10b0 <fprintf@plt>
mov    $0x1,%ebx
jmp    1a4d <main+0x84d>
lea    0xef2(%rip),%rdi
call   1040 <puts@plt>
mov    $0x2,%ebx
jmp    1a4d <main+0x84d>
lea    0xf11(%rip),%rdi
call   1040 <puts@plt>
mov    $0x3,%ebx
jmp    1a4d <main+0x84d>
lea    0xdb2(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x4,%ebx
jmp    1a4d <main+0x84d>
lea    0xd97(%rip),%rdi
mov    %r13,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x5,%ebx
jmp    1a45 <main+0x845>
lea    0xd7c(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x6,%ebx
jmp    1a3d <main+0x83d>
mov    %r14,%r8
and    $0xfffffffffffffff0,%r8
lea    -0x10(%r8),%rcx
mov    %rcx,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     167b <main+0x47b>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0xc8c(%rip),%xmm6
movdqa 0xc93(%rip),%xmm11
movdqa 0xc9a(%rip),%xmm12
movdqa 0xca1(%rip),%xmm13
xor    %ecx,%ecx
movdqa 0xca6(%rip),%xmm14
movdqa 0xcae(%rip),%xmm5
movdqa 0xcb5(%rip),%xmm8
movdqa 0xcbc(%rip),%xmm9
movdqa 0xcc3(%rip),%xmm10
nopl   (%rax)
movdqa %xmm11,%xmm0
pmuludq %xmm14,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm11,%xmm1
pmuludq %xmm14,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm0
psrld  $0x3,%xmm0
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm2
pmuludq %xmm5,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm2
movdqa %xmm11,%xmm0
psubd  %xmm2,%xmm0
movdqa %xmm6,%xmm1
pmuludq %xmm14,%xmm1
pshufd $0xed,%xmm1,%xmm1
pshufd $0xf5,%xmm6,%xmm2
pmuludq %xmm14,%xmm2
pshufd $0xed,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
psrld  $0x3,%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm5,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqa %xmm6,%xmm2
psubd  %xmm1,%xmm2
packuswb %xmm2,%xmm0
movdqa %xmm13,%xmm1
pmuludq %xmm14,%xmm1
pshufd $0xed,%xmm1,%xmm1
pshufd $0xf5,%xmm13,%xmm2
pmuludq %xmm14,%xmm2
pshufd $0xed,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
psrld  $0x3,%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm5,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqa %xmm13,%xmm2
psubd  %xmm1,%xmm2
movdqa %xmm12,%xmm1
pmuludq %xmm14,%xmm1
pshufd $0xed,%xmm1,%xmm1
pshufd $0xf5,%xmm12,%xmm3
pmuludq %xmm14,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
psrld  $0x3,%xmm1
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm5,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm5,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
movdqa %xmm12,%xmm3
psubd  %xmm1,%xmm3
packuswb %xmm3,%xmm2
packuswb %xmm0,%xmm2
paddb  %xmm8,%xmm2
movdqu %xmm2,(%r12,%rcx,1)
movdqa %xmm12,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm13,%xmm1
paddd  %xmm9,%xmm1
movdqa %xmm6,%xmm3
paddd  %xmm9,%xmm3
movdqa %xmm11,%xmm7
paddd  %xmm9,%xmm7
movdqa %xmm7,%xmm0
pmuludq %xmm14,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm7,%xmm4
pmuludq %xmm14,%xmm4
pshufd $0xed,%xmm4,%xmm4
punpckldq %xmm4,%xmm0
psrld  $0x3,%xmm0
pshufd $0xf5,%xmm0,%xmm4
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm5,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm0
psubd  %xmm0,%xmm7
movdqa %xmm3,%xmm0
pmuludq %xmm14,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm3,%xmm4
pmuludq %xmm14,%xmm4
pshufd $0xed,%xmm4,%xmm4
punpckldq %xmm4,%xmm0
psrld  $0x3,%xmm0
pshufd $0xf5,%xmm0,%xmm4
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm5,%xmm4
pshufd $0xe8,%xmm4,%xmm4
punpckldq %xmm4,%xmm0
psubd  %xmm0,%xmm3
packuswb %xmm3,%xmm7
movdqa %xmm1,%xmm0
pmuludq %xmm14,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm1,%xmm3
pmuludq %xmm14,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
psrld  $0x3,%xmm0
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm5,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
psubd  %xmm0,%xmm1
movdqa %xmm2,%xmm0
pmuludq %xmm14,%xmm0
pshufd $0xed,%xmm0,%xmm0
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm14,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
psrld  $0x3,%xmm0
pshufd $0xf5,%xmm0,%xmm3
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm5,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm0
psubd  %xmm0,%xmm2
packuswb %xmm2,%xmm1
packuswb %xmm7,%xmm1
paddb  %xmm8,%xmm1
movdqu %xmm1,0x10(%r12,%rcx,1)
add    $0x20,%rcx
paddd  %xmm10,%xmm13
paddd  %xmm10,%xmm12
paddd  %xmm10,%xmm11
paddd  %xmm10,%xmm6
add    $0xfffffffffffffffe,%rsi
jne    13c0 <main+0x1c0>
jmp    16a0 <main+0x4a0>
movdqa 0x97d(%rip),%xmm6
movdqa 0x984(%rip),%xmm11
movdqa 0x98b(%rip),%xmm12
movdqa 0x992(%rip),%xmm13
xor    %ecx,%ecx
test   $0x1,%dl
je     17ec <main+0x5ec>
movdqa 0x98f(%rip),%xmm0
movdqa %xmm11,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xed,%xmm1,%xmm2
pshufd $0xf5,%xmm11,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xed,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
psrld  $0x3,%xmm2
movdqa 0x971(%rip),%xmm1
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm2
psubd  %xmm2,%xmm11
movdqa %xmm6,%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xed,%xmm2,%xmm2
pshufd $0xf5,%xmm6,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm2
psrld  $0x3,%xmm2
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm2
psubd  %xmm2,%xmm6
packuswb %xmm6,%xmm11
movdqa %xmm13,%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xed,%xmm2,%xmm2
pshufd $0xf5,%xmm13,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xed,%xmm3,%xmm3
punpckldq %xmm3,%xmm2
psrld  $0x3,%xmm2
pshufd $0xf5,%xmm2,%xmm3
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm2
psubd  %xmm2,%xmm13
movdqa %xmm12,%xmm2
pmuludq %xmm0,%xmm2
pshufd $0xed,%xmm2,%xmm2
pshufd $0xf5,%xmm12,%xmm3
pmuludq %xmm0,%xmm3
pshufd $0xed,%xmm3,%xmm0
punpckldq %xmm0,%xmm2
psrld  $0x3,%xmm2
pshufd $0xf5,%xmm2,%xmm0
pmuludq %xmm1,%xmm2
pshufd $0xe8,%xmm2,%xmm2
pmuludq %xmm1,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
psubd  %xmm2,%xmm12
packuswb %xmm12,%xmm13
packuswb %xmm11,%xmm13
paddb  0x87a(%rip),%xmm13
movdqu %xmm13,(%r12,%rcx,1)
cmp    %r8,%r14
je     183f <main+0x63f>
mov    %r12,%rcx
add    %r8,%rcx
lea    0x61(%r8),%edx
mov    %r14,%rsi
sub    %r8,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r8d,%edi
imul   $0x4ec4ec4f,%rdi,%rdi
shr    $0x23,%rdi
lea    (%rdi,%rdi,4),%ebp
lea    0x0(%rbp,%rbp,4),%ebp
add    %edi,%ebp
mov    %edx,%ebx
sub    %bpl,%bl
mov    %bl,(%rcx)
add    $0x1,%rcx
add    $0x1,%dl
add    $0x1,%r8d
add    $0xffffffffffffffff,%rsi
jne    1810 <main+0x610>
mov    %r14d,%eax
movb   $0x0,(%r12,%rax,1)
mov    0x8(%rsp),%rbp
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
call   10c0 <memcpy@plt>
mov    %r14,%rbx
shr    %rbx
mov    %rbp,%rdi
add    %rbx,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
call   10c0 <memcpy@plt>
movb   $0x0,0x0(%rbp,%r13,1)
cmp    $0x13f,%r14
ja     1894 <main+0x694>
lea    0x848(%rip),%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
xor    %eax,%eax
call   1060 <printf@plt>
mov    0x275d(%rip),%rax
mov    0x2736(%rip),%rcx
mov    (%rcx),%esi
or     (%rax),%esi
mov    0x8(%r15),%rdi
mov    0x273f(%rip),%rax
or     (%rax),%esi
mov    $0x1c0,%edx
call   10e0 <open@plt>
cmp    $0xffffffff,%eax
je     1997 <main+0x797>
mov    %eax,%ebp
mov    %eax,%edi
mov    %r12,%rsi
mov    %r14,%rdx
call   1050 <write@plt>
cltq
cmp    %rax,%r14
jne    19b0 <main+0x7b0>
mov    $0x1,%edi
call   1110 <sleep@plt>
lea    0x18(%rsp),%rsi
mov    %ebp,%edi
call   1120 <fstat@plt>
mov    0x18(%rsp),%rdx
test   %eax,%eax
js     19c3 <main+0x7c3>
cmp    %r14,%rdx
jne    19c3 <main+0x7c3>
mov    0x26ad(%rip),%r15
mov    (%r15),%edx
mov    %ebp,%edi
mov    %rbx,%rsi
call   1070 <lseek@plt>
cltq
cmp    %rax,%rbx
jne    19e3 <main+0x7e3>
mov    %ebp,%edi
mov    %r12,%rsi
mov    %r14,%rdx
call   1050 <write@plt>
cltq
cmp    %rax,%r14
jne    19f6 <main+0x7f6>
lea    0x18(%rsp),%rsi
mov    %ebp,%edi
call   1120 <fstat@plt>
mov    0x18(%rsp),%rdx
test   %eax,%eax
js     1a09 <main+0x809>
add    %r14,%rbx
cmp    %rbx,%rdx
jne    1a09 <main+0x809>
mov    %rdx,0x28(%rsp)
mov    (%r15),%edx
mov    %ebp,%edi
xor    %esi,%esi
call   1070 <lseek@plt>
test   %eax,%eax
je     1a5e <main+0x85e>
lea    0x854(%rip),%rdi
call   1040 <puts@plt>
mov    $0xd,%ebx
jmp    1a27 <main+0x827>
mov    0x8(%r15),%rsi
lea    0x752(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x7,%ebx
jmp    1a2e <main+0x82e>
lea    0x832(%rip),%rdi
call   1040 <puts@plt>
mov    $0x8,%ebx
jmp    1a27 <main+0x827>
mov    0x20(%rsp),%rsi
lea    0x73e(%rip),%rdi
mov    %r14,%rcx
mov    %eax,%r8d
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0x9,%ebx
jmp    1a27 <main+0x827>
lea    0x7f2(%rip),%rdi
call   1040 <puts@plt>
mov    $0xa,%ebx
jmp    1a27 <main+0x827>
lea    0x7ec(%rip),%rdi
call   1040 <puts@plt>
mov    $0xb,%ebx
jmp    1a27 <main+0x827>
mov    0x20(%rsp),%rsi
lea    0x729(%rip),%rdi
mov    %r14,%rcx
mov    %eax,%r8d
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xc,%ebx
mov    %ebp,%edi
call   1080 <close@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rbp
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %ebx,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebp,%edi
mov    0x10(%rsp),%rsi
mov    0x30(%rsp),%rdx
call   1090 <read@plt>
mov    %eax,%ebx
cltq
cmp    %rax,%r13
jne    1ac8 <main+0x8c8>
cmp    $0x13f,%r14
mov    0x10(%rsp),%rbx
ja     1a9c <main+0x89c>
lea    0x702(%rip),%rdi
mov    %rbx,%rsi
mov    0x8(%rsp),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbx,%rdi
mov    0x8(%rsp),%rsi
call   10a0 <strcmp@plt>
test   %rax,%rax
je     1b3a <main+0x93a>
lea    0x719(%rip),%rdi
call   1040 <puts@plt>
mov    $0x10,%ebx
jmp    1a27 <main+0x827>
lea    0x6a1(%rip),%rdi
mov    %ebx,%esi
mov    %r13,%rdx
xor    %eax,%eax
call   1060 <printf@plt>
cmp    $0xffffffff,%ebx
je     1b4d <main+0x94d>
lea    0x6a8(%rip),%rdi
mov    0x10(%rsp),%rsi
mov    0x8(%rsp),%rdx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x18(%rsp),%rsi
mov    %ebp,%edi
call   1120 <fstat@plt>
mov    0x18(%rsp),%rsi
test   %eax,%eax
mov    0x28(%rsp),%rdx
js     1b20 <main+0x920>
mov    $0xf,%ebx
cmp    %rdx,%rsi
je     1a27 <main+0x827>
lea    0x66f(%rip),%rdi
mov    %eax,%ecx
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xe,%ebx
jmp    1a27 <main+0x827>
lea    0x68b(%rip),%rdi
call   1040 <puts@plt>
xor    %ebx,%ebx
jmp    1a27 <main+0x827>
lea    0x5b8(%rip),%rdi
call   10f0 <perror@plt>
jmp    1af8 <main+0x8f8>

LLVM IR (-O0):
%struct.stat = type { i64, i64 }
@stderr = global i32 0
@.str = [30 x i8] c"usage: %s <filename> <bytes>\0A\00"
@.str.1 = [11 x i8] c"No bytes!\0A\00"
@.str.2 = [31 x i8] c"Need an even number of bytes!\0A\00"
@.str.3 = [33 x i8] c"No enough memory for %lu bytes.\0A\00"
@.str.4 = [37 x i8] c"First String: %s\0ASecond String: %s\0A\00"
@O_CREAT = global i32 0
@O_RDWR = global i32 0
@O_TRUNC = global i32 0
@.str.5 = [25 x i8] c"Could not open file %s.\0A\00"
@.str.6 = [15 x i8] c"Write failed!\0A\00"
@.str.7 = [49 x i8] c"bad file %lu size first write %lu != %lu: rc %d\0A\00"
@SEEK_SET = global i32 0
@.str.8 = [14 x i8] c"Seek failed!\0A\00"
@.str.9 = [50 x i8] c"bad file %lu size second write %lu != %lu: rc %d\0A\00"
@.str.10 = [31 x i8] c"Read %d bytes instead of %lu.\0A\00"
@.str.11 = [1 x i8] zeroinitializer
@.str.12 = [7 x i8] c"%s\0A%s\0A\00"
@.str.13 = [44 x i8] c"bad file size after read %lu != %lu: rc %d\0A\00"
@.str.14 = [11 x i8] c"No match!\0A\00"
@.str.15 = [7 x i8] c"Pass!\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 i64
%10 = alloca i64
%11 = alloca %struct.stat
%12 = alloca i8*
%13 = alloca i8*
%14 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 0, i32* %8
%15 = load i32, i32* %4
%16 = icmp ne i32 %15, 3
br i1 %16, label %17, label %25
17: ; preds = %2
%18 = load i32, i32* @stderr
%19 = load i8**, i8*** %5
%20 = getelementptr inbounds i8*, i8** %19, i64 0
%21 = load i8*, i8** %20
%22 = call i32 @fprintf(i32 %18, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i8* %21)
br label %23
23: ; preds = %17
store i32 1, i32* %8
br label %317
24: ; No predecessors!
br label %25
25: ; preds = %24, %2
%26 = load i8**, i8*** %5
%27 = getelementptr inbounds i8*, i8** %26, i64 2
%28 = load i8*, i8** %27
%29 = call i64 @strtoul(i8* %28, i32* null, i32 10)
store i64 %29, i64* %9
%30 = load i64, i64* %9
%31 = icmp ne i64 %30, 0
br i1 %31, label %36, label %32
32: ; preds = %25
%33 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.1, i64 0, i64 0))
br label %34
34: ; preds = %32
store i32 2, i32* %8
br label %317
35: ; No predecessors!
br label %36
36: ; preds = %35, %25
%37 = load i64, i64* %9
%38 = urem i64 %37, 2
%39 = icmp ne i64 %38, 0
br i1 %39, label %40, label %44
40: ; preds = %36
%41 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.2, i64 0, i64 0))
br label %42
42: ; preds = %40
store i32 3, i32* %8
br label %317
43: ; No predecessors!
br label %44
44: ; preds = %43, %36
%45 = load i64, i64* %9
%46 = mul i64 3, %45
%47 = udiv i64 %46, 2
store i64 %47, i64* %10
%48 = load i64, i64* %9
%49 = add i64 %48, 1
%50 = call i8* @malloc(i64 %49)
store i8* %50, i8** %12
%51 = load i8*, i8** %12
%52 = icmp ne i8* %51, null
br i1 %52, label %58, label %53
53: ; preds = %44
%54 = load i64, i64* %9
%55 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i64 %54)
br label %56
56: ; preds = %53
store i32 4, i32* %8
br label %317
57: ; No predecessors!
br label %58
58: ; preds = %57, %44
%59 = load i64, i64* %10
%60 = add i64 %59, 1
%61 = call i8* @malloc(i64 %60)
store i8* %61, i8** %13
%62 = load i8*, i8** %13
%63 = icmp ne i8* %62, null
br i1 %63, label %69, label %64
64: ; preds = %58
%65 = load i64, i64* %10
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i64 %65)
br label %67
67: ; preds = %64
store i32 5, i32* %8
br label %314
68: ; No predecessors!
br label %69
69: ; preds = %68, %58
%70 = load i64, i64* %9
%71 = mul i64 %70, 2
%72 = call i8* @malloc(i64 %71)
store i8* %72, i8** %14
%73 = load i8*, i8** %14
%74 = icmp ne i8* %73, null
br i1 %74, label %81, label %75
75: ; preds = %69
%76 = load i64, i64* %9
%77 = mul i64 %76, 2
%78 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i64 %77)
br label %79
79: ; preds = %75
store i32 6, i32* %8
br label %311
80: ; No predecessors!
br label %81
81: ; preds = %80, %69
store i32 0, i32* %7
br label %82
82: ; preds = %96, %81
%83 = load i32, i32* %7
%84 = sext i32 %83 to i64
%85 = load i64, i64* %9
%86 = icmp ult i64 %84, %85
br i1 %86, label %87, label %99
87: ; preds = %82
%88 = load i32, i32* %7
%89 = srem i32 %88, 26
%90 = add nsw i32 97, %89
%91 = trunc i32 %90 to i8
%92 = load i8*, i8** %12
%93 = load i32, i32* %7
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i8, i8* %92, i64 %94
store i8 %91, i8* %95
br label %96
96: ; preds = %87
%97 = load i32, i32* %7
%98 = add nsw i32 %97, 1
store i32 %98, i32* %7
br label %82
99: ; preds = %82
%100 = load i8*, i8** %12
%101 = load i32, i32* %7
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i8, i8* %100, i64 %102
store i8 0, i8* %103
%104 = load i8*, i8** %13
%105 = load i8*, i8** %12
%106 = load i64, i64* %9
%107 = call i32 @memcpy(i8* %104, i8* %105, i64 %106)
%108 = load i8*, i8** %13
%109 = load i64, i64* %9
%110 = udiv i64 %109, 2
%111 = getelementptr inbounds i8, i8* %108, i64 %110
%112 = load i8*, i8** %12
%113 = load i64, i64* %9
%114 = call i32 @memcpy(i8* %111, i8* %112, i64 %113)
%115 = load i8*, i8** %13
%116 = load i64, i64* %10
%117 = getelementptr inbounds i8, i8* %115, i64 %116
store i8 0, i8* %117
%118 = load i64, i64* %9
%119 = icmp ult i64 %118, 320
br i1 %119, label %120, label %124
120: ; preds = %99
%121 = load i8*, i8** %12
%122 = load i8*, i8** %13
%123 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.4, i64 0, i64 0), i8* %121, i8* %122)
br label %124
124: ; preds = %120, %99
%125 = load i8**, i8*** %5
%126 = getelementptr inbounds i8*, i8** %125, i64 1
%127 = load i8*, i8** %126
%128 = load i32, i32* @O_CREAT
%129 = load i32, i32* @O_RDWR
%130 = or i32 %128, %129
%131 = load i32, i32* @O_TRUNC
%132 = or i32 %130, %131
%133 = call i32 @open(i8* %127, i32 %132, i32 448)
store i32 %133, i32* %6
%134 = load i32, i32* %6
%135 = icmp eq i32 %134, -1
br i1 %135, label %136, label %143
136: ; preds = %124
%137 = load i8**, i8*** %5
%138 = getelementptr inbounds i8*, i8** %137, i64 1
%139 = load i8*, i8** %138
%140 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.5, i64 0, i64 0), i8* %139)
br label %141
141: ; preds = %136
store i32 7, i32* %8
br label %308
142: ; No predecessors!
br label %143
143: ; preds = %142, %124
%144 = load i32, i32* %6
%145 = load i8*, i8** %12
%146 = load i64, i64* %9
%147 = call i32 @write(i32 %144, i8* %145, i64 %146)
store i32 %147, i32* %8
%148 = load i32, i32* %8
%149 = sext i32 %148 to i64
%150 = load i64, i64* %9
%151 = icmp ne i64 %149, %150
br i1 %151, label %152, label %156
152: ; preds = %143
%153 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0))
br label %154
154: ; preds = %152
store i32 8, i32* %8
br label %305
155: ; No predecessors!
br label %156
156: ; preds = %155, %143
%157 = call i32 @sleep(i32 1)
%158 = load i32, i32* %6
%159 = call i32 @fstat(i32 %158, %struct.stat* %11)
store i32 %159, i32* %8
%160 = load i32, i32* %8
%161 = icmp slt i32 %160, 0
br i1 %161, label %167, label %162
162: ; preds = %156
%163 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 0
%164 = load i64, i64* %163
%165 = load i64, i64* %9
%166 = icmp ne i64 %164, %165
br i1 %166, label %167, label %177
167: ; preds = %162, %156
%168 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 1
%169 = load i64, i64* %168
%170 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 0
%171 = load i64, i64* %170
%172 = load i64, i64* %9
%173 = load i32, i32* %8
%174 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.7, i64 0, i64 0), i64 %169, i64 %171, i64 %172, i32 %173)
br label %175
175: ; preds = %167
store i32 9, i32* %8
br label %305
176: ; No predecessors!
br label %177
177: ; preds = %176, %162
%178 = load i32, i32* %6
%179 = load i64, i64* %9
%180 = udiv i64 %179, 2
%181 = load i32, i32* @SEEK_SET
%182 = call i32 @lseek(i32 %178, i64 %180, i32 %181)
store i32 %182, i32* %8
%183 = load i32, i32* %8
%184 = sext i32 %183 to i64
%185 = load i64, i64* %9
%186 = udiv i64 %185, 2
%187 = icmp ne i64 %184, %186
br i1 %187, label %188, label %192
188: ; preds = %177
%189 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i64 0, i64 0))
br label %190
190: ; preds = %188
store i32 10, i32* %8
br label %305
191: ; No predecessors!
br label %192
192: ; preds = %191, %177
%193 = load i32, i32* %6
%194 = load i8*, i8** %12
%195 = load i64, i64* %9
%196 = call i32 @write(i32 %193, i8* %194, i64 %195)
store i32 %196, i32* %8
%197 = load i32, i32* %8
%198 = sext i32 %197 to i64
%199 = load i64, i64* %9
%200 = icmp ne i64 %198, %199
br i1 %200, label %201, label %205
201: ; preds = %192
%202 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.6, i64 0, i64 0))
br label %203
203: ; preds = %201
store i32 11, i32* %8
br label %305
204: ; No predecessors!
br label %205
205: ; preds = %204, %192
%206 = load i32, i32* %6
%207 = call i32 @fstat(i32 %206, %struct.stat* %11)
store i32 %207, i32* %8
%208 = load i32, i32* %8
%209 = icmp slt i32 %208, 0
br i1 %209, label %218, label %210
210: ; preds = %205
%211 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 0
%212 = load i64, i64* %211
%213 = load i64, i64* %9
%214 = load i64, i64* %9
%215 = udiv i64 %214, 2
%216 = add i64 %213, %215
%217 = icmp ne i64 %212, %216
br i1 %217, label %218, label %228
218: ; preds = %210, %205
%219 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 1
%220 = load i64, i64* %219
%221 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 0
%222 = load i64, i64* %221
%223 = load i64, i64* %9
%224 = load i32, i32* %8
%225 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([50 x i8], [50 x i8]* @.str.9, i64 0, i64 0), i64 %220, i64 %222, i64 %223, i32 %224)
br label %226
226: ; preds = %218
store i32 12, i32* %8
br label %305
227: ; No predecessors!
br label %228
228: ; preds = %227, %210
%229 = load i32, i32* %6
%230 = load i32, i32* @SEEK_SET
%231 = call i32 @lseek(i32 %229, i64 0, i32 %230)
store i32 %231, i32* %8
%232 = load i32, i32* %8
%233 = icmp ne i32 %232, 0
br i1 %233, label %234, label %238
234: ; preds = %228
%235 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i64 0, i64 0))
br label %236
236: ; preds = %234
store i32 13, i32* %8
br label %305
237: ; No predecessors!
br label %238
238: ; preds = %237, %228
%239 = load i32, i32* %6
%240 = load i8*, i8** %14
%241 = load i64, i64* %9
%242 = mul i64 %241, 2
%243 = call i32 @read(i32 %239, i8* %240, i64 %242)
store i32 %243, i32* %8
%244 = load i32, i32* %8
%245 = sext i32 %244 to i64
%246 = load i64, i64* %10
%247 = icmp ne i64 %245, %246
br i1 %247, label %248, label %287
248: ; preds = %238
%249 = load i32, i32* %8
%250 = load i64, i64* %10
%251 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0), i32 %249, i64 %250)
%252 = load i32, i32* %8
%253 = icmp eq i32 %252, -1
br i1 %253, label %254, label %256
254: ; preds = %248
%255 = call i32 @perror(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.11, i64 0, i64 0))
br label %260
256: ; preds = %248
%257 = load i8*, i8** %14
%258 = load i8*, i8** %13
%259 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0), i8* %257, i8* %258)
br label %260
260: ; preds = %256, %254
%261 = load i32, i32* %6
%262 = call i32 @fstat(i32 %261, %struct.stat* %11)
store i32 %262, i32* %8
%263 = load i32, i32* %8
%264 = icmp slt i32 %263, 0
br i1 %264, label %273, label %265
265: ; preds = %260
%266 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 0
%267 = load i64, i64* %266
%268 = load i64, i64* %9
%269 = load i64, i64* %9
%270 = udiv i64 %269, 2
%271 = add i64 %268, %270
%272 = icmp ne i64 %267, %271
br i1 %272, label %273, label %284
273: ; preds = %265, %260
%274 = getelementptr inbounds %struct.stat, %struct.stat* %11, i32 0, i32 0
%275 = load i64, i64* %274
%276 = load i64, i64* %9
%277 = load i64, i64* %9
%278 = udiv i64 %277, 2
%279 = add i64 %276, %278
%280 = load i32, i32* %8
%281 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.13, i64 0, i64 0), i64 %275, i64 %279, i32 %280)
br label %282
282: ; preds = %273
store i32 14, i32* %8
br label %305
283: ; No predecessors!
br label %284
284: ; preds = %283, %265
br label %285
285: ; preds = %284
store i32 15, i32* %8
br label %305
286: ; No predecessors!
br label %287
287: ; preds = %286, %238
store i32 0, i32* %8
%288 = load i64, i64* %9
%289 = icmp ult i64 %288, 320
br i1 %289, label %290, label %294
290: ; preds = %287
%291 = load i8*, i8** %14
%292 = load i8*, i8** %13
%293 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0), i8* %291, i8* %292)
br label %294
294: ; preds = %290, %287
%295 = load i8*, i8** %14
%296 = load i8*, i8** %13
%297 = call i64 @strcmp(i8* %295, i8* %296)
%298 = icmp ne i64 %297, 0
br i1 %298, label %299, label %303
299: ; preds = %294
%300 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.14, i64 0, i64 0))
br label %301
301: ; preds = %299
store i32 16, i32* %8
br label %305
302: ; No predecessors!
br label %303
303: ; preds = %302, %294
%304 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.15, i64 0, i64 0))
br label %305
305: ; preds = %303, %301, %285, %282, %236, %226, %203, %190, %175, %154
%306 = load i32, i32* %6
%307 = call i32 @close(i32 %306)
br label %308
308: ; preds = %305, %141
%309 = load i8*, i8** %14
%310 = call i32 @free(i8* %309)
br label %311
311: ; preds = %308, %79
%312 = load i8*, i8** %13
%313 = call i32 @free(i8* %312)
br label %314
314: ; preds = %311, %67
%315 = load i8*, i8** %12
%316 = call i32 @free(i8* %315)
br label %317
317: ; preds = %314, %56, %42, %34, %23
%318 = load i32, i32* %8
ret i32 %318
}

LLVM IR (-O2):
%struct.stat = type { i64, i64 }
@stderr = global i32 0
@.str = [30 x i8] c"usage: %s <filename> <bytes>\0A\00"
@.str.3 = [33 x i8] c"No enough memory for %lu bytes.\0A\00"
@.str.4 = [37 x i8] c"First String: %s\0ASecond String: %s\0A\00"
@O_CREAT = global i32 0
@O_RDWR = global i32 0
@O_TRUNC = global i32 0
@.str.5 = [25 x i8] c"Could not open file %s.\0A\00"
@.str.7 = [49 x i8] c"bad file %lu size first write %lu != %lu: rc %d\0A\00"
@SEEK_SET = global i32 0
@.str.9 = [50 x i8] c"bad file %lu size second write %lu != %lu: rc %d\0A\00"
@.str.10 = [31 x i8] c"Read %d bytes instead of %lu.\0A\00"
@.str.11 = [1 x i8] zeroinitializer
@.str.12 = [7 x i8] c"%s\0A%s\0A\00"
@.str.13 = [44 x i8] c"bad file size after read %lu != %lu: rc %d\0A\00"
@str = [10 x i8] c"No bytes!\00"
@str.16 = [6 x i8] c"Pass!\00"
@str.17 = [10 x i8] c"No match!\00"
@str.20 = [13 x i8] c"Seek failed!\00"
@str.21 = [14 x i8] c"Write failed!\00"
@str.22 = [30 x i8] c"Need an even number of bytes!\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca %struct.stat
%4 = bitcast %struct.stat* %3 to i8*
%5 = icmp eq i32 %0, 3
br i1 %5, label %10, label %6
6: ; preds = %2
%7 = load i32, i32* @stderr
%8 = load i8*, i8** %1
%9 = tail call i32 @fprintf(i32 %7, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str, i64 0, i64 0), i8* %8)
br label %209
10: ; preds = %2
%11 = getelementptr inbounds i8*, i8** %1, i64 2
%12 = load i8*, i8** %11
%13 = tail call i64 @strtoul(i8* nocapture %12, i32* null, i32 10)
%14 = icmp eq i64 %13, 0
br i1 %14, label %15, label %17
15: ; preds = %10
%16 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str, i64 0, i64 0))
br label %209
17: ; preds = %10
%18 = and i64 %13, 1
%19 = icmp eq i64 %18, 0
br i1 %19, label %22, label %20
20: ; preds = %17
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([30 x i8], [30 x i8]* @str.22, i64 0, i64 0))
br label %209
22: ; preds = %17
%23 = mul i64 %13, 3
%24 = lshr i64 %23, 1
%25 = add nuw i64 %13, 1
%26 = tail call i8* @malloc(i64 %25)
%27 = icmp eq i8* %26, null
br i1 %27, label %28, label %30
28: ; preds = %22
%29 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i64 %13)
br label %209
30: ; preds = %22
%31 = add nuw i64 %24, 1
%32 = tail call i8* @malloc(i64 %31)
%33 = icmp eq i8* %32, null
br i1 %33, label %34, label %36
34: ; preds = %30
%35 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i64 %24)
br label %206
36: ; preds = %30
%37 = shl i64 %13, 1
%38 = tail call i8* @malloc(i64 %37)
%39 = icmp eq i8* %38, null
br i1 %39, label %85, label %40
40: ; preds = %36
%41 = icmp ult i64 %13, 16
br i1 %41, label %83, label %42
42: ; preds = %40
%43 = and i64 %13, -16
%44 = add i64 %43, -16
%45 = lshr exact i64 %44, 4
%46 = add nuw nsw i64 %45, 1
%47 = and i64 %46, 1
%48 = icmp eq i64 %44, 0
br i1 %48, label %71, label %49
49: ; preds = %42
%50 = and i64 %46, 2305843009213693950
br label %51
51: ; preds = %51, %49
%52 = phi i64 [ 0, %49 ], [ %67, %51 ]
%53 = phi <16 x i32> [ <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>, %49 ], [ %68, %51 ]
%54 = phi i64 [ 0, %49 ], [ %69, %51 ]
%55 = urem <16 x i32> %53, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%56 = trunc <16 x i32> %55 to <16 x i8>
%57 = add nuw nsw <16 x i8> %56, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%58 = getelementptr inbounds i8, i8* %26, i64 %52
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %59
%60 = or i64 %52, 16
%61 = add <16 x i32> %53, <i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16, i32 16>
%62 = urem <16 x i32> %61, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%63 = trunc <16 x i32> %62 to <16 x i8>
%64 = add nuw nsw <16 x i8> %63, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%65 = getelementptr inbounds i8, i8* %26, i64 %60
%66 = bitcast i8* %65 to <16 x i8>*
store <16 x i8> %64, <16 x i8>* %66
%67 = add nuw i64 %52, 32
%68 = add <16 x i32> %53, <i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32, i32 32>
%69 = add i64 %54, 2
%70 = icmp eq i64 %69, %50
br i1 %70, label %71, label %51
71: ; preds = %51, %42
%72 = phi i64 [ 0, %42 ], [ %67, %51 ]
%73 = phi <16 x i32> [ <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 15>, %42 ], [ %68, %51 ]
%74 = icmp eq i64 %47, 0
br i1 %74, label %81, label %75
75: ; preds = %71
%76 = urem <16 x i32> %73, <i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26, i32 26>
%77 = trunc <16 x i32> %76 to <16 x i8>
%78 = add nuw nsw <16 x i8> %77, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%79 = getelementptr inbounds i8, i8* %26, i64 %72
%80 = bitcast i8* %79 to <16 x i8>*
store <16 x i8> %78, <16 x i8>* %80
br label %81
81: ; preds = %71, %75
%82 = icmp eq i64 %13, %43
br i1 %82, label %96, label %83
83: ; preds = %40, %81
%84 = phi i64 [ 0, %40 ], [ %43, %81 ]
br label %87
85: ; preds = %36
%86 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([33 x i8], [33 x i8]* @.str.3, i64 0, i64 0), i64 %37)
br label %203
87: ; preds = %83, %87
%88 = phi i64 [ %94, %87 ], [ %84, %83 ]
%89 = trunc i64 %88 to i32
%90 = urem i32 %89, 26
%91 = trunc i32 %90 to i8
%92 = add nuw nsw i8 %91, 97
%93 = getelementptr inbounds i8, i8* %26, i64 %88
store i8 %92, i8* %93
%94 = add nuw nsw i64 %88, 1
%95 = icmp eq i64 %94, %13
br i1 %95, label %96, label %87
96: ; preds = %87, %81
%97 = and i64 %13, 4294967295
%98 = getelementptr inbounds i8, i8* %26, i64 %97
store i8 0, i8* %98
%99 = tail call i32 @memcpy(i8* %32, i8* %26, i64 %13)
%100 = lshr i64 %13, 1
%101 = getelementptr inbounds i8, i8* %32, i64 %100
%102 = tail call i32 @memcpy(i8* %101, i8* %26, i64 %13)
%103 = getelementptr inbounds i8, i8* %32, i64 %24
store i8 0, i8* %103
%104 = icmp ult i64 %13, 320
br i1 %104, label %105, label %107
105: ; preds = %96
%106 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([37 x i8], [37 x i8]* @.str.4, i64 0, i64 0), i8* %26, i8* %32)
br label %107
107: ; preds = %105, %96
%108 = getelementptr inbounds i8*, i8** %1, i64 1
%109 = load i8*, i8** %108
%110 = load i32, i32* @O_CREAT
%111 = load i32, i32* @O_RDWR
%112 = or i32 %111, %110
%113 = load i32, i32* @O_TRUNC
%114 = or i32 %112, %113
%115 = tail call i32 @open(i8* %109, i32 %114, i32 448)
%116 = icmp eq i32 %115, -1
br i1 %116, label %117, label %120
117: ; preds = %107
%118 = load i8*, i8** %108
%119 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.5, i64 0, i64 0), i8* %118)
br label %200
120: ; preds = %107
%121 = tail call i32 @write(i32 %115, i8* %26, i64 %13)
%122 = sext i32 %121 to i64
%123 = icmp eq i64 %13, %122
br i1 %123, label %126, label %124
124: ; preds = %120
%125 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.21, i64 0, i64 0))
br label %197
126: ; preds = %120
%127 = tail call i32 @sleep(i32 1)
%128 = call i32 @fstat(i32 %115, %struct.stat* %3)
%129 = icmp sgt i32 %128, -1
%130 = getelementptr inbounds %struct.stat, %struct.stat* %3, i64 0, i32 0
%131 = load i64, i64* %130
%132 = icmp eq i64 %131, %13
%133 = select i1 %129, i1 %132, i1 false
br i1 %133, label %138, label %134
134: ; preds = %126
%135 = getelementptr inbounds %struct.stat, %struct.stat* %3, i64 0, i32 1
%136 = load i64, i64* %135
%137 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([49 x i8], [49 x i8]* @.str.7, i64 0, i64 0), i64 %136, i64 %131, i64 %13, i32 %128)
br label %197
138: ; preds = %126
%139 = load i32, i32* @SEEK_SET
%140 = tail call i32 @lseek(i32 %115, i64 %100, i32 %139)
%141 = sext i32 %140 to i64
%142 = icmp eq i64 %100, %141
br i1 %142, label %145, label %143
143: ; preds = %138
%144 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str.20, i64 0, i64 0))
br label %197
145: ; preds = %138
%146 = tail call i32 @write(i32 %115, i8* %26, i64 %13)
%147 = sext i32 %146 to i64
%148 = icmp eq i64 %13, %147
br i1 %148, label %151, label %149
149: ; preds = %145
%150 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @str.21, i64 0, i64 0))
br label %197
151: ; preds = %145
%152 = call i32 @fstat(i32 %115, %struct.stat* %3)
%153 = icmp sgt i32 %152, -1
%154 = load i64, i64* %130
%155 = add i64 %100, %13
%156 = icmp eq i64 %154, %155
%157 = select i1 %153, i1 %156, i1 false
br i1 %157, label %162, label %158
158: ; preds = %151
%159 = getelementptr inbounds %struct.stat, %struct.stat* %3, i64 0, i32 1
%160 = load i64, i64* %159
%161 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([50 x i8], [50 x i8]* @.str.9, i64 0, i64 0), i64 %160, i64 %154, i64 %13, i32 %152)
br label %197
162: ; preds = %151
%163 = load i32, i32* @SEEK_SET
%164 = tail call i32 @lseek(i32 %115, i64 0, i32 %163)
%165 = icmp eq i32 %164, 0
br i1 %165, label %168, label %166
166: ; preds = %162
%167 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str.20, i64 0, i64 0))
br label %197
168: ; preds = %162
%169 = tail call i32 @read(i32 %115, i8* %38, i64 %37)
%170 = sext i32 %169 to i64
%171 = icmp eq i64 %24, %170
br i1 %171, label %187, label %172
172: ; preds = %168
%173 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([31 x i8], [31 x i8]* @.str.10, i64 0, i64 0), i32 %169, i64 %24)
%174 = icmp eq i32 %169, -1
br i1 %174, label %175, label %177
175: ; preds = %172
%176 = tail call i32 @perror(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.11, i64 0, i64 0))
br label %179
177: ; preds = %172
%178 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0), i8* %38, i8* %32)
br label %179
179: ; preds = %177, %175
%180 = call i32 @fstat(i32 %115, %struct.stat* %3)
%181 = icmp sgt i32 %180, -1
%182 = load i64, i64* %130
%183 = icmp eq i64 %182, %154
%184 = select i1 %181, i1 %183, i1 false
br i1 %184, label %197, label %185
185: ; preds = %179
%186 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([44 x i8], [44 x i8]* @.str.13, i64 0, i64 0), i64 %182, i64 %154, i32 %180)
br label %197
187: ; preds = %168
br i1 %104, label %188, label %190
188: ; preds = %187
%189 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.12, i64 0, i64 0), i8* %38, i8* %32)
br label %190
190: ; preds = %188, %187
%191 = tail call i64 @strcmp(i8* %38, i8* %32)
%192 = icmp eq i64 %191, 0
br i1 %192, label %195, label %193
193: ; preds = %190
%194 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.17, i64 0, i64 0))
br label %197
195: ; preds = %190
%196 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @str.16, i64 0, i64 0))
br label %197
197: ; preds = %179, %195, %193, %185, %166, %158, %149, %143, %134, %124
%198 = phi i32 [ 8, %124 ], [ 9, %134 ], [ 10, %143 ], [ 11, %149 ], [ 12, %158 ], [ 13, %166 ], [ 14, %185 ], [ 16, %193 ], [ 0, %195 ], [ 15, %179 ]
%199 = tail call i32 @close(i32 %115)
br label %200
200: ; preds = %197, %117
%201 = phi i32 [ 7, %117 ], [ %198, %197 ]
%202 = tail call i32 @free(i8* %38)
br label %203
203: ; preds = %200, %85
%204 = phi i32 [ %201, %200 ], [ 6, %85 ]
%205 = tail call i32 @free(i8* %32)
br label %206
206: ; preds = %203, %34
%207 = phi i32 [ %204, %203 ], [ 5, %34 ]
%208 = tail call i32 @free(i8* %26)
br label %209
209: ; preds = %206, %28, %20, %15, %6
%210 = phi i32 [ 1, %6 ], [ 3, %20 ], [ %207, %206 ], [ 4, %28 ], [ 2, %15 ]
ret i32 %210
}