#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 */
char EOF;
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ free(char *);
char getc(int /*<<< orphan*/ *);
char *malloc(unsigned int);
int /*<<< orphan*/ printf(char *, ...);
char *realloc(char *, unsigned int);
int main(int argc, char *argv[]) {
  FILE *fp;
  unsigned sbs = 16, s = 0, rbs = 32, r = 0;
  char c;
  char *sb = malloc(sbs), *rb = malloc(rbs);
  if (argc != 2) {
    printf("Usage: %s [FILE]\n", argv[0]);
    return 1;
  }
  fp = fopen(*++argv, "r");
  while ((c = getc(fp)) != EOF) {
    if (c == '\n')
      continue;
    while (c != '\n' && c != EOF) {
      if (c == ' ' || c == '\t') {
        while (r + s > rbs - 1) {
          rbs += rbs / 2;
          rb = realloc(rb, rbs);
        }
        while (s > 0) {
          rb[r++] = sb[--s];
        }
        rb[r++] = ' ';
      } else {
        if (s == sbs - 1) {
          sbs += sbs / 2;
          sb = realloc(sb, sbs);
        }
        sb[s++] = c;
      }
      c = getc(fp);
    }
    sb[s] = '\0';
    printf("%s", sb);
    while (r > 0)
      printf("%c", rb[--r]);
    printf("\n");
    s = 0;
  }
  free(rb);
  free(sb);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x10,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x20,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x1c(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmpl   $0x2,-0x8(%rbp)
je     11d5 <main+0x75>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xe3e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    13e5 <main+0x285>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x8(%rax),%rdi
lea    0xe23(%rip),%rsi
call   1070 <fopen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1080 <getc@plt>
mov    %al,-0x29(%rbp)
movsbl %al,%eax
mov    0x2dda(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     13cc <main+0x26c>
movsbl -0x29(%rbp),%eax
cmp    $0xa,%eax
jne    122b <main+0xcb>
jmp    11f8 <main+0x98>
jmp    1230 <main+0xd0>
movsbl -0x29(%rbp),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x41(%rbp)
je     1258 <main+0xf8>
movsbl -0x29(%rbp),%eax
mov    0x2d9b(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    1268 <main+0x108>
jmp    1365 <main+0x205>
movsbl -0x29(%rbp),%eax
cmp    $0x20,%eax
je     1282 <main+0x122>
movsbl -0x29(%rbp),%eax
cmp    $0x9,%eax
jne    1310 <main+0x1b0>
jmp    1287 <main+0x127>
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jbe    12bc <main+0x15c>
mov    -0x24(%rbp),%eax
shr    $0x1,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x40(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x40(%rbp)
jmp    1287 <main+0x127>
jmp    12c1 <main+0x161>
cmpl   $0x0,-0x20(%rbp)
jbe    12f6 <main+0x196>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x20(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    12c1 <main+0x161>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
mov    %ecx,%ecx
movb   $0x20,(%rax,%rcx,1)
jmp    1354 <main+0x1f4>
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    133d <main+0x1dd>
mov    -0x1c(%rbp),%eax
shr    $0x1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x38(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1060 <realloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x29(%rbp),%dl
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rdi
call   1080 <getc@plt>
mov    %al,-0x29(%rbp)
jmp    1230 <main+0xd0>
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x38(%rbp),%rsi
lea    0xc99(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x28(%rbp)
jbe    13b2 <main+0x252>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x28(%rbp)
mov    %ecx,%ecx
movsbl (%rax,%rcx,1),%esi
lea    0xc71(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    1382 <main+0x222>
lea    0xc57(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x20(%rbp)
jmp    11f8 <main+0x98>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rsi,%r14
mov    %edi,%ebp
mov    $0x10,%eax
mov    %rax,0x18(%rsp)
mov    $0x10,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0x20,%r12d
mov    $0x20,%edi
call   1060 <malloc@plt>
cmp    $0x2,%ebp
jne    1505 <main+0x395>
mov    %rax,%r13
mov    0x8(%r14),%rdi
lea    0xe51(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,%r14
mov    0x2e18(%rip),%rbx
mov    %r14,%rdi
call   1090 <getc@plt>
cmp    (%rbx),%al
je     151d <main+0x3ad>
mov    %eax,%ebp
cmp    $0xa,%al
je     11d0 <main+0x60>
mov    %r14,0x20(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x20,%bpl
je     120c <main+0x9c>
cmp    $0x9,%bpl
jne    1280 <main+0x110>
mov    %r15,0x10(%rsp)
mov    0x8(%rsp),%rax
lea    (%rax,%r14,1),%ebx
lea    -0x1(%r12),%eax
cmp    %eax,%ebx
jbe    1255 <main+0xe5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r12d,%r15d
shr    %r15d
lea    (%r15,%r12,1),%ebp
mov    %r13,%rdi
mov    %ebp,%esi
call   1070 <realloc@plt>
mov    %rax,%r13
lea    (%r15,%r12,1),%eax
add    $0xffffffff,%eax
mov    %ebp,%r12d
cmp    %eax,%ebx
ja     1230 <main+0xc0>
mov    %r13,%r9
test   %r14d,%r14d
je     12c0 <main+0x150>
mov    %r14d,%edx
cmp    $0x20,%r14d
jae    12d0 <main+0x160>
mov    %rdx,%rcx
mov    0x8(%rsp),%r14
mov    0x10(%rsp),%r15
jmp    1316 <main+0x1a6>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
lea    -0x1(%rcx),%eax
cmp    %eax,%r14d
jne    12a2 <main+0x132>
mov    %ecx,%ebx
shr    %ebx
add    %ecx,%ebx
mov    %r15,%rdi
mov    %ebx,%esi
call   1070 <realloc@plt>
mov    %rax,%r15
mov    %ebx,%ecx
mov    %rcx,0x18(%rsp)
lea    0x1(%r14),%ebx
mov    %r15,%r9
jmp    13b3 <main+0x243>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x8(%rsp),%r14
mov    0x10(%rsp),%r15
jmp    13a2 <main+0x232>
nop
lea    -0x1(%rdx),%rcx
mov    0x8(%rsp),%rax
mov    %eax,%esi
add    %ecx,%esi
mov    0x10(%rsp),%r15
pxor   %xmm3,%xmm3
jb     1310 <main+0x1a0>
shr    $0x20,%rcx
jne    1310 <main+0x1a0>
mov    %eax,%ecx
lea    (%rdx,%rcx,1),%rsi
add    %r9,%rsi
cmp    %rsi,%r15
jae    13e6 <main+0x276>
lea    (%r15,%rdx,1),%rsi
add    %r9,%rcx
cmp    %rsi,%rcx
jae    13e6 <main+0x276>
mov    %rdx,%rcx
mov    %eax,%r14d
lea    -0x1(%rcx),%rdx
mov    %rcx,%rsi
and    $0x3,%rsi
je     134b <main+0x1db>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl -0x1(%r15,%rcx,1),%ebx
add    $0xffffffffffffffff,%rcx
mov    %r14d,%edi
add    $0x1,%r14d
mov    %bl,(%r9,%rdi,1)
add    $0xffffffffffffffff,%rsi
jne    1330 <main+0x1c0>
cmp    $0x3,%rdx
jb     13a2 <main+0x232>
lea    -0x1(%r15),%rdx
mov    %r14d,%r8d
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
lea    (%r8,%rdi,1),%rbp
movzbl (%rdx,%rcx,1),%ebx
lea    0x1(%rbp),%esi
mov    %ebp,%eax
mov    %bl,(%r9,%rax,1)
movzbl -0x1(%rdx,%rcx,1),%eax
lea    0x2(%rbp),%ebx
mov    %al,(%r9,%rsi,1)
movzbl -0x2(%rdx,%rcx,1),%eax
add    $0x3,%ebp
mov    %al,(%r9,%rbx,1)
movzbl -0x3(%rdx,%rcx,1),%eax
mov    %al,(%r9,%rbp,1)
add    $0x4,%rdi
add    $0xfffffffffffffffc,%rdx
cmp    %rdi,%rcx
jne    1360 <main+0x1f0>
add    %edi,%r14d
lea    0x1(%r14),%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
mov    $0x20,%bpl
mov    %r9,%r13
mov    %r14d,%eax
mov    %bpl,(%r9,%rax,1)
mov    0x20(%rsp),%rdi
call   1090 <getc@plt>
cmp    $0xa,%al
je     14b0 <main+0x340>
mov    %eax,%ebp
mov    %ebx,%r14d
mov    0x2c10(%rip),%rax
cmp    (%rax),%bpl
jne    1200 <main+0x90>
jmp    14b0 <main+0x340>
mov    %edx,%r8d
and    $0xffffffe0,%r8d
mov    %edx,%ecx
and    $0x1f,%ecx
lea    (%rax,%r8,1),%r14d
lea    (%r15,%rdx,1),%rdi
add    $0xfffffffffffffff0,%rdi
mov    %r8,%rsi
neg    %rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rdi,%rbx,1),%xmm0
movdqu (%rdi,%rbx,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqa %xmm0,%xmm2
punpcklbw %xmm3,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm3,%xmm0
pshufd $0x4e,%xmm0,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
mov    %eax,%ebp
movdqu %xmm1,(%r9,%rbp,1)
movdqu %xmm0,0x10(%r9,%rbp,1)
add    $0xffffffffffffffe0,%rbx
add    $0x20,%eax
cmp    %rbx,%rsi
jne    1410 <main+0x2a0>
cmp    %rdx,%r8
jne    1316 <main+0x1a6>
jmp    13a2 <main+0x232>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%eax
movb   $0x0,(%r15,%rax,1)
lea    0xb56(%rip),%rdi
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x8(%rsp),%rax
test   %eax,%eax
je     14f1 <main+0x381>
mov    %eax,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsbl -0x1(%r13,%rbx,1),%edi
call   1040 <putchar@plt>
add    $0xffffffffffffffff,%rbx
jne    14e0 <main+0x370>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x20(%rsp),%r14
jmp    11c9 <main+0x59>
mov    (%r14),%rsi
lea    0xaf1(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
mov    $0x1,%eax
jmp    152f <main+0x3bf>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [18 x i8] c"Usage: %s [FILE]\0A\00"
@.str.1 = [2 x i8] c"r\00"
@EOF = global i8 0
@.str.2 = [3 x i8] c"%s\00"
@.str.3 = [3 x i8] c"%c\00"
@.str.4 = [2 x i8] c"\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 i32
%11 = alloca i8
%12 = alloca i8*
%13 = alloca i8*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 16, i32* %7
store i32 0, i32* %8
store i32 32, i32* %9
store i32 0, i32* %10
%14 = load i32, i32* %7
%15 = call i8* @malloc(i32 %14)
store i8* %15, i8** %12
%16 = load i32, i32* %9
%17 = call i8* @malloc(i32 %16)
store i8* %17, i8** %13
%18 = load i32, i32* %4
%19 = icmp ne i32 %18, 2
br i1 %19, label %20, label %25
20: ; preds = %2
%21 = load i8**, i8*** %5
%22 = getelementptr inbounds i8*, i8** %21, i64 0
%23 = load i8*, i8** %22
%24 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %23)
store i32 1, i32* %3
br label %150
25: ; preds = %2
%26 = load i8**, i8*** %5
%27 = getelementptr inbounds i8*, i8** %26, i32 1
store i8** %27, i8*** %5
%28 = load i8*, i8** %27
%29 = call i32* @fopen(i8* %28, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %29, i32** %6
br label %30
30: ; preds = %143, %41, %25
%31 = load i32*, i32** %6
%32 = call signext i8 @getc(i32* %31)
store i8 %32, i8* %11
%33 = sext i8 %32 to i32
%34 = load i8, i8* @EOF
%35 = sext i8 %34 to i32
%36 = icmp ne i32 %33, %35
br i1 %36, label %37, label %145
37: ; preds = %30
%38 = load i8, i8* %11
%39 = sext i8 %38 to i32
%40 = icmp eq i32 %39, 10
br i1 %40, label %41, label %42
41: ; preds = %37
br label %30
42: ; preds = %37
br label %43
43: ; preds = %121, %42
%44 = load i8, i8* %11
%45 = sext i8 %44 to i32
%46 = icmp ne i32 %45, 10
br i1 %46, label %47, label %53
47: ; preds = %43
%48 = load i8, i8* %11
%49 = sext i8 %48 to i32
%50 = load i8, i8* @EOF
%51 = sext i8 %50 to i32
%52 = icmp ne i32 %49, %51
br label %53
53: ; preds = %47, %43
%54 = phi i1 [ false, %43 ], [ %52, %47 ]
br i1 %54, label %55, label %124
55: ; preds = %53
%56 = load i8, i8* %11
%57 = sext i8 %56 to i32
%58 = icmp eq i32 %57, 32
br i1 %58, label %63, label %59
59: ; preds = %55
%60 = load i8, i8* %11
%61 = sext i8 %60 to i32
%62 = icmp eq i32 %61, 9
br i1 %62, label %63, label %101
63: ; preds = %59, %55
br label %64
64: ; preds = %71, %63
%65 = load i32, i32* %10
%66 = load i32, i32* %8
%67 = add i32 %65, %66
%68 = load i32, i32* %9
%69 = sub i32 %68, 1
%70 = icmp ugt i32 %67, %69
br i1 %70, label %71, label %79
71: ; preds = %64
%72 = load i32, i32* %9
%73 = udiv i32 %72, 2
%74 = load i32, i32* %9
%75 = add i32 %74, %73
store i32 %75, i32* %9
%76 = load i8*, i8** %13
%77 = load i32, i32* %9
%78 = call i8* @realloc(i8* %76, i32 %77)
store i8* %78, i8** %13
br label %64
79: ; preds = %64
br label %80
80: ; preds = %83, %79
%81 = load i32, i32* %8
%82 = icmp ugt i32 %81, 0
br i1 %82, label %83, label %95
83: ; preds = %80
%84 = load i8*, i8** %12
%85 = load i32, i32* %8
%86 = add i32 %85, -1
store i32 %86, i32* %8
%87 = zext i32 %86 to i64
%88 = getelementptr inbounds i8, i8* %84, i64 %87
%89 = load i8, i8* %88
%90 = load i8*, i8** %13
%91 = load i32, i32* %10
%92 = add i32 %91, 1
store i32 %92, i32* %10
%93 = zext i32 %91 to i64
%94 = getelementptr inbounds i8, i8* %90, i64 %93
store i8 %89, i8* %94
br label %80
95: ; preds = %80
%96 = load i8*, i8** %13
%97 = load i32, i32* %10
%98 = add i32 %97, 1
store i32 %98, i32* %10
%99 = zext i32 %97 to i64
%100 = getelementptr inbounds i8, i8* %96, i64 %99
store i8 32, i8* %100
br label %121
101: ; preds = %59
%102 = load i32, i32* %8
%103 = load i32, i32* %7
%104 = sub i32 %103, 1
%105 = icmp eq i32 %102, %104
br i1 %105, label %106, label %114
106: ; preds = %101
%107 = load i32, i32* %7
%108 = udiv i32 %107, 2
%109 = load i32, i32* %7
%110 = add i32 %109, %108
store i32 %110, i32* %7
%111 = load i8*, i8** %12
%112 = load i32, i32* %7
%113 = call i8* @realloc(i8* %111, i32 %112)
store i8* %113, i8** %12
br label %114
114: ; preds = %106, %101
%115 = load i8, i8* %11
%116 = load i8*, i8** %12
%117 = load i32, i32* %8
%118 = add i32 %117, 1
store i32 %118, i32* %8
%119 = zext i32 %117 to i64
%120 = getelementptr inbounds i8, i8* %116, i64 %119
store i8 %115, i8* %120
br label %121
121: ; preds = %114, %95
%122 = load i32*, i32** %6
%123 = call signext i8 @getc(i32* %122)
store i8 %123, i8* %11
br label %43
124: ; preds = %53
%125 = load i8*, i8** %12
%126 = load i32, i32* %8
%127 = zext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %125, i64 %127
store i8 0, i8* %128
%129 = load i8*, i8** %12
%130 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %129)
br label %131
131: ; preds = %134, %124
%132 = load i32, i32* %10
%133 = icmp ugt i32 %132, 0
br i1 %133, label %134, label %143
134: ; preds = %131
%135 = load i8*, i8** %13
%136 = load i32, i32* %10
%137 = add i32 %136, -1
store i32 %137, i32* %10
%138 = zext i32 %137 to i64
%139 = getelementptr inbounds i8, i8* %135, i64 %138
%140 = load i8, i8* %139
%141 = sext i8 %140 to i32
%142 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32 %141)
br label %131
143: ; preds = %131
%144 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0))
store i32 0, i32* %8
br label %30
145: ; preds = %30
%146 = load i8*, i8** %13
%147 = call i32 @free(i8* %146)
%148 = load i8*, i8** %12
%149 = call i32 @free(i8* %148)
store i32 0, i32* %3
br label %150
150: ; preds = %145, %20
%151 = load i32, i32* %3
ret i32 %151
}

LLVM IR (-O2):
@.str = [18 x i8] c"Usage: %s [FILE]\0A\00"
@.str.1 = [2 x i8] c"r\00"
@EOF = global i8 0
@.str.2 = [3 x i8] c"%s\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = tail call dereferenceable_or_null(16) i8* @malloc(i32 16)
%4 = tail call dereferenceable_or_null(32) i8* @malloc(i32 32)
%5 = icmp eq i32 %0, 2
br i1 %5, label %9, label %6
6: ; preds = %2
%7 = load i8*, i8** %1
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %7)
br label %199
9: ; preds = %2
%10 = getelementptr inbounds i8*, i8** %1, i64 1
%11 = load i8*, i8** %10
%12 = tail call i32* @fopen(i8* %11, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %13
13: ; preds = %194, %9
%14 = phi i32 [ %166, %194 ], [ 16, %9 ]
%15 = phi i32 [ %168, %194 ], [ 32, %9 ]
%16 = phi i8* [ %170, %194 ], [ %3, %9 ]
%17 = phi i8* [ %171, %194 ], [ %4, %9 ]
br label %18
18: ; preds = %13, %22
%19 = tail call signext i8 @getc(i32* %12)
%20 = load i8, i8* @EOF
%21 = icmp eq i8 %19, %20
br i1 %21, label %196, label %22
22: ; preds = %18
%23 = icmp eq i8 %19, 10
br i1 %23, label %18, label %24
24: ; preds = %22, %162
%25 = phi i8* [ %171, %162 ], [ %17, %22 ]
%26 = phi i8* [ %170, %162 ], [ %16, %22 ]
%27 = phi i8 [ %174, %162 ], [ %19, %22 ]
%28 = phi i32 [ %169, %162 ], [ 0, %22 ]
%29 = phi i32 [ %168, %162 ], [ %15, %22 ]
%30 = phi i32 [ %167, %162 ], [ 0, %22 ]
%31 = phi i32 [ %166, %162 ], [ %14, %22 ]
switch i8 %27, label %151 [
i8 32, label %32
i8 9, label %32
]
32: ; preds = %24, %24
%33 = add i32 %28, %30
%34 = add i32 %29, -1
%35 = icmp ugt i32 %33, %34
br i1 %35, label %112, label %36
36: ; preds = %112, %32
%37 = phi i32 [ %29, %32 ], [ %116, %112 ]
%38 = phi i8* [ %25, %32 ], [ %117, %112 ]
%39 = icmp eq i32 %30, 0
br i1 %39, label %148, label %40
40: ; preds = %36
%41 = zext i32 %30 to i64
%42 = icmp ult i32 %30, 32
br i1 %42, label %89, label %43
43: ; preds = %40
%44 = add nsw i64 %41, -1
%45 = trunc i64 %44 to i32
%46 = xor i32 %28, -1
%47 = icmp ult i32 %46, %45
%48 = icmp ugt i64 %44, 4294967295
%49 = or i1 %47, %48
br i1 %49, label %89, label %50
50: ; preds = %43
%51 = getelementptr i8, i8* %26, i64 %41
%52 = zext i32 %28 to i64
%53 = getelementptr i8, i8* %38, i64 %52
%54 = add nuw nsw i64 %41, %52
%55 = getelementptr i8, i8* %38, i64 %54
%56 = icmp ult i8* %26, %55
%57 = icmp ult i8* %53, %51
%58 = and i1 %56, %57
br i1 %58, label %89, label %59
59: ; preds = %50
%60 = and i64 %41, 4294967264
%61 = and i64 %41, 31
%62 = trunc i64 %60 to i32
%63 = add i32 %28, %62
br label %64
64: ; preds = %64, %59
%65 = phi i64 [ 0, %59 ], [ %85, %64 ]
%66 = trunc i64 %65 to i32
%67 = add i32 %28, %66
%68 = xor i64 %65, -1
%69 = add i64 %68, %41
%70 = getelementptr inbounds i8, i8* %26, i64 %69
%71 = getelementptr inbounds i8, i8* %70, i64 -15
%72 = bitcast i8* %71 to <16 x i8>*
%73 = load <16 x i8>, <16 x i8>* %72
%74 = shufflevector <16 x i8> %73, <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>
%75 = getelementptr inbounds i8, i8* %70, i64 -16
%76 = getelementptr inbounds i8, i8* %75, i64 -15
%77 = bitcast i8* %76 to <16 x i8>*
%78 = load <16 x i8>, <16 x i8>* %77
%79 = shufflevector <16 x i8> %78, <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>
%80 = zext i32 %67 to i64
%81 = getelementptr inbounds i8, i8* %38, i64 %80
%82 = bitcast i8* %81 to <16 x i8>*
store <16 x i8> %74, <16 x i8>* %82
%83 = getelementptr inbounds i8, i8* %81, i64 16
%84 = bitcast i8* %83 to <16 x i8>*
store <16 x i8> %79, <16 x i8>* %84
%85 = add nuw i64 %65, 32
%86 = icmp eq i64 %85, %60
br i1 %86, label %87, label %64
87: ; preds = %64
%88 = icmp eq i64 %60, %41
br i1 %88, label %148, label %89
89: ; preds = %50, %43, %40, %87
%90 = phi i64 [ %41, %50 ], [ %41, %43 ], [ %41, %40 ], [ %61, %87 ]
%91 = phi i32 [ %28, %50 ], [ %28, %43 ], [ %28, %40 ], [ %63, %87 ]
%92 = add nsw i64 %90, -1
%93 = and i64 %90, 3
%94 = icmp eq i64 %93, 0
br i1 %94, label %107, label %95
95: ; preds = %89, %95
%96 = phi i64 [ %99, %95 ], [ %90, %89 ]
%97 = phi i32 [ %102, %95 ], [ %91, %89 ]
%98 = phi i64 [ %105, %95 ], [ 0, %89 ]
%99 = add nsw i64 %96, -1
%100 = getelementptr inbounds i8, i8* %26, i64 %99
%101 = load i8, i8* %100
%102 = add i32 %97, 1
%103 = zext i32 %97 to i64
%104 = getelementptr inbounds i8, i8* %38, i64 %103
store i8 %101, i8* %104
%105 = add i64 %98, 1
%106 = icmp eq i64 %105, %93
br i1 %106, label %107, label %95
107: ; preds = %95, %89
%108 = phi i32 [ undef, %89 ], [ %102, %95 ]
%109 = phi i64 [ %90, %89 ], [ %99, %95 ]
%110 = phi i32 [ %91, %89 ], [ %102, %95 ]
%111 = icmp ult i64 %92, 3
br i1 %111, label %148, label %120
112: ; preds = %32, %112
%113 = phi i8* [ %117, %112 ], [ %25, %32 ]
%114 = phi i32 [ %116, %112 ], [ %29, %32 ]
%115 = lshr i32 %114, 1
%116 = add i32 %115, %114
%117 = tail call i8* @realloc(i8* %113, i32 %116)
%118 = add i32 %116, -1
%119 = icmp ugt i32 %33, %118
br i1 %119, label %112, label %36
120: ; preds = %107, %120
%121 = phi i64 [ %141, %120 ], [ %109, %107 ]
%122 = phi i32 [ %144, %120 ], [ %110, %107 ]
%123 = add nsw i64 %121, -1
%124 = getelementptr inbounds i8, i8* %26, i64 %123
%125 = load i8, i8* %124
%126 = add i32 %122, 1
%127 = zext i32 %122 to i64
%128 = getelementptr inbounds i8, i8* %38, i64 %127
store i8 %125, i8* %128
%129 = add nsw i64 %121, -2
%130 = getelementptr inbounds i8, i8* %26, i64 %129
%131 = load i8, i8* %130
%132 = add i32 %122, 2
%133 = zext i32 %126 to i64
%134 = getelementptr inbounds i8, i8* %38, i64 %133
store i8 %131, i8* %134
%135 = add nsw i64 %121, -3
%136 = getelementptr inbounds i8, i8* %26, i64 %135
%137 = load i8, i8* %136
%138 = add i32 %122, 3
%139 = zext i32 %132 to i64
%140 = getelementptr inbounds i8, i8* %38, i64 %139
store i8 %137, i8* %140
%141 = add nsw i64 %121, -4
%142 = getelementptr inbounds i8, i8* %26, i64 %141
%143 = load i8, i8* %142
%144 = add i32 %122, 4
%145 = zext i32 %138 to i64
%146 = getelementptr inbounds i8, i8* %38, i64 %145
store i8 %143, i8* %146
%147 = icmp eq i64 %141, 0
br i1 %147, label %148, label %120
148: ; preds = %107, %120, %87, %36
%149 = phi i32 [ %28, %36 ], [ %63, %87 ], [ %108, %107 ], [ %144, %120 ]
%150 = add i32 %149, 1
br label %162
151: ; preds = %24
%152 = add i32 %31, -1
%153 = icmp eq i32 %30, %152
br i1 %153, label %154, label %158
154: ; preds = %151
%155 = lshr i32 %31, 1
%156 = add i32 %155, %31
%157 = tail call i8* @realloc(i8* %26, i32 %156)
br label %158
158: ; preds = %154, %151
%159 = phi i32 [ %156, %154 ], [ %31, %151 ]
%160 = phi i8* [ %157, %154 ], [ %26, %151 ]
%161 = add i32 %30, 1
br label %162
162: ; preds = %158, %148
%163 = phi i32 [ %30, %158 ], [ %149, %148 ]
%164 = phi i8* [ %160, %158 ], [ %38, %148 ]
%165 = phi i8 [ %27, %158 ], [ 32, %148 ]
%166 = phi i32 [ %159, %158 ], [ %31, %148 ]
%167 = phi i32 [ %161, %158 ], [ 0, %148 ]
%168 = phi i32 [ %29, %158 ], [ %37, %148 ]
%169 = phi i32 [ %28, %158 ], [ %150, %148 ]
%170 = phi i8* [ %160, %158 ], [ %26, %148 ]
%171 = phi i8* [ %25, %158 ], [ %38, %148 ]
%172 = zext i32 %163 to i64
%173 = getelementptr inbounds i8, i8* %164, i64 %172
store i8 %165, i8* %173
%174 = tail call signext i8 @getc(i32* %12)
%175 = icmp ne i8 %174, 10
%176 = load i8, i8* @EOF
%177 = icmp ne i8 %174, %176
%178 = select i1 %175, i1 %177, i1 false
br i1 %178, label %24, label %179
179: ; preds = %162
%180 = zext i32 %167 to i64
%181 = getelementptr inbounds i8, i8* %170, i64 %180
store i8 0, i8* %181
%182 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %170)
%183 = icmp eq i32 %169, 0
br i1 %183, label %194, label %184
184: ; preds = %179
%185 = zext i32 %169 to i64
br label %186
186: ; preds = %184, %186
%187 = phi i64 [ %185, %184 ], [ %188, %186 ]
%188 = add nsw i64 %187, -1
%189 = getelementptr inbounds i8, i8* %171, i64 %188
%190 = load i8, i8* %189
%191 = sext i8 %190 to i32
%192 = tail call i32 @putchar(i32 %191)
%193 = icmp eq i64 %188, 0
br i1 %193, label %194, label %186
194: ; preds = %186, %179
%195 = tail call i32 @putchar(i32 10)
br label %13
196: ; preds = %18
%197 = tail call i32 @free(i8* %17)
%198 = tail call i32 @free(i8* %16)
br label %199
199: ; preds = %196, %6
%200 = phi i32 [ 1, %6 ], [ 0, %196 ]
ret i32 %200
}