#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 *);
char getc(int /*<<< orphan*/ *);
int /*<<< orphan*/ printf(char *, ...);
int main(int argc, char *argv[]) {
  FILE *fp;
  char c;
  unsigned i, j, k, r, t, ll[32], cl[32];
  if (argc != 2) {
    printf("Usage: %s [FILE]\n", argv[0]);
    return 1;
  }
  fp = fopen(*++argv, "r");
  while ((c = getc(fp)) != EOF) {
    r = 0;
    for (j = 0; j < 32; j++) {
      ll[j] = 0;
      cl[j] = 0;
    }
    i = 0;
    j = 1;
    do {
      if (c == '|') {
        for (k = 1; k < 31; k++) {
          ll[k] = cl[k];
          cl[k] = 0;
        }
        i++;
        j = 0;
      } else if (c == 'o') {
        if (ll[j - 1] > 0)
          cl[j] = ll[j - 1];
        else if (ll[j] > 0)
          cl[j] = ll[j];
        else if (cl[j - 1] > 0)
          cl[j] = cl[j - 1];
        if (ll[j + 1] > 0) {
          if (cl[j] == 0) {
            cl[j] = ll[j + 1];
          } else if (cl[j] != ll[j + 1]) {
            t = ll[j + 1];
            for (k = j + 1; k < 31; k++)
              if (ll[k] == t)
                ll[k] = cl[j];
            for (k = 1; k < j - 1; k++)
              if (cl[k] == t)
                cl[k] = cl[j];
            r--;
          }
        }
        if (cl[j] == 0) {
          cl[j] = i * 32 + j;
          r++;
        }
      }
      j++;
      if ((c = getc(fp)) == EOF || c == '\n')
        break;
      c = getc(fp);
    } while (c != '\n' && c != EOF);
    printf("%d\n", r);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
je     1174 <main+0x44>
mov    -0x10(%rbp),%rax
mov    (%rax),%rsi
lea    0xe9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    150f <main+0x3df>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x10(%rbp)
mov    0x8(%rax),%rdi
lea    0xe84(%rip),%rsi
call   1040 <fopen@plt>
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <getc@plt>
mov    %al,-0x19(%rbp)
movsbl %al,%eax
mov    0x2e3b(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     1508 <main+0x3d8>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x20,-0x24(%rbp)
jae    11fa <main+0xca>
mov    -0x24(%rbp),%eax
movl   $0x0,-0xb0(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
movl   $0x0,-0x130(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11c6 <main+0x96>
movl   $0x0,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
movsbl -0x19(%rbp),%eax
cmp    $0x7c,%eax
jne    126b <main+0x13b>
movl   $0x1,-0x28(%rbp)
cmpl   $0x1f,-0x28(%rbp)
jae    1256 <main+0x126>
mov    -0x28(%rbp),%eax
mov    -0x130(%rbp,%rax,4),%ecx
mov    -0x28(%rbp),%eax
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
movl   $0x0,-0x130(%rbp,%rax,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    121c <main+0xec>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
jmp    146e <main+0x33e>
movsbl -0x19(%rbp),%eax
cmp    $0x6f,%eax
jne    1469 <main+0x339>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
cmpl   $0x0,-0xb0(%rbp,%rax,4)
jbe    12ac <main+0x17c>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    -0xb0(%rbp,%rax,4),%ecx
mov    -0x24(%rbp),%eax
mov    %ecx,-0x130(%rbp,%rax,4)
jmp    130f <main+0x1df>
mov    -0x24(%rbp),%eax
cmpl   $0x0,-0xb0(%rbp,%rax,4)
jbe    12d6 <main+0x1a6>
mov    -0x24(%rbp),%eax
mov    -0xb0(%rbp,%rax,4),%ecx
mov    -0x24(%rbp),%eax
mov    %ecx,-0x130(%rbp,%rax,4)
jmp    130a <main+0x1da>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
cmpl   $0x0,-0x130(%rbp,%rax,4)
jbe    1305 <main+0x1d5>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,%eax
mov    -0x130(%rbp,%rax,4),%ecx
mov    -0x24(%rbp),%eax
mov    %ecx,-0x130(%rbp,%rax,4)
jmp    130a <main+0x1da>
jmp    130f <main+0x1df>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
cmpl   $0x0,-0xb0(%rbp,%rax,4)
jbe    1437 <main+0x307>
mov    -0x24(%rbp),%eax
cmpl   $0x0,-0x130(%rbp,%rax,4)
jne    1354 <main+0x224>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
mov    -0xb0(%rbp,%rax,4),%ecx
mov    -0x24(%rbp),%eax
mov    %ecx,-0x130(%rbp,%rax,4)
jmp    1432 <main+0x302>
mov    -0x24(%rbp),%eax
mov    -0x130(%rbp,%rax,4),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
cmp    -0xb0(%rbp,%rcx,4),%eax
je     142d <main+0x2fd>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,%eax
mov    -0xb0(%rbp,%rax,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x1f,-0x28(%rbp)
jae    13d2 <main+0x2a2>
mov    -0x28(%rbp),%eax
mov    -0xb0(%rbp,%rax,4),%eax
cmp    -0x30(%rbp),%eax
jne    13bf <main+0x28f>
mov    -0x24(%rbp),%eax
mov    -0x130(%rbp,%rax,4),%ecx
mov    -0x28(%rbp),%eax
mov    %ecx,-0xb0(%rbp,%rax,4)
jmp    13c4 <main+0x294>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    138e <main+0x25e>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    1424 <main+0x2f4>
mov    -0x28(%rbp),%eax
mov    -0x130(%rbp,%rax,4),%eax
cmp    -0x30(%rbp),%eax
jne    1411 <main+0x2e1>
mov    -0x24(%rbp),%eax
mov    -0x130(%rbp,%rax,4),%ecx
mov    -0x28(%rbp),%eax
mov    %ecx,-0x130(%rbp,%rax,4)
jmp    1416 <main+0x2e6>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13d9 <main+0x2a9>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1432 <main+0x302>
jmp    1437 <main+0x307>
mov    -0x24(%rbp),%eax
cmpl   $0x0,-0x130(%rbp,%rax,4)
jne    1464 <main+0x334>
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
add    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%eax
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1469 <main+0x339>
jmp    146e <main+0x33e>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <getc@plt>
mov    %al,-0x19(%rbp)
movsbl %al,%eax
mov    0x2b5b(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
je     14a5 <main+0x375>
movsbl -0x19(%rbp),%eax
cmp    $0xa,%eax
jne    14aa <main+0x37a>
jmp    14f2 <main+0x3c2>
mov    -0x18(%rbp),%rdi
call   1050 <getc@plt>
mov    %al,-0x19(%rbp)
movsbl -0x19(%rbp),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x131(%rbp)
je     14e4 <main+0x3b4>
movsbl -0x19(%rbp),%eax
mov    0x2b12(%rip),%rcx
movsbl (%rcx),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x131(%rbp)
mov    -0x131(%rbp),%al
test   $0x1,%al
jne    1208 <main+0xd8>
mov    -0x2c(%rbp),%esi
lea    0xb18(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1197 <main+0x67>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
cmp    $0x2,%edi
jne    1655 <main+0x525>
mov    0x8(%rsi),%rdi
lea    0xebd(%rip),%rsi
call   1040 <fopen@plt>
mov    %rax,%r15
mov    %rax,%rdi
call   1050 <getc@plt>
mov    0x2e7c(%rip),%r12
xor    %ebp,%ebp
cmp    (%r12),%al
je     166b <main+0x53b>
lea    0xe95(%rip),%rbx
jmp    11b2 <main+0x82>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
mov    %rbx,%rdi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1030 <printf@plt>
mov    %r15,%rdi
call   1050 <getc@plt>
cmp    (%r12),%al
je     166b <main+0x53b>
pxor   %xmm0,%xmm0
movdqa %xmm0,0x110(%rsp)
movdqa %xmm0,0x100(%rsp)
movdqa %xmm0,0xf0(%rsp)
movdqa %xmm0,0xe0(%rsp)
movdqa %xmm0,0xd0(%rsp)
movdqa %xmm0,0xc0(%rsp)
movdqa %xmm0,0xb0(%rsp)
movdqa %xmm0,0xa0(%rsp)
movdqa %xmm0,0x10(%rsp)
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x60(%rsp)
movdqa %xmm0,0x70(%rsp)
movdqa %xmm0,0x80(%rsp)
mov    $0x1,%r13d
xor    %r14d,%r14d
movl   $0x0,0xc(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    $0x6f,%al
je     1330 <main+0x200>
cmp    $0x7c,%al
jne    15b0 <main+0x480>
movups 0x14(%rsp),%xmm0
movdqu 0x24(%rsp),%xmm1
movdqu 0x34(%rsp),%xmm2
movdqu 0x44(%rsp),%xmm3
movups %xmm0,0xa4(%rsp)
pxor   %xmm4,%xmm4
movdqu %xmm4,0x14(%rsp)
movdqu %xmm1,0xb4(%rsp)
movdqu %xmm4,0x24(%rsp)
movdqu %xmm2,0xc4(%rsp)
movdqu %xmm4,0x34(%rsp)
movdqu %xmm3,0xd4(%rsp)
movdqu %xmm4,0x44(%rsp)
movups 0x54(%rsp),%xmm0
movups %xmm0,0xe4(%rsp)
movdqu %xmm4,0x54(%rsp)
movups 0x64(%rsp),%xmm0
movups %xmm0,0xf4(%rsp)
movdqu %xmm4,0x64(%rsp)
movdqu 0x74(%rsp),%xmm0
movdqu %xmm0,0x104(%rsp)
movdqu %xmm4,0x74(%rsp)
mov    0x84(%rsp),%eax
mov    %eax,0x114(%rsp)
movl   $0x0,0x84(%rsp)
mov    0x88(%rsp),%eax
mov    %eax,0x118(%rsp)
movl   $0x0,0x88(%rsp)
add    $0x1,%r14d
xor    %r13d,%r13d
jmp    15b0 <main+0x480>
nop
lea    -0x1(%r13),%r11d
mov    0xa0(%rsp,%r11,4),%ecx
mov    %r13d,%eax
test   %ecx,%ecx
jne    1360 <main+0x230>
mov    0xa0(%rsp,%rax,4),%ecx
test   %ecx,%ecx
jne    1360 <main+0x230>
mov    0x10(%rsp,%r11,4),%ecx
test   %ecx,%ecx
je     1364 <main+0x234>
nopw   0x0(%rax,%rax,1)
mov    %ecx,0x10(%rsp,%rax,4)
lea    0x1(%r13),%ebp
mov    0xa0(%rsp,%rbp,4),%edx
test   %edx,%edx
je     1590 <main+0x460>
mov    0x10(%rsp,%rax,4),%esi
test   %esi,%esi
je     15ed <main+0x4bd>
cmp    %edx,%esi
je     1590 <main+0x460>
cmp    $0x1e,%ebp
ja     155c <main+0x42c>
mov    %esi,0xa0(%rsp,%rbp,4)
lea    0x1(%rbp),%rdi
cmp    $0x1f,%edi
je     155c <main+0x42c>
mov    $0x1c,%r8d
sub    %r13d,%r8d
cmp    $0x7,%r8d
jb     1540 <main+0x410>
add    $0x1,%r8
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
movd   %edx,%xmm0
pshufd $0x0,%xmm0,%xmm8
movd   %esi,%xmm1
pshufd $0x0,%xmm1,%xmm0
mov    %rcx,0x98(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     1644 <main+0x514>
mov    %r10,%rcx
and    $0xfffffffffffffffe,%rcx
lea    0xd4(%rsp),%rbx
lea    (%rbx,%rbp,4),%r9
lea    0xc01(%rip),%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x30(%r9,%rbp,4),%xmm2
movdqu -0x20(%r9,%rbp,4),%xmm3
movdqu -0x10(%r9,%rbp,4),%xmm4
movdqu (%r9,%rbp,4),%xmm5
movdqa %xmm2,%xmm6
pcmpeqd %xmm8,%xmm6
movdqa %xmm3,%xmm7
pcmpeqd %xmm8,%xmm7
movdqa %xmm0,%xmm1
pand   %xmm6,%xmm1
pandn  %xmm2,%xmm6
por    %xmm1,%xmm6
movdqa %xmm0,%xmm1
pand   %xmm7,%xmm1
pandn  %xmm3,%xmm7
por    %xmm1,%xmm7
movdqu %xmm6,-0x30(%r9,%rbp,4)
movdqu %xmm7,-0x20(%r9,%rbp,4)
movdqa %xmm4,%xmm1
pcmpeqd %xmm8,%xmm1
movdqa %xmm5,%xmm2
pcmpeqd %xmm8,%xmm2
movdqa %xmm0,%xmm3
pand   %xmm1,%xmm3
pandn  %xmm4,%xmm1
por    %xmm3,%xmm1
movdqa %xmm0,%xmm3
pand   %xmm2,%xmm3
pandn  %xmm5,%xmm2
por    %xmm3,%xmm2
movdqu %xmm1,-0x10(%r9,%rbp,4)
movdqu %xmm2,(%r9,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rcx
jne    1420 <main+0x2f0>
test   $0x1,%r10b
je     1523 <main+0x3f3>
add    %rdi,%rbp
movdqu 0xa0(%rsp,%rbp,4),%xmm1
movdqu 0xb0(%rsp,%rbp,4),%xmm2
movdqa %xmm1,%xmm3
pcmpeqd %xmm8,%xmm3
pcmpeqd %xmm2,%xmm8
movdqa %xmm0,%xmm4
pand   %xmm3,%xmm4
pandn  %xmm1,%xmm3
por    %xmm4,%xmm3
pand   %xmm8,%xmm0
pandn  %xmm2,%xmm8
por    %xmm0,%xmm8
movdqu %xmm3,0xa0(%rsp,%rbp,4)
movdqu %xmm8,0xb0(%rsp,%rbp,4)
mov    0x98(%rsp),%rcx
cmp    %rcx,%r8
je     155c <main+0x42c>
add    %rcx,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xa0(%rsp,%rdi,4),%ecx
cmp    %edx,%ecx
cmove  %esi,%ecx
mov    %ecx,0xa0(%rsp,%rdi,4)
add    $0x1,%rdi
cmp    $0x1f,%edi
jne    1540 <main+0x410>
cmp    $0x2,%r11d
jb     158b <main+0x45b>
mov    %r11d,%esi
add    $0xffffffffffffffff,%r11
mov    $0x1,%ecx
cmp    $0x2,%esi
jne    15fa <main+0x4ca>
test   $0x1,%r11b
je     158b <main+0x45b>
cmp    %edx,0x10(%rsp,%rcx,4)
jne    158b <main+0x45b>
mov    0x10(%rsp,%rax,4),%edx
mov    %edx,0x10(%rsp,%rcx,4)
addl   $0xffffffff,0xc(%rsp)
cmpl   $0x0,0x10(%rsp,%rax,4)
jne    15b0 <main+0x480>
mov    %r14d,%ecx
shl    $0x5,%ecx
add    %r13d,%ecx
mov    %ecx,0x10(%rsp,%rax,4)
addl   $0x1,0xc(%rsp)
nopl   0x0(%rax)
mov    %r15,%rdi
call   1050 <getc@plt>
cmp    $0xa,%al
je     1190 <main+0x60>
cmp    (%r12),%al
je     1190 <main+0x60>
mov    %r15,%rdi
call   1050 <getc@plt>
cmp    $0xa,%al
je     1190 <main+0x60>
add    $0x1,%r13d
cmp    (%r12),%al
jne    1250 <main+0x120>
jmp    1190 <main+0x60>
mov    %edx,0x10(%rsp,%rax,4)
cmpl   $0x0,0x10(%rsp,%rax,4)
jne    15b0 <main+0x480>
jmp    1597 <main+0x467>
mov    %r11,%rsi
and    $0xfffffffffffffffe,%rsi
neg    %rsi
mov    $0x1,%ecx
jmp    1626 <main+0x4f6>
nopl   0x0(%rax,%rax,1)
lea    (%rsi,%rcx,1),%rdi
add    $0x2,%rdi
add    $0x2,%rcx
cmp    $0x1,%rdi
je     1577 <main+0x447>
cmp    %edx,0x10(%rsp,%rcx,4)
jne    1634 <main+0x504>
mov    0x10(%rsp,%rax,4),%edi
mov    %edi,0x10(%rsp,%rcx,4)
cmp    %edx,0x14(%rsp,%rcx,4)
jne    1610 <main+0x4e0>
mov    0x10(%rsp,%rax,4),%edi
mov    %edi,0x14(%rsp,%rcx,4)
jmp    1610 <main+0x4e0>
xor    %ebp,%ebp
test   $0x1,%r10b
jne    14ce <main+0x39e>
jmp    1523 <main+0x3f3>
mov    (%rsi),%rsi
lea    0x9a1(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    $0x1,%ebp
mov    %ebp,%eax
add    $0x128,%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 = [4 x i8] c"%d\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32*
%7 = alloca i8
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca [32 x i32]
%14 = alloca [32 x i32]
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%15 = load i32, i32* %4
%16 = icmp ne i32 %15, 2
br i1 %16, label %17, label %22
17: ; preds = %2
%18 = load i8**, i8*** %5
%19 = getelementptr inbounds i8*, i8** %18, i64 0
%20 = load i8*, i8** %19
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0), i8* %20)
store i32 1, i32* %3
br label %270
22: ; preds = %2
%23 = load i8**, i8*** %5
%24 = getelementptr inbounds i8*, i8** %23, i32 1
store i8** %24, i8*** %5
%25 = load i8*, i8** %24
%26 = call i32* @fopen(i8* %25, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %26, i32** %6
br label %27
27: ; preds = %266, %22
%28 = load i32*, i32** %6
%29 = call signext i8 @getc(i32* %28)
store i8 %29, i8* %7
%30 = sext i8 %29 to i32
%31 = load i8, i8* @EOF
%32 = sext i8 %31 to i32
%33 = icmp ne i32 %30, %32
br i1 %33, label %34, label %269
34: ; preds = %27
store i32 0, i32* %11
store i32 0, i32* %9
br label %35
35: ; preds = %45, %34
%36 = load i32, i32* %9
%37 = icmp ult i32 %36, 32
br i1 %37, label %38, label %48
38: ; preds = %35
%39 = load i32, i32* %9
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %40
store i32 0, i32* %41
%42 = load i32, i32* %9
%43 = zext i32 %42 to i64
%44 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %43
store i32 0, i32* %44
br label %45
45: ; preds = %38
%46 = load i32, i32* %9
%47 = add i32 %46, 1
store i32 %47, i32* %9
br label %35
48: ; preds = %35
store i32 0, i32* %8
store i32 1, i32* %9
br label %49
49: ; preds = %264, %48
%50 = load i8, i8* %7
%51 = sext i8 %50 to i32
%52 = icmp eq i32 %51, 124
br i1 %52, label %53, label %74
53: ; preds = %49
store i32 1, i32* %10
br label %54
54: ; preds = %68, %53
%55 = load i32, i32* %10
%56 = icmp ult i32 %55, 31
br i1 %56, label %57, label %71
57: ; preds = %54
%58 = load i32, i32* %10
%59 = zext i32 %58 to i64
%60 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %59
%61 = load i32, i32* %60
%62 = load i32, i32* %10
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %63
store i32 %61, i32* %64
%65 = load i32, i32* %10
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %66
store i32 0, i32* %67
br label %68
68: ; preds = %57
%69 = load i32, i32* %10
%70 = add i32 %69, 1
store i32 %70, i32* %10
br label %54
71: ; preds = %54
%72 = load i32, i32* %8
%73 = add i32 %72, 1
store i32 %73, i32* %8
store i32 0, i32* %9
br label %237
74: ; preds = %49
%75 = load i8, i8* %7
%76 = sext i8 %75 to i32
%77 = icmp eq i32 %76, 111
br i1 %77, label %78, label %236
78: ; preds = %74
%79 = load i32, i32* %9
%80 = sub i32 %79, 1
%81 = zext i32 %80 to i64
%82 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %81
%83 = load i32, i32* %82
%84 = icmp ugt i32 %83, 0
br i1 %84, label %85, label %94
85: ; preds = %78
%86 = load i32, i32* %9
%87 = sub i32 %86, 1
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %88
%90 = load i32, i32* %89
%91 = load i32, i32* %9
%92 = zext i32 %91 to i64
%93 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %92
store i32 %90, i32* %93
br label %126
94: ; preds = %78
%95 = load i32, i32* %9
%96 = zext i32 %95 to i64
%97 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %96
%98 = load i32, i32* %97
%99 = icmp ugt i32 %98, 0
br i1 %99, label %100, label %108
100: ; preds = %94
%101 = load i32, i32* %9
%102 = zext i32 %101 to i64
%103 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %102
%104 = load i32, i32* %103
%105 = load i32, i32* %9
%106 = zext i32 %105 to i64
%107 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %106
store i32 %104, i32* %107
br label %125
108: ; preds = %94
%109 = load i32, i32* %9
%110 = sub i32 %109, 1
%111 = zext i32 %110 to i64
%112 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %111
%113 = load i32, i32* %112
%114 = icmp ugt i32 %113, 0
br i1 %114, label %115, label %124
115: ; preds = %108
%116 = load i32, i32* %9
%117 = sub i32 %116, 1
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %118
%120 = load i32, i32* %119
%121 = load i32, i32* %9
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %122
store i32 %120, i32* %123
br label %124
124: ; preds = %115, %108
br label %125
125: ; preds = %124, %100
br label %126
126: ; preds = %125, %85
%127 = load i32, i32* %9
%128 = add i32 %127, 1
%129 = zext i32 %128 to i64
%130 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %129
%131 = load i32, i32* %130
%132 = icmp ugt i32 %131, 0
br i1 %132, label %133, label %219
133: ; preds = %126
%134 = load i32, i32* %9
%135 = zext i32 %134 to i64
%136 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %135
%137 = load i32, i32* %136
%138 = icmp eq i32 %137, 0
br i1 %138, label %139, label %148
139: ; preds = %133
%140 = load i32, i32* %9
%141 = add i32 %140, 1
%142 = zext i32 %141 to i64
%143 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %142
%144 = load i32, i32* %143
%145 = load i32, i32* %9
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %146
store i32 %144, i32* %147
br label %218
148: ; preds = %133
%149 = load i32, i32* %9
%150 = zext i32 %149 to i64
%151 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %150
%152 = load i32, i32* %151
%153 = load i32, i32* %9
%154 = add i32 %153, 1
%155 = zext i32 %154 to i64
%156 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %155
%157 = load i32, i32* %156
%158 = icmp ne i32 %152, %157
br i1 %158, label %159, label %217
159: ; preds = %148
%160 = load i32, i32* %9
%161 = add i32 %160, 1
%162 = zext i32 %161 to i64
%163 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %162
%164 = load i32, i32* %163
store i32 %164, i32* %12
%165 = load i32, i32* %9
%166 = add i32 %165, 1
store i32 %166, i32* %10
br label %167
167: ; preds = %186, %159
%168 = load i32, i32* %10
%169 = icmp ult i32 %168, 31
br i1 %169, label %170, label %189
170: ; preds = %167
%171 = load i32, i32* %10
%172 = zext i32 %171 to i64
%173 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %172
%174 = load i32, i32* %173
%175 = load i32, i32* %12
%176 = icmp eq i32 %174, %175
br i1 %176, label %177, label %185
177: ; preds = %170
%178 = load i32, i32* %9
%179 = zext i32 %178 to i64
%180 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %179
%181 = load i32, i32* %180
%182 = load i32, i32* %10
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %183
store i32 %181, i32* %184
br label %185
185: ; preds = %177, %170
br label %186
186: ; preds = %185
%187 = load i32, i32* %10
%188 = add i32 %187, 1
store i32 %188, i32* %10
br label %167
189: ; preds = %167
store i32 1, i32* %10
br label %190
190: ; preds = %211, %189
%191 = load i32, i32* %10
%192 = load i32, i32* %9
%193 = sub i32 %192, 1
%194 = icmp ult i32 %191, %193
br i1 %194, label %195, label %214
195: ; preds = %190
%196 = load i32, i32* %10
%197 = zext i32 %196 to i64
%198 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %197
%199 = load i32, i32* %198
%200 = load i32, i32* %12
%201 = icmp eq i32 %199, %200
br i1 %201, label %202, label %210
202: ; preds = %195
%203 = load i32, i32* %9
%204 = zext i32 %203 to i64
%205 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %204
%206 = load i32, i32* %205
%207 = load i32, i32* %10
%208 = zext i32 %207 to i64
%209 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %208
store i32 %206, i32* %209
br label %210
210: ; preds = %202, %195
br label %211
211: ; preds = %210
%212 = load i32, i32* %10
%213 = add i32 %212, 1
store i32 %213, i32* %10
br label %190
214: ; preds = %190
%215 = load i32, i32* %11
%216 = add i32 %215, -1
store i32 %216, i32* %11
br label %217
217: ; preds = %214, %148
br label %218
218: ; preds = %217, %139
br label %219
219: ; preds = %218, %126
%220 = load i32, i32* %9
%221 = zext i32 %220 to i64
%222 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %221
%223 = load i32, i32* %222
%224 = icmp eq i32 %223, 0
br i1 %224, label %225, label %235
225: ; preds = %219
%226 = load i32, i32* %8
%227 = mul i32 %226, 32
%228 = load i32, i32* %9
%229 = add i32 %227, %228
%230 = load i32, i32* %9
%231 = zext i32 %230 to i64
%232 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %231
store i32 %229, i32* %232
%233 = load i32, i32* %11
%234 = add i32 %233, 1
store i32 %234, i32* %11
br label %235
235: ; preds = %225, %219
br label %236
236: ; preds = %235, %74
br label %237
237: ; preds = %236, %71
%238 = load i32, i32* %9
%239 = add i32 %238, 1
store i32 %239, i32* %9
%240 = load i32*, i32** %6
%241 = call signext i8 @getc(i32* %240)
store i8 %241, i8* %7
%242 = sext i8 %241 to i32
%243 = load i8, i8* @EOF
%244 = sext i8 %243 to i32
%245 = icmp eq i32 %242, %244
br i1 %245, label %250, label %246
246: ; preds = %237
%247 = load i8, i8* %7
%248 = sext i8 %247 to i32
%249 = icmp eq i32 %248, 10
br i1 %249, label %250, label %251
250: ; preds = %246, %237
br label %266
251: ; preds = %246
%252 = load i32*, i32** %6
%253 = call signext i8 @getc(i32* %252)
store i8 %253, i8* %7
br label %254
254: ; preds = %251
%255 = load i8, i8* %7
%256 = sext i8 %255 to i32
%257 = icmp ne i32 %256, 10
br i1 %257, label %258, label %264
258: ; preds = %254
%259 = load i8, i8* %7
%260 = sext i8 %259 to i32
%261 = load i8, i8* @EOF
%262 = sext i8 %261 to i32
%263 = icmp ne i32 %260, %262
br label %264
264: ; preds = %258, %254
%265 = phi i1 [ false, %254 ], [ %263, %258 ]
br i1 %265, label %49, label %266
266: ; preds = %264, %250
%267 = load i32, i32* %11
%268 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %267)
br label %27
269: ; preds = %27
store i32 0, i32* %3
br label %270
270: ; preds = %269, %17
%271 = load i32, i32* %3
ret i32 %271
}

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