#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 EXIT_FAILURE;
int EXIT_SUCCESS;
long atoi(char *);
int /*<<< orphan*/ errno;
char fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int *malloc(long);
int /*<<< orphan*/ printf(char *, long);
int /*<<< orphan*/ rewind(int /*<<< orphan*/ *);
int /*<<< orphan*/ stderr;
char *strerror(int /*<<< orphan*/);
int main(int argc, char **argv) {
  FILE *inFile;
  bool *row1, *row2, *newRow, *oldRow, *temp;
  long numSafe = 0;
  long numRows, rowSize, r, c;
  int nextChar;
  if (argc != 3) {
    fprintf(stderr, "Usage:\n\tDay18 <input filename> <row count>\n\n");
    return EXIT_FAILURE;
  }
  inFile = fopen(argv[1], "r");
  if (inFile == NULL) {
    fprintf(stderr, "Error opening file: %s\n\n", strerror(errno));
    return EXIT_FAILURE;
  }
  numRows = atoi(argv[2]);
  rowSize = 0;
  while (fgetc(inFile) != '\n') {
    rowSize++;
  }
  rewind(inFile);
  row1 = malloc((rowSize + 2) * sizeof(bool));
  row2 = malloc((rowSize + 2) * sizeof(bool));
  if (row1 == NULL || row2 == NULL) {
    fprintf(stderr, "Error allocating memory: %s\n\n", strerror(errno));
    return EXIT_FAILURE;
  }
  oldRow = row1 + 1;
  oldRow[-1] = false;
  oldRow[rowSize - 1 + 1] = false;
  newRow = row2 + 1;
  newRow[-1] = false;
  newRow[rowSize - 1 + 1] = false;
  for (c = 0; c < rowSize; c++) {
    nextChar = fgetc(inFile);
    if (nextChar == '.') {
      oldRow[c] = false;
      numSafe++;
    } else {
      oldRow[c] = true;
    }
  }
  for (r = 1; r < numRows; r++) {
    for (c = 0; c < rowSize; c++) {
      newRow[c] = oldRow[c - 1] ^ oldRow[c + 1];
      if (newRow[c] == false)
        numSafe++;
    }
    temp = oldRow;
    oldRow = newRow;
    newRow = temp;
  }
  printf("The number of safe tiles is %ld\n", numSafe);
  return EXIT_SUCCESS;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x0,-0x48(%rbp)
cmpl   $0x3,-0x8(%rbp)
je     11d3 <main+0x53>
mov    0x2e2e(%rip),%rax
mov    (%rax),%edi
lea    0xe45(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    0x2e07(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1491 <main+0x311>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe4b(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1235 <main+0xb5>
mov    0x2de3(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x70(%rbp)
mov    0x2dcf(%rip),%rax
mov    (%rax),%edi
call   10a0 <strerror@plt>
mov    -0x70(%rbp),%edi
mov    %rax,%rdx
lea    0xe12(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    0x2da5(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1491 <main+0x311>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
call   1090 <atoi@plt>
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x18(%rbp),%rdi
call   1050 <fgetc@plt>
movsbl %al,%eax
cmp    $0xa,%eax
je     1274 <main+0xf4>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    124e <main+0xce>
mov    -0x18(%rbp),%rdi
call   1040 <rewind@plt>
mov    -0x58(%rbp),%rdi
add    $0x2,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x58(%rbp),%rdi
add    $0x2,%rdi
shl    $0x2,%rdi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     12bd <main+0x13d>
cmpq   $0x0,-0x28(%rbp)
jne    12fc <main+0x17c>
mov    0x2d1c(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x74(%rbp)
mov    0x2d08(%rip),%rax
mov    (%rax),%edi
call   10a0 <strerror@plt>
mov    -0x74(%rbp),%edi
mov    %rax,%rdx
lea    0xd64(%rip),%rsi
mov    $0x0,%al
call   1060 <fprintf@plt>
mov    0x2cde(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1491 <main+0x311>
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movl   $0x0,-0x4(%rax)
mov    -0x38(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
movl   $0x0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movl   $0x0,-0x4(%rax)
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    $0x1,%rcx
movl   $0x0,0x4(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x58(%rbp),%rax
jge    13c6 <main+0x246>
mov    -0x18(%rbp),%rdi
call   1050 <fgetc@plt>
movsbl %al,%eax
mov    %eax,-0x6c(%rbp)
cmpl   $0x2e,-0x6c(%rbp)
jne    13a1 <main+0x221>
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    13b0 <main+0x230>
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    13b5 <main+0x235>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    135a <main+0x1da>
movq   $0x1,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x50(%rbp),%rax
jge    1475 <main+0x2f5>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x58(%rbp),%rax
jge    144c <main+0x2cc>
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
mov    -0x68(%rbp),%rcx
xor    0x4(%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x68(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1436 <main+0x2b6>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    143b <main+0x2bb>
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    13e4 <main+0x264>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    13ce <main+0x24e>
mov    -0x48(%rbp),%rsi
lea    0xbe6(%rip),%rdi
call   1030 <printf@plt>
mov    0x2b3c(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
cmp    $0x3,%edi
jne    1286 <main+0x106>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
lea    0xe98(%rip),%rsi
call   1080 <fopen@plt>
test   %rax,%rax
je     12a9 <main+0x129>
mov    %rax,%r12
mov    0x10(%rbx),%rdi
call   1090 <atoi@plt>
mov    %rax,%r13
mov    $0x1,%ebp
mov    $0x4,%ebx
nopl   0x0(%rax)
mov    %r12,%rdi
call   1050 <fgetc@plt>
add    $0xffffffffffffffff,%rbp
add    $0x4,%rbx
cmp    $0xa,%al
jne    11d0 <main+0x50>
mov    %r12,%rdi
call   1040 <rewind@plt>
mov    %rbx,%rdi
call   1070 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%rdi
call   1070 <malloc@plt>
test   %r15,%r15
je     12c9 <main+0x149>
test   %rax,%rax
je     12c9 <main+0x149>
mov    %r15,%rcx
mov    %rbp,%r14
neg    %r14
add    $0x4,%r15
movl   $0x0,(%rcx)
movl   $0x0,-0x4(%rcx,%rbx,1)
movl   $0x0,(%rax)
movl   $0x0,-0x4(%rax,%rbx,1)
test   %rbp,%rbp
mov    %r13,0x10(%rsp)
mov    %rax,0x8(%rsp)
je     12ff <main+0x17f>
xor    %r13d,%r13d
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12,%rdi
call   1050 <fgetc@plt>
xor    %ecx,%ecx
xor    %edx,%edx
cmp    $0x2e,%al
sete   %cl
setne  %dl
add    %rcx,%rbx
mov    %edx,(%r15,%r13,4)
add    $0x1,%r13
cmp    %r13,%r14
jne    1260 <main+0xe0>
jmp    1301 <main+0x181>
mov    0x2d53(%rip),%rax
mov    (%rax),%edi
lea    0xd7a(%rip),%rsi
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    0x2d2c(%rip),%rax
jmp    143b <main+0x2bb>
mov    0x2d30(%rip),%rax
mov    (%rax),%ebx
mov    0x2d1f(%rip),%rax
mov    (%rax),%edi
call   10a0 <strerror@plt>
lea    0xd78(%rip),%rsi
jmp    12e7 <main+0x167>
mov    0x2d10(%rip),%rax
mov    (%rax),%ebx
mov    0x2cff(%rip),%rax
mov    (%rax),%edi
call   10a0 <strerror@plt>
lea    0xd71(%rip),%rsi
mov    %ebx,%edi
mov    %rax,%rdx
xor    %eax,%eax
call   1060 <fprintf@plt>
mov    0x2cd6(%rip),%rax
jmp    143b <main+0x2bb>
xor    %ebx,%ebx
mov    0x10(%rsp),%r10
cmp    $0x2,%r10
jl     1425 <main+0x2a5>
mov    0x8(%rsp),%rax
add    $0x4,%rax
movabs $0x7ffffffffffffffc,%r8
ff ff 7f
and    %r14,%r8
mov    %r14,%rcx
and    $0xfffffffffffffffc,%rcx
mov    $0x1,%r9d
pxor   %xmm0,%xmm0
movdqa 0xcc1(%rip),%xmm1
jmp    1360 <main+0x1e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9
mov    %rsi,%rax
cmp    %r10,%r9
je     1425 <main+0x2a5>
mov    %r15,%rsi
mov    %rax,%r15
test   %rbp,%rbp
je     1350 <main+0x1d0>
cmp    $0x4,%r14
jae    1380 <main+0x200>
xor    %edi,%edi
jmp    1400 <main+0x280>
nopl   0x0(%rax,%rax,1)
movq   %rbx,%xmm3
pxor   %xmm2,%xmm2
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    0x4(%rsi,%rdi,4),%rbx
mov    -0x4(%rsi,%rdi,4),%rax
xor    %rbx,%rax
movq   %rax,%xmm4
xor    0xc(%rsi,%rdi,4),%rbx
movq   %rbx,%xmm5
pshufd $0xd4,%xmm4,%xmm6
punpcklqdq %xmm5,%xmm4
movdqu %xmm4,(%r15,%rdi,4)
pcmpeqd %xmm0,%xmm6
pand   %xmm1,%xmm6
paddq  %xmm6,%xmm3
pshufd $0xd4,%xmm5,%xmm4
pcmpeqd %xmm0,%xmm4
pand   %xmm1,%xmm4
paddq  %xmm4,%xmm2
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1390 <main+0x210>
paddq  %xmm3,%xmm2
pshufd $0xee,%xmm2,%xmm3
paddq  %xmm2,%xmm3
movq   %xmm3,%rbx
mov    %r8,%rdi
cmp    %r8,%r14
je     1350 <main+0x1d0>
nop
mov    0x4(%rsi,%rdi,4),%eax
xor    %edx,%edx
xor    -0x4(%rsi,%rdi,4),%eax
mov    %eax,(%r15,%rdi,4)
lea    0x1(%rdi),%rax
sete   %dl
add    %rdx,%rbx
mov    %rax,%rdi
cmp    %rax,%r14
jne    1400 <main+0x280>
jmp    1350 <main+0x1d0>
lea    0xc4a(%rip),%rdi
mov    %rbx,%rsi
call   1030 <printf@plt>
mov    0x2b8d(%rip),%rax
mov    (%rax),%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [45 x i8] c"Usage:\0A\09Day18 <input filename> <row count>\0A\0A\00"
@EXIT_FAILURE = global i32 0
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [25 x i8] c"Error opening file: %s\0A\0A\00"
@errno = global i32 0
@.str.3 = [30 x i8] c"Error allocating memory: %s\0A\0A\00"
@.str.4 = [33 x i8] c"The number of safe tiles is %ld\0A\00"
@EXIT_SUCCESS = global i32 0
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 i32*
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i64 0, i64* %12
%18 = load i32, i32* %4
%19 = icmp ne i32 %18, 3
br i1 %19, label %20, label %24
20: ; preds = %2
%21 = load i32, i32* @stderr
%22 = call i32 (i32, i8*, ...) @fprintf(i32 %21, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0))
%23 = load i32, i32* @EXIT_FAILURE
store i32 %23, i32* %3
br label %163
24: ; preds = %2
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 1
%27 = load i8*, i8** %26
%28 = call i32* @fopen(i8* %27, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32* %28, i32** %6
%29 = load i32*, i32** %6
%30 = icmp eq i32* %29, null
br i1 %30, label %31, label %37
31: ; preds = %24
%32 = load i32, i32* @stderr
%33 = load i32, i32* @errno
%34 = call i8* @strerror(i32 %33)
%35 = call i32 (i32, i8*, ...) @fprintf(i32 %32, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0), i8* %34)
%36 = load i32, i32* @EXIT_FAILURE
store i32 %36, i32* %3
br label %163
37: ; preds = %24
%38 = load i8**, i8*** %5
%39 = getelementptr inbounds i8*, i8** %38, i64 2
%40 = load i8*, i8** %39
%41 = call i64 @atoi(i8* %40)
store i64 %41, i64* %13
store i64 0, i64* %14
br label %42
42: ; preds = %47, %37
%43 = load i32*, i32** %6
%44 = call signext i8 @fgetc(i32* %43)
%45 = sext i8 %44 to i32
%46 = icmp ne i32 %45, 10
br i1 %46, label %47, label %50
47: ; preds = %42
%48 = load i64, i64* %14
%49 = add nsw i64 %48, 1
store i64 %49, i64* %14
br label %42
50: ; preds = %42
%51 = load i32*, i32** %6
%52 = call i32 @rewind(i32* %51)
%53 = load i64, i64* %14
%54 = add nsw i64 %53, 2
%55 = mul i64 %54, 4
%56 = call i32* @malloc(i64 %55)
store i32* %56, i32** %7
%57 = load i64, i64* %14
%58 = add nsw i64 %57, 2
%59 = mul i64 %58, 4
%60 = call i32* @malloc(i64 %59)
store i32* %60, i32** %8
%61 = load i32*, i32** %7
%62 = icmp eq i32* %61, null
br i1 %62, label %66, label %63
63: ; preds = %50
%64 = load i32*, i32** %8
%65 = icmp eq i32* %64, null
br i1 %65, label %66, label %72
66: ; preds = %63, %50
%67 = load i32, i32* @stderr
%68 = load i32, i32* @errno
%69 = call i8* @strerror(i32 %68)
%70 = call i32 (i32, i8*, ...) @fprintf(i32 %67, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i8* %69)
%71 = load i32, i32* @EXIT_FAILURE
store i32 %71, i32* %3
br label %163
72: ; preds = %63
%73 = load i32*, i32** %7
%74 = getelementptr inbounds i32, i32* %73, i64 1
store i32* %74, i32** %10
%75 = load i32*, i32** %10
%76 = getelementptr inbounds i32, i32* %75, i64 -1
store i32 0, i32* %76
%77 = load i32*, i32** %10
%78 = load i64, i64* %14
%79 = sub nsw i64 %78, 1
%80 = add nsw i64 %79, 1
%81 = getelementptr inbounds i32, i32* %77, i64 %80
store i32 0, i32* %81
%82 = load i32*, i32** %8
%83 = getelementptr inbounds i32, i32* %82, i64 1
store i32* %83, i32** %9
%84 = load i32*, i32** %9
%85 = getelementptr inbounds i32, i32* %84, i64 -1
store i32 0, i32* %85
%86 = load i32*, i32** %9
%87 = load i64, i64* %14
%88 = sub nsw i64 %87, 1
%89 = add nsw i64 %88, 1
%90 = getelementptr inbounds i32, i32* %86, i64 %89
store i32 0, i32* %90
store i64 0, i64* %16
br label %91
91: ; preds = %112, %72
%92 = load i64, i64* %16
%93 = load i64, i64* %14
%94 = icmp slt i64 %92, %93
br i1 %94, label %95, label %115
95: ; preds = %91
%96 = load i32*, i32** %6
%97 = call signext i8 @fgetc(i32* %96)
%98 = sext i8 %97 to i32
store i32 %98, i32* %17
%99 = load i32, i32* %17
%100 = icmp eq i32 %99, 46
br i1 %100, label %101, label %107
101: ; preds = %95
%102 = load i32*, i32** %10
%103 = load i64, i64* %16
%104 = getelementptr inbounds i32, i32* %102, i64 %103
store i32 0, i32* %104
%105 = load i64, i64* %12
%106 = add nsw i64 %105, 1
store i64 %106, i64* %12
br label %111
107: ; preds = %95
%108 = load i32*, i32** %10
%109 = load i64, i64* %16
%110 = getelementptr inbounds i32, i32* %108, i64 %109
store i32 1, i32* %110
br label %111
111: ; preds = %107, %101
br label %112
112: ; preds = %111
%113 = load i64, i64* %16
%114 = add nsw i64 %113, 1
store i64 %114, i64* %16
br label %91
115: ; preds = %91
store i64 1, i64* %15
br label %116
116: ; preds = %156, %115
%117 = load i64, i64* %15
%118 = load i64, i64* %13
%119 = icmp slt i64 %117, %118
br i1 %119, label %120, label %159
120: ; preds = %116
store i64 0, i64* %16
br label %121
121: ; preds = %149, %120
%122 = load i64, i64* %16
%123 = load i64, i64* %14
%124 = icmp slt i64 %122, %123
br i1 %124, label %125, label %152
125: ; preds = %121
%126 = load i32*, i32** %10
%127 = load i64, i64* %16
%128 = sub nsw i64 %127, 1
%129 = getelementptr inbounds i32, i32* %126, i64 %128
%130 = load i32, i32* %129
%131 = load i32*, i32** %10
%132 = load i64, i64* %16
%133 = add nsw i64 %132, 1
%134 = getelementptr inbounds i32, i32* %131, i64 %133
%135 = load i32, i32* %134
%136 = xor i32 %130, %135
%137 = load i32*, i32** %9
%138 = load i64, i64* %16
%139 = getelementptr inbounds i32, i32* %137, i64 %138
store i32 %136, i32* %139
%140 = load i32*, i32** %9
%141 = load i64, i64* %16
%142 = getelementptr inbounds i32, i32* %140, i64 %141
%143 = load i32, i32* %142
%144 = icmp eq i32 %143, 0
br i1 %144, label %145, label %148
145: ; preds = %125
%146 = load i64, i64* %12
%147 = add nsw i64 %146, 1
store i64 %147, i64* %12
br label %148
148: ; preds = %145, %125
br label %149
149: ; preds = %148
%150 = load i64, i64* %16
%151 = add nsw i64 %150, 1
store i64 %151, i64* %16
br label %121
152: ; preds = %121
%153 = load i32*, i32** %10
store i32* %153, i32** %11
%154 = load i32*, i32** %9
store i32* %154, i32** %10
%155 = load i32*, i32** %11
store i32* %155, i32** %9
br label %156
156: ; preds = %152
%157 = load i64, i64* %15
%158 = add nsw i64 %157, 1
store i64 %158, i64* %15
br label %116
159: ; preds = %116
%160 = load i64, i64* %12
%161 = call i32 @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), i64 %160)
%162 = load i32, i32* @EXIT_SUCCESS
store i32 %162, i32* %3
br label %163
163: ; preds = %159, %66, %31, %20
%164 = load i32, i32* %3
ret i32 %164
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [45 x i8] c"Usage:\0A\09Day18 <input filename> <row count>\0A\0A\00"
@EXIT_FAILURE = global i32 0
@.str.1 = [2 x i8] c"r\00"
@.str.2 = [25 x i8] c"Error opening file: %s\0A\0A\00"
@errno = global i32 0
@.str.3 = [30 x i8] c"Error allocating memory: %s\0A\0A\00"
@.str.4 = [33 x i8] c"The number of safe tiles is %ld\0A\00"
@EXIT_SUCCESS = global i32 0
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp eq i32 %0, 3
br i1 %3, label %7, label %4
4: ; preds = %2
%5 = load i32, i32* @stderr
%6 = tail call i32 (i32, i8*, ...) @fprintf(i32 %5, i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str, i64 0, i64 0))
br label %133
7: ; preds = %2
%8 = getelementptr inbounds i8*, i8** %1, i64 1
%9 = load i8*, i8** %8
%10 = tail call i32* @fopen(i8* %9, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%11 = icmp eq i32* %10, null
br i1 %11, label %12, label %17
12: ; preds = %7
%13 = load i32, i32* @stderr
%14 = load i32, i32* @errno
%15 = tail call i8* @strerror(i32 %14)
%16 = tail call i32 (i32, i8*, ...) @fprintf(i32 %13, i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str.2, i64 0, i64 0), i8* %15)
br label %133
17: ; preds = %7
%18 = getelementptr inbounds i8*, i8** %1, i64 2
%19 = load i8*, i8** %18
%20 = tail call i64 @atoi(i8* %19)
br label %21
21: ; preds = %21, %17
%22 = phi i64 [ 0, %17 ], [ %25, %21 ]
%23 = tail call signext i8 @fgetc(i32* %10)
%24 = icmp eq i8 %23, 10
%25 = add nuw nsw i64 %22, 1
br i1 %24, label %26, label %21
26: ; preds = %21
%27 = tail call i32 @rewind(i32* %10)
%28 = shl i64 %22, 2
%29 = add i64 %28, 8
%30 = tail call i32* @malloc(i64 %29)
%31 = tail call i32* @malloc(i64 %29)
%32 = icmp eq i32* %30, null
%33 = icmp eq i32* %31, null
%34 = or i1 %32, %33
br i1 %34, label %35, label %40
35: ; preds = %26
%36 = load i32, i32* @stderr
%37 = load i32, i32* @errno
%38 = tail call i8* @strerror(i32 %37)
%39 = tail call i32 (i32, i8*, ...) @fprintf(i32 %36, i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0), i8* %38)
br label %133
40: ; preds = %26
%41 = getelementptr inbounds i32, i32* %30, i64 1
store i32 0, i32* %30
%42 = getelementptr inbounds i32, i32* %41, i64 %22
store i32 0, i32* %42
%43 = getelementptr inbounds i32, i32* %31, i64 1
store i32 0, i32* %31
%44 = getelementptr inbounds i32, i32* %43, i64 %22
store i32 0, i32* %44
%45 = icmp eq i64 %22, 0
br i1 %45, label %46, label %53
46: ; preds = %53, %40
%47 = phi i64 [ 0, %40 ], [ %61, %53 ]
%48 = icmp sgt i64 %20, 1
br i1 %48, label %49, label %130
49: ; preds = %46
%50 = icmp ult i64 %22, 4
%51 = and i64 %22, 9223372036854775804
%52 = icmp eq i64 %22, %51
br label %65
53: ; preds = %40, %53
%54 = phi i64 [ %63, %53 ], [ 0, %40 ]
%55 = phi i64 [ %61, %53 ], [ 0, %40 ]
%56 = tail call signext i8 @fgetc(i32* %10)
%57 = icmp eq i8 %56, 46
%58 = xor i1 %57, true
%59 = zext i1 %58 to i32
%60 = zext i1 %57 to i64
%61 = add nuw nsw i64 %55, %60
%62 = getelementptr inbounds i32, i32* %41, i64 %54
store i32 %59, i32* %62
%63 = add nuw nsw i64 %54, 1
%64 = icmp eq i64 %63, %22
br i1 %64, label %46, label %53
65: ; preds = %49, %126
%66 = phi i64 [ %128, %126 ], [ 1, %49 ]
%67 = phi i32* [ %69, %126 ], [ %43, %49 ]
%68 = phi i64 [ %127, %126 ], [ %47, %49 ]
%69 = phi i32* [ %67, %126 ], [ %41, %49 ]
br i1 %45, label %126, label %70
70: ; preds = %65
br i1 %50, label %108, label %71
71: ; preds = %70
%72 = insertelement <2 x i64> <i64 poison, i64 0>, i64 %68, i64 0
br label %73
73: ; preds = %73, %71
%74 = phi i64 [ 0, %71 ], [ %103, %73 ]
%75 = phi <2 x i64> [ %72, %71 ], [ %101, %73 ]
%76 = phi <2 x i64> [ zeroinitializer, %71 ], [ %102, %73 ]
%77 = add nsw i64 %74, -1
%78 = getelementptr inbounds i32, i32* %69, i64 %77
%79 = bitcast i32* %78 to <2 x i32>*
%80 = load <2 x i32>, <2 x i32>* %79
%81 = getelementptr inbounds i32, i32* %78, i64 2
%82 = bitcast i32* %81 to <2 x i32>*
%83 = load <2 x i32>, <2 x i32>* %82
%84 = or i64 %74, 1
%85 = getelementptr inbounds i32, i32* %69, i64 %84
%86 = bitcast i32* %85 to <2 x i32>*
%87 = load <2 x i32>, <2 x i32>* %86
%88 = getelementptr inbounds i32, i32* %85, i64 2
%89 = bitcast i32* %88 to <2 x i32>*
%90 = load <2 x i32>, <2 x i32>* %89
%91 = xor <2 x i32> %87, %80
%92 = xor <2 x i32> %90, %83
%93 = getelementptr inbounds i32, i32* %67, i64 %74
%94 = bitcast i32* %93 to <2 x i32>*
store <2 x i32> %91, <2 x i32>* %94
%95 = getelementptr inbounds i32, i32* %93, i64 2
%96 = bitcast i32* %95 to <2 x i32>*
store <2 x i32> %92, <2 x i32>* %96
%97 = icmp eq <2 x i32> %91, zeroinitializer
%98 = icmp eq <2 x i32> %92, zeroinitializer
%99 = zext <2 x i1> %97 to <2 x i64>
%100 = zext <2 x i1> %98 to <2 x i64>
%101 = add <2 x i64> %75, %99
%102 = add <2 x i64> %76, %100
%103 = add nuw i64 %74, 4
%104 = icmp eq i64 %103, %51
br i1 %104, label %105, label %73
105: ; preds = %73
%106 = add <2 x i64> %102, %101
%107 = call i64 @llvm.vector.reduce.add.v2i64(<2 x i64> %106)
br i1 %52, label %126, label %108
108: ; preds = %70, %105
%109 = phi i64 [ 0, %70 ], [ %51, %105 ]
%110 = phi i64 [ %68, %70 ], [ %107, %105 ]
br label %111
111: ; preds = %108, %111
%112 = phi i64 [ %117, %111 ], [ %109, %108 ]
%113 = phi i64 [ %124, %111 ], [ %110, %108 ]
%114 = add nsw i64 %112, -1
%115 = getelementptr inbounds i32, i32* %69, i64 %114
%116 = load i32, i32* %115
%117 = add nuw nsw i64 %112, 1
%118 = getelementptr inbounds i32, i32* %69, i64 %117
%119 = load i32, i32* %118
%120 = xor i32 %119, %116
%121 = getelementptr inbounds i32, i32* %67, i64 %112
store i32 %120, i32* %121
%122 = icmp eq i32 %120, 0
%123 = zext i1 %122 to i64
%124 = add nsw i64 %113, %123
%125 = icmp eq i64 %117, %22
br i1 %125, label %126, label %111
126: ; preds = %111, %105, %65
%127 = phi i64 [ %68, %65 ], [ %107, %105 ], [ %124, %111 ]
%128 = add nuw nsw i64 %66, 1
%129 = icmp eq i64 %128, %20
br i1 %129, label %130, label %65
130: ; preds = %126, %46
%131 = phi i64 [ %47, %46 ], [ %127, %126 ]
%132 = tail call i32 @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str.4, i64 0, i64 0), i64 %131)
br label %133
133: ; preds = %130, %35, %12, %4
%134 = phi i32* [ @EXIT_FAILURE, %4 ], [ @EXIT_FAILURE, %12 ], [ @EXIT_FAILURE, %35 ], [ @EXIT_SUCCESS, %130 ]
%135 = load i32, i32* %134
ret i32 %135
}