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

/* Forward declarations */

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

/* Variables and functions */
int EOF;
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ feof(int /*<<< orphan*/ *);
scalar_t__ ferror(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int getc(int /*<<< orphan*/ *);
int /*<<< orphan*/ memcpy(char *, char *, int);
int /*<<< orphan*/ memmove(char *, char *, int);
int strlen(char *);
int Version(char *file, char *pat, char *version, int vlen) {
  FILE *fp = fopen(file, "rb");
  int r = 2;
  char epat[80];
  int i, plen, c, mi = 0, match = 0;
  char buf[80];
  int nbuf = 0, ibuf = 0;
  if (!fp)
    return 1;
  plen = strlen(pat);
  for (i = 0; i < plen; i++)
    epat[plen - i - 1] = pat[i];
  epat[plen] = '\0';
  while (!match) {
    if (nbuf) {
      c = buf[ibuf++];
      if (ibuf == nbuf)
        nbuf = 0;
    } else {
      c = getc(fp);
      if (c == EOF)
        if (feof(fp)) {
          fclose(fp);
          return 2;
        } else if (ferror(fp)) {
          fclose(fp);
          return 3;
        };
    }
    if (pat[mi] == c) {
      if (++mi == plen)
        match = 1;
    } else if (nbuf) {
      if (--nbuf)
        memmove(buf, buf + 1, nbuf);
      ibuf = mi = 0;
    } else if (mi) {
      if (mi-- > 1)
        memcpy(buf, pat + 1, mi);
      buf[mi] = c;
      nbuf = mi + 1;
      ibuf = mi = 0;
    }
  }
  while ((c = getc(fp)) == ' ')
    ;
  if (c == EOF)
    if (feof(fp)) {
      fclose(fp);
      return 2;
    } else if (ferror(fp)) {
      fclose(fp);
      return 3;
    };
  vlen--;
  for (match = mi = i = 0; !match; i++) {
    if (i < vlen)
      version[i] = c;
    if (epat[mi] == c) {
      if (++mi == plen)
        match = 1;
    } else if (mi)
      mi = epat[0] == c;
    c = getc(fp);
    if (c == EOF)
      if (feof(fp)) {
        fclose(fp);
        return 2;
      } else if (ferror(fp)) {
        fclose(fp);
        return 3;
      };
  }
  fclose(fp);
  if (match) {
    mi = i - plen;
    if (mi > vlen)
      mi = vlen;
    version[mi--] = '\0';
    while (mi >= 0 && version[mi] == ' ')
      version[mi--] = '\0';
    return 0;
  } else
    return 2;
}


x86 assembly (clang, -O0):
<Version>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe5b(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x30(%rbp)
movl   $0x2,-0x34(%rbp)
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0x104(%rbp)
movl   $0x0,-0x108(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    11f4 <Version+0x74>
movl   $0x1,-0x4(%rbp)
jmp    174e <Version+0x5ce>
mov    -0x18(%rbp),%rdi
call   1050 <strlen@plt>
mov    %eax,-0x98(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
cmp    -0x98(%rbp),%eax
jge    1259 <Version+0xd9>
mov    -0x18(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x98(%rbp),%eax
sub    -0x94(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %cl,-0x90(%rbp,%rax,1)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    120d <Version+0x8d>
movslq -0x98(%rbp),%rax
movb   $0x0,-0x90(%rbp,%rax,1)
cmpl   $0x0,-0xa4(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    1281 <Version+0x101>
jmp    147c <Version+0x2fc>
cmpl   $0x0,-0x104(%rbp)
je     12d0 <Version+0x150>
mov    -0x108(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x108(%rbp)
cltq
movsbl -0x100(%rbp,%rax,1),%eax
ff
mov    %eax,-0x9c(%rbp)
mov    -0x108(%rbp),%eax
cmp    -0x104(%rbp),%eax
jne    12cb <Version+0x14b>
movl   $0x0,-0x104(%rbp)
jmp    1353 <Version+0x1d3>
mov    -0x30(%rbp),%rdi
call   10a0 <getc@plt>
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    0x2cfc(%rip),%rcx
cmp    (%rcx),%eax
jne    134e <Version+0x1ce>
mov    -0x30(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%rax
je     131c <Version+0x19c>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
movl   $0x2,-0x4(%rbp)
jmp    174e <Version+0x5ce>
mov    -0x30(%rbp),%rdi
call   1030 <ferror@plt>
cmp    $0x0,%rax
je     1344 <Version+0x1c4>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
movl   $0x3,-0x4(%rbp)
jmp    174e <Version+0x5ce>
jmp    1349 <Version+0x1c9>
jmp    134e <Version+0x1ce>
jmp    1353 <Version+0x1d3>
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    -0x9c(%rbp),%eax
jne    1398 <Version+0x218>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
cmp    -0x98(%rbp),%eax
jne    1393 <Version+0x213>
movl   $0x1,-0xa4(%rbp)
jmp    1477 <Version+0x2f7>
cmpl   $0x0,-0x104(%rbp)
je     13f3 <Version+0x273>
mov    -0x104(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x104(%rbp)
cmp    $0x0,%eax
je     13da <Version+0x25a>
lea    -0x100(%rbp),%rdi
lea    -0x100(%rbp),%rsi
add    $0x1,%rsi
mov    -0x104(%rbp),%edx
call   1080 <memmove@plt>
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0x108(%rbp)
jmp    1472 <Version+0x2f2>
cmpl   $0x0,-0xa0(%rbp)
je     146d <Version+0x2ed>
mov    -0xa0(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xa0(%rbp)
cmp    $0x1,%eax
jle    1434 <Version+0x2b4>
lea    -0x100(%rbp),%rdi
mov    -0x18(%rbp),%rsi
add    $0x1,%rsi
mov    -0xa0(%rbp),%edx
call   1070 <memcpy@plt>
mov    -0x9c(%rbp),%eax
mov    %al,%cl
movslq -0xa0(%rbp),%rax
mov    %cl,-0x100(%rbp,%rax,1)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x104(%rbp)
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0x108(%rbp)
jmp    1472 <Version+0x2f2>
jmp    1477 <Version+0x2f7>
jmp    1268 <Version+0xe8>
jmp    1481 <Version+0x301>
mov    -0x30(%rbp),%rdi
call   10a0 <getc@plt>
mov    %eax,-0x9c(%rbp)
cmp    $0x20,%eax
jne    149e <Version+0x31e>
jmp    1481 <Version+0x301>
mov    -0x9c(%rbp),%eax
mov    0x2b3d(%rip),%rcx
cmp    (%rcx),%eax
jne    150d <Version+0x38d>
mov    -0x30(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%rax
je     14db <Version+0x35b>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
movl   $0x2,-0x4(%rbp)
jmp    174e <Version+0x5ce>
mov    -0x30(%rbp),%rdi
call   1030 <ferror@plt>
cmp    $0x0,%rax
je     1503 <Version+0x383>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
movl   $0x3,-0x4(%rbp)
jmp    174e <Version+0x5ce>
jmp    1508 <Version+0x388>
jmp    150d <Version+0x38d>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x94(%rbp)
movl   $0x0,-0xa0(%rbp)
movl   $0x0,-0xa4(%rbp)
cmpl   $0x0,-0xa4(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    154d <Version+0x3cd>
jmp    167b <Version+0x4fb>
mov    -0x94(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1572 <Version+0x3f2>
mov    -0x9c(%rbp),%eax
mov    %al,%dl
mov    -0x20(%rbp),%rax
movslq -0x94(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
movslq -0xa0(%rbp),%rax
movsbl -0x90(%rbp,%rax,1),%eax
ff
cmp    -0x9c(%rbp),%eax
jne    15b7 <Version+0x437>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
cmp    -0x98(%rbp),%eax
jne    15b2 <Version+0x432>
movl   $0x1,-0xa4(%rbp)
jmp    15e4 <Version+0x464>
cmpl   $0x0,-0xa0(%rbp)
je     15df <Version+0x45f>
movsbl -0x90(%rbp),%eax
cmp    -0x9c(%rbp),%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0xa0(%rbp)
jmp    15e4 <Version+0x464>
mov    -0x30(%rbp),%rdi
call   10a0 <getc@plt>
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
mov    0x29e8(%rip),%rcx
cmp    (%rcx),%eax
jne    1662 <Version+0x4e2>
mov    -0x30(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%rax
je     1630 <Version+0x4b0>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
movl   $0x2,-0x4(%rbp)
jmp    174e <Version+0x5ce>
mov    -0x30(%rbp),%rdi
call   1030 <ferror@plt>
cmp    $0x0,%rax
je     1658 <Version+0x4d8>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
movl   $0x3,-0x4(%rbp)
jmp    174e <Version+0x5ce>
jmp    165d <Version+0x4dd>
jmp    1662 <Version+0x4e2>
jmp    1667 <Version+0x4e7>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1534 <Version+0x3b4>
mov    -0x30(%rbp),%rdi
call   1040 <fclose@plt>
cmpl   $0x0,-0xa4(%rbp)
je     1747 <Version+0x5c7>
mov    -0x94(%rbp),%eax
sub    -0x98(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    16bb <Version+0x53b>
mov    -0x24(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x20(%rbp),%rax
mov    -0xa0(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0xa0(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
xor    %eax,%eax
cmpl   $0x0,-0xa0(%rbp)
mov    %al,-0x109(%rbp)
jl     1707 <Version+0x587>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
sete   %al
mov    %al,-0x109(%rbp)
mov    -0x109(%rbp),%al
test   $0x1,%al
jne    171a <Version+0x59a>
jmp    173b <Version+0x5bb>
mov    -0x20(%rbp),%rax
mov    -0xa0(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0xa0(%rbp)
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    16d7 <Version+0x557>
movl   $0x0,-0x4(%rbp)
jmp    174e <Version+0x5ce>
movl   $0x2,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x110,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Version>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rcx,0x20(%rsp)
mov    %rdx,%rbx
mov    %rsi,%rbp
lea    0xe5d(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     11d6 <Version+0x56>
mov    %rax,%r14
mov    %rbx,0x28(%rsp)
mov    %rbp,%rdi
call   1050 <strlen@plt>
test   %eax,%eax
mov    %rbp,%r8
jle    1366 <Version+0x1e6>
mov    %eax,%ebp
cmp    $0x8,%eax
jae    11e1 <Version+0x61>
xor    %ecx,%ecx
jmp    1307 <Version+0x187>
mov    $0x1,%r15d
jmp    164f <Version+0x4cf>
lea    -0x1(%rbp),%rsi
lea    -0x1(%rax),%edx
mov    %edx,%edi
sub    %esi,%edi
xor    %ecx,%ecx
cmp    %edx,%edi
jg     1307 <Version+0x187>
shr    $0x20,%rsi
jne    1307 <Version+0x187>
cmp    $0x20,%eax
jae    120c <Version+0x8c>
xor    %ecx,%ecx
jmp    12b7 <Version+0x137>
mov    %ebp,%ecx
and    $0xffffffe0,%ecx
xor    %esi,%esi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
movdqu (%r8,%rsi,1),%xmm1
movdqu 0x10(%r8,%rsi,1),%xmm2
movslq %edx,%rdx
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 %xmm1,0x21(%rsp,%rdx,1)
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
movdqu %xmm2,0x11(%rsp,%rdx,1)
add    $0x20,%rsi
add    $0xffffffe0,%edx
cmp    %rsi,%rcx
jne    1220 <Version+0xa0>
cmp    %rbp,%rcx
je     1366 <Version+0x1e6>
test   $0x18,%bpl
je     1307 <Version+0x187>
mov    %rcx,%rdx
mov    %ebp,%ecx
and    $0xfffffff8,%ecx
mov    %edx,%esi
not    %esi
add    %eax,%esi
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movq   (%r8,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
movslq %esi,%rsi
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x29(%rsp,%rsi,1)
add    $0x8,%rdx
add    $0xfffffff8,%esi
cmp    %rdx,%rcx
jne    12d0 <Version+0x150>
cmp    %rbp,%rcx
je     1366 <Version+0x1e6>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%bpl
je     1328 <Version+0x1a8>
mov    (%r8,%rcx,1),%bl
mov    %ecx,%esi
not    %esi
add    %eax,%esi
movslq %esi,%rsi
mov    %bl,0x30(%rsp,%rsi,1)
or     $0x1,%rcx
add    %rbp,%rdx
je     1366 <Version+0x1e6>
sub    %rcx,%rbp
mov    %ecx,%edx
not    %edx
add    %eax,%edx
add    %r8,%rcx
add    $0x1,%rcx
xor    %esi,%esi
nop
movzbl -0x1(%rcx,%rsi,1),%ebx
movslq %edx,%rdx
mov    %bl,0x30(%rsp,%rdx,1)
movzbl (%rcx,%rsi,1),%ebx
lea    -0x1(%rdx),%edi
movslq %edi,%rdi
mov    %bl,0x30(%rsp,%rdi,1)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rbp
jne    1340 <Version+0x1c0>
mov    %r14,0x8(%rsp)
mov    %rax,0x18(%rsp)
cltq
movb   $0x0,0x30(%rsp,%rax,1)
lea    0x1(%r8),%rax
mov    %rax,0x10(%rsp)
xor    %r13d,%r13d
xor    %ebp,%ebp
xor    %r12d,%r12d
mov    %r8,(%rsp)
jmp    13b2 <Version+0x232>
xchg   %ax,%ax
add    $0x1,%r12d
xor    %eax,%eax
cmp    0x18(%rsp),%r12d
sete   %al
mov    %r12d,%ebx
mov    %ebp,%r12d
mov    %r12d,%ebp
mov    %ebx,%r12d
test   %eax,%eax
jne    14bd <Version+0x33d>
test   %ebp,%ebp
je     13e0 <Version+0x260>
movslq %r13d,%rax
add    $0x1,%r13d
movsbl 0x80(%rsp,%rax,1),%r14d
cmp    %ebp,%r13d
mov    $0x0,%eax
cmove  %eax,%ebp
jmp    1430 <Version+0x2b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%rsp),%rbx
mov    %rbx,%rdi
call   10a0 <getc@plt>
mov    %eax,%r14d
xor    %ebp,%ebp
mov    0x2bef(%rip),%rax
cmp    (%rax),%r14d
jne    1425 <Version+0x2a5>
mov    %rbx,%rdi
call   1060 <feof@plt>
test   %rax,%rax
jne    1629 <Version+0x4a9>
mov    %rbx,%rdi
call   1030 <ferror@plt>
test   %rax,%rax
mov    (%rsp),%r8
je     1430 <Version+0x2b0>
jmp    1634 <Version+0x4b4>
mov    (%rsp),%r8
nopl   0x0(%rax)
movslq %r12d,%r15
movsbl (%r8,%r15,1),%eax
cmp    %eax,%r14d
je     1390 <Version+0x210>
test   %ebp,%ebp
je     146e <Version+0x2ee>
xor    %ebx,%ebx
add    $0xffffffff,%ebp
je     14a4 <Version+0x324>
lea    0x80(%rsp),%rdi
lea    0x81(%rsp),%rsi
mov    %ebp,%edx
call   1080 <memmove@plt>
mov    (%rsp),%r8
xor    %eax,%eax
mov    %ebp,%r12d
jmp    14a9 <Version+0x329>
test   %r12d,%r12d
je     14b1 <Version+0x331>
add    $0xffffffffffffffff,%r15
cmp    $0x2,%r12d
jl     1496 <Version+0x316>
lea    0x80(%rsp),%rdi
mov    0x10(%rsp),%rsi
mov    %r15d,%edx
call   1070 <memcpy@plt>
mov    (%rsp),%r8
mov    %r14b,0x80(%rsp,%r15,1)
xor    %ebx,%ebx
xor    %eax,%eax
jmp    14a9 <Version+0x329>
xor    %eax,%eax
xor    %r12d,%r12d
xor    %r13d,%r13d
jmp    13a4 <Version+0x224>
xor    %ebx,%ebx
xor    %eax,%eax
xor    %r12d,%r12d
jmp    13a4 <Version+0x224>
mov    0x8(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rdi
call   10a0 <getc@plt>
cmp    $0x20,%eax
je     14d0 <Version+0x350>
mov    %eax,%ebp
mov    0x2b02(%rip),%rax
cmp    (%rax),%ebp
jne    1518 <Version+0x398>
mov    %r14,%rdi
call   1060 <feof@plt>
mov    $0x2,%r15d
test   %rax,%rax
jne    1647 <Version+0x4c7>
mov    %r14,%rdi
call   1030 <ferror@plt>
mov    $0x3,%r15d
test   %rax,%rax
jne    1647 <Version+0x4c7>
mov    0x20(%rsp),%rax
add    $0xffffffff,%eax
movsbl 0x30(%rsp),%ecx
mov    %ecx,(%rsp)
mov    %eax,0x10(%rsp)
movslq %eax,%r12
xor    %ebx,%ebx
xor    %r13d,%r13d
mov    0x8(%rsp),%r14
jmp    154d <Version+0x3cd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
test   %r15d,%r15d
jne    15db <Version+0x45b>
cmp    %r12,%rbx
jge    155b <Version+0x3db>
mov    0x28(%rsp),%rax
mov    %bpl,(%rax,%rbx,1)
movslq %r13d,%rax
movsbl 0x30(%rsp,%rax,1),%eax
cmp    %eax,%ebp
jne    1580 <Version+0x400>
add    $0x1,%r13d
xor    %r15d,%r15d
cmp    0x18(%rsp),%r13d
sete   %r15b
jmp    15a0 <Version+0x420>
nopl   0x0(%rax)
xor    %r15d,%r15d
test   %r13d,%r13d
je     1594 <Version+0x414>
xor    %r13d,%r13d
cmp    (%rsp),%ebp
sete   %r13b
jmp    15a0 <Version+0x420>
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
call   10a0 <getc@plt>
mov    %eax,%ebp
mov    0x2a37(%rip),%rax
cmp    (%rax),%ebp
jne    1540 <Version+0x3c0>
mov    %r14,%rdi
call   1060 <feof@plt>
test   %rax,%rax
jne    1641 <Version+0x4c1>
mov    %r14,%rdi
call   1030 <ferror@plt>
test   %rax,%rax
je     1540 <Version+0x3c0>
mov    $0x3,%r15d
jmp    1647 <Version+0x4c7>
mov    0x8(%rsp),%rdi
call   1040 <fclose@plt>
sub    0x18(%rsp),%ebx
cmp    0x20(%rsp),%ebx
mov    0x10(%rsp),%ecx
cmovl  %ebx,%ecx
movslq %ecx,%rax
mov    0x28(%rsp),%rdx
movb   $0x0,(%rdx,%rax,1)
xor    %r15d,%r15d
test   %eax,%eax
jle    164f <Version+0x4cf>
mov    %ecx,%eax
add    $0x1,%rax
nopl   (%rax)
lea    -0x2(%rax),%ecx
cmpb   $0x20,(%rdx,%rcx,1)
jne    164f <Version+0x4cf>
movb   $0x0,(%rdx,%rcx,1)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     1610 <Version+0x490>
jmp    164f <Version+0x4cf>
mov    $0x2,%r15d
mov    %rbx,%r14
jmp    1647 <Version+0x4c7>
mov    $0x3,%r15d
mov    0x8(%rsp),%r14
jmp    1647 <Version+0x4c7>
mov    $0x2,%r15d
mov    %r14,%rdi
call   1040 <fclose@plt>
mov    %r15d,%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"rb\00"
@EOF = global i32 0
define i32 @Version(i8* %0, i8* %1, i8* %2, i32 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32
%12 = alloca [80 x i8]
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca [80 x i8]
%19 = alloca i32
%20 = alloca i32
store i8* %0, i8** %6
store i8* %1, i8** %7
store i8* %2, i8** %8
store i32 %3, i32* %9
%21 = load i8*, i8** %6
%22 = call i32* @fopen(i8* %21, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
store i32* %22, i32** %10
store i32 2, i32* %11
store i32 0, i32* %16
store i32 0, i32* %17
store i32 0, i32* %19
store i32 0, i32* %20
%23 = load i32*, i32** %10
%24 = icmp ne i32* %23, null
br i1 %24, label %26, label %25
25: ; preds = %4
store i32 1, i32* %5
br label %285
26: ; preds = %4
%27 = load i8*, i8** %7
%28 = call i32 @strlen(i8* %27)
store i32 %28, i32* %14
store i32 0, i32* %13
br label %29
29: ; preds = %45, %26
%30 = load i32, i32* %13
%31 = load i32, i32* %14
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %48
33: ; preds = %29
%34 = load i8*, i8** %7
%35 = load i32, i32* %13
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i8, i8* %34, i64 %36
%38 = load i8, i8* %37
%39 = load i32, i32* %14
%40 = load i32, i32* %13
%41 = sub nsw i32 %39, %40
%42 = sub nsw i32 %41, 1
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [80 x i8], [80 x i8]* %12, i64 0, i64 %43
store i8 %38, i8* %44
br label %45
45: ; preds = %33
%46 = load i32, i32* %13
%47 = add nsw i32 %46, 1
store i32 %47, i32* %13
br label %29
48: ; preds = %29
%49 = load i32, i32* %14
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds [80 x i8], [80 x i8]* %12, i64 0, i64 %50
store i8 0, i8* %51
br label %52
52: ; preds = %147, %48
%53 = load i32, i32* %17
%54 = icmp ne i32 %53, 0
%55 = xor i1 %54, true
br i1 %55, label %56, label %148
56: ; preds = %52
%57 = load i32, i32* %19
%58 = icmp ne i32 %57, 0
br i1 %58, label %59, label %71
59: ; preds = %56
%60 = load i32, i32* %20
%61 = add nsw i32 %60, 1
store i32 %61, i32* %20
%62 = sext i32 %60 to i64
%63 = getelementptr inbounds [80 x i8], [80 x i8]* %18, i64 0, i64 %62
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
store i32 %65, i32* %15
%66 = load i32, i32* %20
%67 = load i32, i32* %19
%68 = icmp eq i32 %66, %67
br i1 %68, label %69, label %70
69: ; preds = %59
store i32 0, i32* %19
br label %70
70: ; preds = %69, %59
br label %94
71: ; preds = %56
%72 = load i32*, i32** %10
%73 = call i32 @getc(i32* %72)
store i32 %73, i32* %15
%74 = load i32, i32* %15
%75 = load i32, i32* @EOF
%76 = icmp eq i32 %74, %75
br i1 %76, label %77, label %93
77: ; preds = %71
%78 = load i32*, i32** %10
%79 = call i64 @feof(i32* %78)
%80 = icmp ne i64 %79, 0
br i1 %80, label %81, label %84
81: ; preds = %77
%82 = load i32*, i32** %10
%83 = call i32 @fclose(i32* %82)
store i32 2, i32* %5
br label %285
84: ; preds = %77
%85 = load i32*, i32** %10
%86 = call i64 @ferror(i32* %85)
%87 = icmp ne i64 %86, 0
br i1 %87, label %88, label %91
88: ; preds = %84
%89 = load i32*, i32** %10
%90 = call i32 @fclose(i32* %89)
store i32 3, i32* %5
br label %285
91: ; preds = %84
br label %92
92: ; preds = %91
br label %93
93: ; preds = %92, %71
br label %94
94: ; preds = %93, %70
%95 = load i8*, i8** %7
%96 = load i32, i32* %16
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i8, i8* %95, i64 %97
%99 = load i8, i8* %98
%100 = sext i8 %99 to i32
%101 = load i32, i32* %15
%102 = icmp eq i32 %100, %101
br i1 %102, label %103, label %110
103: ; preds = %94
%104 = load i32, i32* %16
%105 = add nsw i32 %104, 1
store i32 %105, i32* %16
%106 = load i32, i32* %14
%107 = icmp eq i32 %105, %106
br i1 %107, label %108, label %109
108: ; preds = %103
store i32 1, i32* %17
br label %109
109: ; preds = %108, %103
br label %147
110: ; preds = %94
%111 = load i32, i32* %19
%112 = icmp ne i32 %111, 0
br i1 %112, label %113, label %124
113: ; preds = %110
%114 = load i32, i32* %19
%115 = add nsw i32 %114, -1
store i32 %115, i32* %19
%116 = icmp ne i32 %115, 0
br i1 %116, label %117, label %123
117: ; preds = %113
%118 = getelementptr inbounds [80 x i8], [80 x i8]* %18, i64 0, i64 0
%119 = getelementptr inbounds [80 x i8], [80 x i8]* %18, i64 0, i64 0
%120 = getelementptr inbounds i8, i8* %119, i64 1
%121 = load i32, i32* %19
%122 = call i32 @memmove(i8* %118, i8* %120, i32 %121)
br label %123
123: ; preds = %117, %113
store i32 0, i32* %16
store i32 0, i32* %20
br label %146
124: ; preds = %110
%125 = load i32, i32* %16
%126 = icmp ne i32 %125, 0
br i1 %126, label %127, label %145
127: ; preds = %124
%128 = load i32, i32* %16
%129 = add nsw i32 %128, -1
store i32 %129, i32* %16
%130 = icmp sgt i32 %128, 1
br i1 %130, label %131, label %137
131: ; preds = %127
%132 = getelementptr inbounds [80 x i8], [80 x i8]* %18, i64 0, i64 0
%133 = load i8*, i8** %7
%134 = getelementptr inbounds i8, i8* %133, i64 1
%135 = load i32, i32* %16
%136 = call i32 @memcpy(i8* %132, i8* %134, i32 %135)
br label %137
137: ; preds = %131, %127
%138 = load i32, i32* %15
%139 = trunc i32 %138 to i8
%140 = load i32, i32* %16
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [80 x i8], [80 x i8]* %18, i64 0, i64 %141
store i8 %139, i8* %142
%143 = load i32, i32* %16
%144 = add nsw i32 %143, 1
store i32 %144, i32* %19
store i32 0, i32* %16
store i32 0, i32* %20
br label %145
145: ; preds = %137, %124
br label %146
146: ; preds = %145, %123
br label %147
147: ; preds = %146, %109
br label %52
148: ; preds = %52
br label %149
149: ; preds = %153, %148
%150 = load i32*, i32** %10
%151 = call i32 @getc(i32* %150)
store i32 %151, i32* %15
%152 = icmp eq i32 %151, 32
br i1 %152, label %153, label %154
153: ; preds = %149
br label %149
154: ; preds = %149
%155 = load i32, i32* %15
%156 = load i32, i32* @EOF
%157 = icmp eq i32 %155, %156
br i1 %157, label %158, label %174
158: ; preds = %154
%159 = load i32*, i32** %10
%160 = call i64 @feof(i32* %159)
%161 = icmp ne i64 %160, 0
br i1 %161, label %162, label %165
162: ; preds = %158
%163 = load i32*, i32** %10
%164 = call i32 @fclose(i32* %163)
store i32 2, i32* %5
br label %285
165: ; preds = %158
%166 = load i32*, i32** %10
%167 = call i64 @ferror(i32* %166)
%168 = icmp ne i64 %167, 0
br i1 %168, label %169, label %172
169: ; preds = %165
%170 = load i32*, i32** %10
%171 = call i32 @fclose(i32* %170)
store i32 3, i32* %5
br label %285
172: ; preds = %165
br label %173
173: ; preds = %172
br label %174
174: ; preds = %173, %154
%175 = load i32, i32* %9
%176 = add nsw i32 %175, -1
store i32 %176, i32* %9
store i32 0, i32* %13
store i32 0, i32* %16
store i32 0, i32* %17
br label %177
177: ; preds = %241, %174
%178 = load i32, i32* %17
%179 = icmp ne i32 %178, 0
%180 = xor i1 %179, true
br i1 %180, label %181, label %244
181: ; preds = %177
%182 = load i32, i32* %13
%183 = load i32, i32* %9
%184 = icmp slt i32 %182, %183
br i1 %184, label %185, label %192
185: ; preds = %181
%186 = load i32, i32* %15
%187 = trunc i32 %186 to i8
%188 = load i8*, i8** %8
%189 = load i32, i32* %13
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i8, i8* %188, i64 %190
store i8 %187, i8* %191
br label %192
192: ; preds = %185, %181
%193 = load i32, i32* %16
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [80 x i8], [80 x i8]* %12, i64 0, i64 %194
%196 = load i8, i8* %195
%197 = sext i8 %196 to i32
%198 = load i32, i32* %15
%199 = icmp eq i32 %197, %198
br i1 %199, label %200, label %207
200: ; preds = %192
%201 = load i32, i32* %16
%202 = add nsw i32 %201, 1
store i32 %202, i32* %16
%203 = load i32, i32* %14
%204 = icmp eq i32 %202, %203
br i1 %204, label %205, label %206
205: ; preds = %200
store i32 1, i32* %17
br label %206
206: ; preds = %205, %200
br label %218
207: ; preds = %192
%208 = load i32, i32* %16
%209 = icmp ne i32 %208, 0
br i1 %209, label %210, label %217
210: ; preds = %207
%211 = getelementptr inbounds [80 x i8], [80 x i8]* %12, i64 0, i64 0
%212 = load i8, i8* %211
%213 = sext i8 %212 to i32
%214 = load i32, i32* %15
%215 = icmp eq i32 %213, %214
%216 = zext i1 %215 to i32
store i32 %216, i32* %16
br label %217
217: ; preds = %210, %207
br label %218
218: ; preds = %217, %206
%219 = load i32*, i32** %10
%220 = call i32 @getc(i32* %219)
store i32 %220, i32* %15
%221 = load i32, i32* %15
%222 = load i32, i32* @EOF
%223 = icmp eq i32 %221, %222
br i1 %223, label %224, label %240
224: ; preds = %218
%225 = load i32*, i32** %10
%226 = call i64 @feof(i32* %225)
%227 = icmp ne i64 %226, 0
br i1 %227, label %228, label %231
228: ; preds = %224
%229 = load i32*, i32** %10
%230 = call i32 @fclose(i32* %229)
store i32 2, i32* %5
br label %285
231: ; preds = %224
%232 = load i32*, i32** %10
%233 = call i64 @ferror(i32* %232)
%234 = icmp ne i64 %233, 0
br i1 %234, label %235, label %238
235: ; preds = %231
%236 = load i32*, i32** %10
%237 = call i32 @fclose(i32* %236)
store i32 3, i32* %5
br label %285
238: ; preds = %231
br label %239
239: ; preds = %238
br label %240
240: ; preds = %239, %218
br label %241
241: ; preds = %240
%242 = load i32, i32* %13
%243 = add nsw i32 %242, 1
store i32 %243, i32* %13
br label %177
244: ; preds = %177
%245 = load i32*, i32** %10
%246 = call i32 @fclose(i32* %245)
%247 = load i32, i32* %17
%248 = icmp ne i32 %247, 0
br i1 %248, label %249, label %284
249: ; preds = %244
%250 = load i32, i32* %13
%251 = load i32, i32* %14
%252 = sub nsw i32 %250, %251
store i32 %252, i32* %16
%253 = load i32, i32* %16
%254 = load i32, i32* %9
%255 = icmp sgt i32 %253, %254
br i1 %255, label %256, label %258
256: ; preds = %249
%257 = load i32, i32* %9
store i32 %257, i32* %16
br label %258
258: ; preds = %256, %249
%259 = load i8*, i8** %8
%260 = load i32, i32* %16
%261 = add nsw i32 %260, -1
store i32 %261, i32* %16
%262 = sext i32 %260 to i64
%263 = getelementptr inbounds i8, i8* %259, i64 %262
store i8 0, i8* %263
br label %264
264: ; preds = %277, %258
%265 = load i32, i32* %16
%266 = icmp sge i32 %265, 0
br i1 %266, label %267, label %275
267: ; preds = %264
%268 = load i8*, i8** %8
%269 = load i32, i32* %16
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i8, i8* %268, i64 %270
%272 = load i8, i8* %271
%273 = sext i8 %272 to i32
%274 = icmp eq i32 %273, 32
br label %275
275: ; preds = %267, %264
%276 = phi i1 [ false, %264 ], [ %274, %267 ]
br i1 %276, label %277, label %283
277: ; preds = %275
%278 = load i8*, i8** %8
%279 = load i32, i32* %16
%280 = add nsw i32 %279, -1
store i32 %280, i32* %16
%281 = sext i32 %279 to i64
%282 = getelementptr inbounds i8, i8* %278, i64 %281
store i8 0, i8* %282
br label %264
283: ; preds = %275
store i32 0, i32* %5
br label %285
284: ; preds = %244
store i32 2, i32* %5
br label %285
285: ; preds = %284, %283, %235, %228, %169, %162, %88, %81, %25
%286 = load i32, i32* %5
ret i32 %286
}

LLVM IR (-O2):
@.str = [3 x i8] c"rb\00"
@EOF = global i32 0
define i32 @Version(i8* nocapture %0, i8* %1, i8* nocapture %2, i32 %3) {
%5 = alloca [80 x i8]
%6 = alloca [80 x i8]
%7 = tail call i32* @fopen(i8* %0, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0))
%8 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 0
%9 = getelementptr inbounds [80 x i8], [80 x i8]* %6, i64 0, i64 0
%10 = icmp eq i32* %7, null
br i1 %10, label %255, label %11
11: ; preds = %4
%12 = tail call i32 @strlen(i8* %1)
%13 = icmp sgt i32 %12, 0
br i1 %13, label %14, label %112
14: ; preds = %11
%15 = zext i32 %12 to i64
%16 = icmp ult i32 %12, 8
br i1 %16, label %75, label %17
17: ; preds = %14
%18 = add nsw i64 %15, -1
%19 = add i32 %12, -1
%20 = trunc i64 %18 to i32
%21 = sub i32 %19, %20
%22 = icmp sgt i32 %21, %19
%23 = icmp ugt i64 %18, 4294967295
%24 = or i1 %22, %23
br i1 %24, label %75, label %25
25: ; preds = %17
%26 = icmp ult i32 %12, 32
br i1 %26, label %55, label %27
27: ; preds = %25
%28 = and i64 %15, 4294967264
br label %29
29: ; preds = %29, %27
%30 = phi i64 [ 0, %27 ], [ %48, %29 ]
%31 = trunc i64 %30 to i32
%32 = getelementptr inbounds i8, i8* %1, i64 %30
%33 = bitcast i8* %32 to <16 x i8>*
%34 = load <16 x i8>, <16 x i8>* %33
%35 = getelementptr inbounds i8, i8* %32, i64 16
%36 = bitcast i8* %35 to <16 x i8>*
%37 = load <16 x i8>, <16 x i8>* %36
%38 = xor i32 %31, -1
%39 = add i32 %12, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 %40
%42 = shufflevector <16 x i8> %34, <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>
%43 = getelementptr inbounds i8, i8* %41, i64 -15
%44 = bitcast i8* %43 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %44
%45 = shufflevector <16 x i8> %37, <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>
%46 = getelementptr inbounds i8, i8* %41, i64 -31
%47 = bitcast i8* %46 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %47
%48 = add nuw i64 %30, 32
%49 = icmp eq i64 %48, %28
br i1 %49, label %50, label %29
50: ; preds = %29
%51 = icmp eq i64 %28, %15
br i1 %51, label %112, label %52
52: ; preds = %50
%53 = and i64 %15, 24
%54 = icmp eq i64 %53, 0
br i1 %54, label %75, label %55
55: ; preds = %25, %52
%56 = phi i64 [ %28, %52 ], [ 0, %25 ]
%57 = and i64 %15, 4294967288
br label %58
58: ; preds = %58, %55
%59 = phi i64 [ %56, %55 ], [ %71, %58 ]
%60 = trunc i64 %59 to i32
%61 = getelementptr inbounds i8, i8* %1, i64 %59
%62 = bitcast i8* %61 to <8 x i8>*
%63 = load <8 x i8>, <8 x i8>* %62
%64 = xor i32 %60, -1
%65 = add i32 %12, %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 %66
%68 = shufflevector <8 x i8> %63, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%69 = getelementptr inbounds i8, i8* %67, i64 -7
%70 = bitcast i8* %69 to <8 x i8>*
store <8 x i8> %68, <8 x i8>* %70
%71 = add nuw i64 %59, 8
%72 = icmp eq i64 %71, %57
br i1 %72, label %73, label %58
73: ; preds = %58
%74 = icmp eq i64 %57, %15
br i1 %74, label %112, label %75
75: ; preds = %17, %14, %52, %73
%76 = phi i64 [ 0, %14 ], [ 0, %17 ], [ %28, %52 ], [ %57, %73 ]
%77 = xor i64 %76, -1
%78 = and i64 %15, 1
%79 = icmp eq i64 %78, 0
br i1 %79, label %89, label %80
80: ; preds = %75
%81 = getelementptr inbounds i8, i8* %1, i64 %76
%82 = load i8, i8* %81
%83 = trunc i64 %76 to i32
%84 = xor i32 %83, -1
%85 = add i32 %12, %84
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 %86
store i8 %82, i8* %87
%88 = or i64 %76, 1
br label %89
89: ; preds = %80, %75
%90 = phi i64 [ %76, %75 ], [ %88, %80 ]
%91 = sub nsw i64 0, %15
%92 = icmp eq i64 %77, %91
br i1 %92, label %112, label %93
93: ; preds = %89, %93
%94 = phi i64 [ %110, %93 ], [ %90, %89 ]
%95 = getelementptr inbounds i8, i8* %1, i64 %94
%96 = load i8, i8* %95
%97 = trunc i64 %94 to i32
%98 = xor i32 %97, -1
%99 = add i32 %12, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 %100
store i8 %96, i8* %101
%102 = add nuw nsw i64 %94, 1
%103 = getelementptr inbounds i8, i8* %1, i64 %102
%104 = load i8, i8* %103
%105 = trunc i64 %102 to i32
%106 = xor i32 %105, -1
%107 = add i32 %12, %106
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 %108
store i8 %104, i8* %109
%110 = add nuw nsw i64 %94, 2
%111 = icmp eq i64 %110, %15
br i1 %111, label %112, label %93
112: ; preds = %89, %93, %50, %73, %11
%113 = sext i32 %12 to i64
%114 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 %113
store i8 0, i8* %114
%115 = getelementptr inbounds [80 x i8], [80 x i8]* %6, i64 0, i64 1
%116 = getelementptr inbounds i8, i8* %1, i64 1
br label %117
117: ; preds = %112, %171
%118 = phi i32 [ 0, %112 ], [ %175, %171 ]
%119 = phi i32 [ 0, %112 ], [ %174, %171 ]
%120 = phi i32 [ 0, %112 ], [ %172, %171 ]
%121 = icmp eq i32 %119, 0
br i1 %121, label %130, label %122
122: ; preds = %117
%123 = add nsw i32 %118, 1
%124 = sext i32 %118 to i64
%125 = getelementptr inbounds [80 x i8], [80 x i8]* %6, i64 0, i64 %124
%126 = load i8, i8* %125
%127 = sext i8 %126 to i32
%128 = icmp eq i32 %123, %119
%129 = select i1 %128, i32 0, i32 %119
br label %140
130: ; preds = %117
%131 = call i32 @getc(i32* %7)
%132 = load i32, i32* @EOF
%133 = icmp eq i32 %131, %132
br i1 %133, label %134, label %140
134: ; preds = %130
%135 = call i64 @feof(i32* %7)
%136 = icmp eq i64 %135, 0
br i1 %136, label %137, label %252
137: ; preds = %134
%138 = call i64 @ferror(i32* %7)
%139 = icmp eq i64 %138, 0
br i1 %139, label %140, label %252
140: ; preds = %130, %137, %122
%141 = phi i32 [ %127, %122 ], [ %131, %137 ], [ %131, %130 ]
%142 = phi i32 [ %129, %122 ], [ 0, %137 ], [ 0, %130 ]
%143 = phi i32 [ %123, %122 ], [ %118, %137 ], [ %118, %130 ]
%144 = sext i32 %120 to i64
%145 = getelementptr inbounds i8, i8* %1, i64 %144
%146 = load i8, i8* %145
%147 = sext i8 %146 to i32
%148 = icmp eq i32 %141, %147
br i1 %148, label %149, label %153
149: ; preds = %140
%150 = add nsw i32 %120, 1
%151 = icmp eq i32 %150, %12
%152 = zext i1 %151 to i32
br label %171
153: ; preds = %140
%154 = icmp eq i32 %142, 0
br i1 %154, label %160, label %155
155: ; preds = %153
%156 = add nsw i32 %142, -1
%157 = icmp eq i32 %156, 0
br i1 %157, label %171, label %158
158: ; preds = %155
%159 = call i32 @memmove(i8* %9, i8* %115, i32 %156)
br label %171
160: ; preds = %153
%161 = icmp eq i32 %120, 0
br i1 %161, label %171, label %162
162: ; preds = %160
%163 = add nsw i32 %120, -1
%164 = icmp sgt i32 %120, 1
br i1 %164, label %165, label %167
165: ; preds = %162
%166 = call i32 @memcpy(i8* %9, i8* %116, i32 %163)
br label %167
167: ; preds = %165, %162
%168 = trunc i32 %141 to i8
%169 = sext i32 %163 to i64
%170 = getelementptr inbounds [80 x i8], [80 x i8]* %6, i64 0, i64 %169
store i8 %168, i8* %170
br label %171
171: ; preds = %149, %155, %158, %167, %160
%172 = phi i32 [ 0, %167 ], [ 0, %160 ], [ %150, %149 ], [ 0, %158 ], [ 0, %155 ]
%173 = phi i32 [ 0, %167 ], [ 0, %160 ], [ %152, %149 ], [ 0, %158 ], [ 0, %155 ]
%174 = phi i32 [ %120, %167 ], [ 0, %160 ], [ %142, %149 ], [ %156, %158 ], [ 0, %155 ]
%175 = phi i32 [ 0, %167 ], [ %143, %160 ], [ %143, %149 ], [ 0, %158 ], [ 0, %155 ]
%176 = icmp eq i32 %173, 0
br i1 %176, label %117, label %177
177: ; preds = %171, %177
%178 = call i32 @getc(i32* %7)
%179 = icmp eq i32 %178, 32
br i1 %179, label %177, label %180
180: ; preds = %177
%181 = load i32, i32* @EOF
%182 = icmp eq i32 %178, %181
br i1 %182, label %183, label %189
183: ; preds = %180
%184 = call i64 @feof(i32* %7)
%185 = icmp eq i64 %184, 0
br i1 %185, label %186, label %252
186: ; preds = %183
%187 = call i64 @ferror(i32* %7)
%188 = icmp eq i64 %187, 0
br i1 %188, label %189, label %252
189: ; preds = %186, %180
%190 = add nsw i32 %3, -1
%191 = load i8, i8* %8
%192 = sext i8 %191 to i32
%193 = sext i32 %190 to i64
br label %194
194: ; preds = %189, %229
%195 = phi i64 [ 0, %189 ], [ %230, %229 ]
%196 = phi i32 [ 0, %189 ], [ %218, %229 ]
%197 = phi i32 [ %178, %189 ], [ %220, %229 ]
%198 = icmp slt i64 %195, %193
br i1 %198, label %199, label %202
199: ; preds = %194
%200 = trunc i32 %197 to i8
%201 = getelementptr inbounds i8, i8* %2, i64 %195
store i8 %200, i8* %201
br label %202
202: ; preds = %199, %194
%203 = sext i32 %196 to i64
%204 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 %203
%205 = load i8, i8* %204
%206 = sext i8 %205 to i32
%207 = icmp eq i32 %197, %206
br i1 %207, label %208, label %212
208: ; preds = %202
%209 = add nsw i32 %196, 1
%210 = icmp eq i32 %209, %12
%211 = zext i1 %210 to i32
br label %217
212: ; preds = %202
%213 = icmp eq i32 %196, 0
br i1 %213, label %217, label %214
214: ; preds = %212
%215 = icmp eq i32 %197, %192
%216 = zext i1 %215 to i32
br label %217
217: ; preds = %208, %212, %214
%218 = phi i32 [ %216, %214 ], [ 0, %212 ], [ %209, %208 ]
%219 = phi i32 [ 0, %214 ], [ 0, %212 ], [ %211, %208 ]
%220 = call i32 @getc(i32* %7)
%221 = load i32, i32* @EOF
%222 = icmp eq i32 %220, %221
br i1 %222, label %223, label %229
223: ; preds = %217
%224 = call i64 @feof(i32* %7)
%225 = icmp eq i64 %224, 0
br i1 %225, label %226, label %252
226: ; preds = %223
%227 = call i64 @ferror(i32* %7)
%228 = icmp eq i64 %227, 0
br i1 %228, label %229, label %252
229: ; preds = %217, %226
%230 = add nuw i64 %195, 1
%231 = icmp eq i32 %219, 0
br i1 %231, label %194, label %232
232: ; preds = %229
%233 = trunc i64 %230 to i32
%234 = call i32 @fclose(i32* %7)
%235 = sub nsw i32 %233, %12
%236 = icmp slt i32 %235, %3
%237 = select i1 %236, i32 %235, i32 %190
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i8, i8* %2, i64 %238
store i8 0, i8* %239
%240 = icmp sgt i32 %237, 0
br i1 %240, label %241, label %255
241: ; preds = %232
%242 = zext i32 %237 to i64
br label %243
243: ; preds = %241, %250
%244 = phi i64 [ %242, %241 ], [ %245, %250 ]
%245 = add nsw i64 %244, -1
%246 = and i64 %245, 4294967295
%247 = getelementptr inbounds i8, i8* %2, i64 %246
%248 = load i8, i8* %247
%249 = icmp eq i8 %248, 32
br i1 %249, label %250, label %255
250: ; preds = %243
store i8 0, i8* %247
%251 = icmp ugt i64 %244, 1
br i1 %251, label %243, label %255
252: ; preds = %137, %134, %226, %223, %186, %183
%253 = phi i32 [ 2, %183 ], [ 3, %186 ], [ 2, %223 ], [ 3, %226 ], [ 2, %134 ], [ 3, %137 ]
%254 = call i32 @fclose(i32* %7)
br label %255
255: ; preds = %250, %243, %252, %232, %4
%256 = phi i32 [ 1, %4 ], [ 0, %232 ], [ %253, %252 ], [ 0, %243 ], [ 0, %250 ]
ret i32 %256
}