#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 uint_fast8_t;
typedef int uint_fast32_t;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ EXIT_FAILURE;
int atoi(char *);
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgetc(int /*<<< orphan*/ *);
int /*<<< orphan*/ fgets(char *, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ printf(char *, unsigned int, char *, int);
int /*<<< orphan*/ stderr;
void problem11(unsigned window, char *grid_file_path, unsigned grid_height,
               unsigned grid_width) {
  FILE *grid_file = fopen(grid_file_path, "r");
  if (!grid_file) {
    fprintf(stderr, "Error: the file \"%s\" could not be opened.",
            grid_file_path);
    exit(EXIT_FAILURE);
  }
  char charbuffer[3];
  uint_fast8_t grid[grid_height][grid_width];
  for (int row = 0; row < grid_height; ++row) {
    for (int col = 0; col < grid_width; ++col) {
      fgets(charbuffer, 3, grid_file);
      grid[row][col] = atoi(charbuffer);
      fgetc(grid_file);
    }
  }
  fclose(grid_file);
  uint_fast32_t accumulator = 0;
  for (int row = 0; row < grid_height; ++row) {
    for (int col = 0; col < grid_width - window; ++col) {
      uint_fast32_t product = 1;
      for (int i = 0; i < window; ++i) {
        product *= grid[row][col + i];
      }
      if (product > accumulator)
        accumulator = product;
    }
  }
  for (int row = 0; row < grid_height - window; ++row) {
    for (int col = 0; col < grid_width; ++col) {
      uint_fast32_t product = 1;
      for (int i = 0; i < window; ++i) {
        product *= grid[row + i][col];
      }
      if (product > accumulator)
        accumulator = product;
    }
  }
  for (int row = 0; row < grid_height - window; ++row) {
    for (int col = 0; col < grid_width - window; ++col) {
      uint_fast32_t product = 1;
      for (int i = 0; i < window; ++i) {
        product *= grid[row + i][col + i];
      }
      if (product > accumulator)
        accumulator = product;
    }
  }
  for (int row = 0; row < grid_height - window; ++row) {
    for (int col = window - 1; col < grid_width; ++col) {
      uint_fast32_t product = 1;
      for (int i = 0; i < window; ++i) {
        product *= grid[row + i][col - i];
      }
      if (product > accumulator)
        accumulator = product;
    }
  }
  printf("Problem 11: The largest sum of %u colinear integers in the grid "
         "\"%s\" is %u\n",
         window, grid_file_path, accumulator);
}


x86 assembly (clang, -O0):
<problem11>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
lea    0xe5d(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    11de <problem11+0x5e>
mov    0x2e22(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rdx
lea    0xe37(%rip),%rsi
call   1070 <fprintf@plt>
mov    0x2e01(%rip),%rax
mov    (%rax),%edi
call   10a0 <exit@plt>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
mov    -0x18(%rbp),%eax
mov    %rax,-0xa0(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x98(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    12b0 <problem11+0x130>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    129d <problem11+0x11d>
lea    -0x23(%rbp),%rdi
mov    -0x20(%rbp),%rdx
mov    $0x3,%esi
call   1060 <fgets@plt>
lea    -0x23(%rbp),%rdi
call   1090 <atoi@plt>
mov    -0xa0(%rbp),%rsi
mov    %eax,%edx
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rdi
call   1050 <fgetc@plt>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1239 <problem11+0xb9>
jmp    12a2 <problem11+0x122>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1226 <problem11+0xa6>
mov    -0x20(%rbp),%rdi
call   1030 <fclose@plt>
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    137b <problem11+0x1fb>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jae    1368 <problem11+0x1e8>
movl   $0x1,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    1343 <problem11+0x1c3>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
movslq -0x50(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x54(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12f9 <problem11+0x179>
mov    -0x58(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jle    1355 <problem11+0x1d5>
mov    -0x58(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    135a <problem11+0x1da>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12da <problem11+0x15a>
jmp    136d <problem11+0x1ed>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12c7 <problem11+0x147>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jae    1436 <problem11+0x2b6>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    1423 <problem11+0x2a3>
movl   $0x1,-0x68(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    13fe <problem11+0x27e>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x60(%rbp),%ecx
add    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13b4 <problem11+0x234>
mov    -0x68(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jle    1410 <problem11+0x290>
mov    -0x68(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    1415 <problem11+0x295>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    139a <problem11+0x21a>
jmp    1428 <problem11+0x2a8>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1382 <problem11+0x202>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jae    14fb <problem11+0x37b>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jae    14e8 <problem11+0x368>
movl   $0x1,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    14c3 <problem11+0x343>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x70(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x74(%rbp),%ecx
add    -0x7c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1474 <problem11+0x2f4>
mov    -0x78(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jle    14d5 <problem11+0x355>
mov    -0x78(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    14da <problem11+0x35a>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1455 <problem11+0x2d5>
jmp    14ed <problem11+0x36d>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    143d <problem11+0x2bd>
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x4(%rbp),%ecx
cmp    %ecx,%eax
jae    15ed <problem11+0x46d>
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x18(%rbp),%eax
jae    15da <problem11+0x45a>
movl   $0x1,-0x88(%rbp)
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jae    15a9 <problem11+0x429>
mov    -0x98(%rbp),%rax
mov    -0xa0(%rbp),%rdx
mov    -0x80(%rbp),%ecx
add    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x84(%rbp),%ecx
sub    -0x8c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
imul   -0x88(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1542 <problem11+0x3c2>
mov    -0x88(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jle    15c1 <problem11+0x441>
mov    -0x88(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    15c6 <problem11+0x446>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    151f <problem11+0x39f>
jmp    15df <problem11+0x45f>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1502 <problem11+0x382>
mov    -0x4(%rbp),%esi
mov    -0x10(%rbp),%rdx
mov    -0x4c(%rbp),%ecx
lea    0xa2e(%rip),%rdi
call   1040 <printf@plt>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<problem11>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %ecx,%r15d
mov    %edx,%r12d
mov    %rsi,%rbx
mov    %edi,%r14d
lea    0xe69(%rip),%rsi
mov    %rbx,%rdi
call   1080 <fopen@plt>
test   %rax,%rax
je     1cea <problem11+0xb6a>
mov    %rax,%r13
mov    %rbx,-0xe0(%rbp)
mov    %rsp,-0xd8(%rbp)
mov    %r12d,%edx
mov    %r15d,-0x2c(%rbp)
mov    %r15d,%ecx
mov    %rcx,%rax
mov    %rdx,-0x38(%rbp)
imul   %rdx,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %r12d,%edx
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %r14,-0x58(%rbp)
mov    %r14d,%eax
mov    %rax,-0x50(%rbp)
mov    %edx,-0x44(%rbp)
test   %edx,%edx
mov    %rcx,-0x70(%rbp)
mov    %r12,-0x60(%rbp)
je     1542 <problem11+0x3c2>
lea    0x0(,%rcx,4),%rax
mov    %rax,-0x68(%rbp)
xor    %eax,%eax
lea    -0xcb(%rbp),%r14
mov    -0x70(%rbp),%r15
jmp    1242 <problem11+0xc2>
nop
mov    -0x40(%rbp),%rax
add    $0x1,%rax
add    -0x68(%rbp),%r12
cmp    -0x38(%rbp),%rax
je     127f <problem11+0xff>
mov    %rax,-0x40(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1230 <problem11+0xb0>
xor    %ebx,%ebx
xchg   %ax,%ax
mov    %r14,%rdi
mov    $0x3,%esi
mov    %r13,%rdx
call   1060 <fgets@plt>
mov    %r14,%rdi
call   1090 <atoi@plt>
mov    %eax,(%r12,%rbx,4)
mov    %r13,%rdi
call   1050 <fgetc@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1250 <problem11+0xd0>
jmp    1230 <problem11+0xb0>
mov    %r13,%rdi
call   1030 <fclose@plt>
cmpl   $0x0,-0x44(%rbp)
je     1552 <problem11+0x3d2>
mov    -0x2c(%rbp),%eax
mov    %eax,%r15d
sub    -0x58(%rbp),%r15d
mov    -0x50(%rbp),%r9
mov    %r9d,%r13d
and    $0xfffffff8,%r13d
lea    -0x8(%r13),%rax
mov    %rax,-0x40(%rbp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
and    %rax,%rcx
mov    %rcx,-0x98(%rbp)
mov    -0x60(%rbp),%r12
lea    0x70(%r12),%r11
mov    %r10,%rdi
shl    $0x5,%rdi
xor    %r14d,%r14d
movdqa 0xd10(%rip),%xmm8
xor    %ecx,%ecx
jmp    1318 <problem11+0x198>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r14
mov    -0x68(%rbp),%rax
add    %rax,%r11
add    %rax,%r12
cmp    -0x38(%rbp),%r14
je     1558 <problem11+0x3d8>
test   %r15,%r15
je     1300 <problem11+0x180>
mov    %r12,%rbx
mov    %r11,%rsi
xor    %r8d,%r8d
jmp    134b <problem11+0x1cb>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%eax
cmp    %ecx,%eax
cmovg  %eax,%ecx
add    $0x1,%r8
add    $0x4,%rsi
add    $0x4,%rbx
cmp    %r15,%r8
je     1300 <problem11+0x180>
mov    -0x58(%rbp),%rax
test   %eax,%eax
je     1330 <problem11+0x1b0>
cmp    $0x8,%eax
jae    1370 <problem11+0x1f0>
mov    $0x1,%eax
xor    %edx,%edx
jmp    1530 <problem11+0x3b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpq   $0x18,-0x40(%rbp)
jae    1388 <problem11+0x208>
xor    %edx,%edx
movdqa %xmm8,%xmm2
movdqa %xmm8,%xmm1
jmp    146b <problem11+0x2eb>
mov    -0x98(%rbp),%r9
xor    %edx,%edx
movdqa %xmm8,%xmm2
movdqa %xmm8,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu -0x70(%rsi,%rdx,4),%xmm4
movdqu -0x60(%rsi,%rdx,4),%xmm3
movdqu -0x50(%rsi,%rdx,4),%xmm5
movdqu -0x40(%rsi,%rdx,4),%xmm6
pshufd $0xf5,%xmm4,%xmm7
pshufd $0xf5,%xmm2,%xmm0
pmuludq %xmm7,%xmm0
pmuludq %xmm2,%xmm4
pshufd $0xf5,%xmm3,%xmm2
pshufd $0xf5,%xmm1,%xmm7
pmuludq %xmm2,%xmm7
pmuludq %xmm1,%xmm3
pmuludq %xmm5,%xmm4
pshufd $0xf5,%xmm5,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm6,%xmm3
pshufd $0xf5,%xmm6,%xmm0
pmuludq %xmm7,%xmm0
movdqu -0x30(%rsi,%rdx,4),%xmm2
movdqu -0x20(%rsi,%rdx,4),%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm1,%xmm6
pmuludq %xmm2,%xmm4
pshufd $0xf5,%xmm5,%xmm7
pmuludq %xmm0,%xmm7
pmuludq %xmm5,%xmm3
movdqu -0x10(%rsi,%rdx,4),%xmm0
movdqu (%rsi,%rdx,4),%xmm5
pmuludq %xmm0,%xmm4
pshufd $0xe8,%xmm4,%xmm2
pshufd $0xf5,%xmm0,%xmm0
pmuludq %xmm6,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm2
pmuludq %xmm5,%xmm3
pshufd $0xe8,%xmm3,%xmm1
pshufd $0xf5,%xmm5,%xmm0
pmuludq %xmm7,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%r9
jne    13a0 <problem11+0x220>
movdqa %xmm2,%xmm3
movdqa %xmm1,%xmm4
test   %r10,%r10
je     14ec <problem11+0x36c>
add    %r8,%rdx
lea    (%r12,%rdx,4),%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%rdx,%rax,1),%xmm0
movdqu 0x10(%rdx,%rax,1),%xmm4
pshufd $0xf5,%xmm0,%xmm5
pmuludq %xmm2,%xmm0
pshufd $0xe8,%xmm0,%xmm3
pshufd $0xf5,%xmm2,%xmm0
pmuludq %xmm5,%xmm0
pshufd $0xe8,%xmm0,%xmm0
punpckldq %xmm0,%xmm3
pshufd $0xf5,%xmm4,%xmm0
pmuludq %xmm1,%xmm4
pshufd $0xe8,%xmm4,%xmm4
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm0
punpckldq %xmm0,%xmm4
add    $0x20,%rax
movdqa %xmm3,%xmm2
movdqa %xmm4,%xmm1
cmp    %rax,%rdi
jne    1490 <problem11+0x310>
pshufd $0xf5,%xmm3,%xmm0
pshufd $0xf5,%xmm4,%xmm1
pmuludq %xmm0,%xmm1
pmuludq %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm0
pmuludq %xmm4,%xmm0
pshufd $0xaa,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pmuludq %xmm0,%xmm2
movd   %xmm2,%eax
mov    %r13,%rdx
mov    -0x50(%rbp),%r9
cmp    %r9,%r13
je     1335 <problem11+0x1b5>
nopl   0x0(%rax,%rax,1)
imul   (%rbx,%rdx,4),%eax
add    $0x1,%rdx
cmp    %rdx,%r9
jne    1530 <problem11+0x3b0>
jmp    1335 <problem11+0x1b5>
mov    %r13,%rdi
call   1030 <fclose@plt>
mov    -0x50(%rbp),%r9
xor    %ecx,%ecx
jmp    1558 <problem11+0x3d8>
xor    %ecx,%ecx
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%rsi
mov    -0x44(%rbp),%eax
sub    %esi,%eax
je     1cc1 <problem11+0xb41>
mov    %ecx,-0x40(%rbp)
mov    %eax,-0x44(%rbp)
mov    %eax,%eax
mov    %rax,-0xb0(%rbp)
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x80(%rbp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0xb8(%rbp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
lea    -0x1(%r9),%rax
mov    %rax,-0x98(%rbp)
cmp    $0x8,%esi
setae  %al
cmpl   $0x1,-0x2c(%rbp)
sete   %dl
and    %al,%dl
mov    %dl,-0x90(%rbp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
add    $0x2,%rax
mov    %rcx,%rdx
mov    %rcx,-0x78(%rbp)
and    %rcx,%rax
mov    %rax,-0xf8(%rbp)
mov    %r9d,%r11d
and    $0x3,%r11d
mov    -0x70(%rbp),%rdi
mov    %rdi,%rax
shl    $0x5,%rax
mov    -0x60(%rbp),%rdx
lea    (%rax,%rdx,1),%r14
add    $0x10,%r14
lea    0x0(,%rdi,4),%rax
mov    %rax,-0x68(%rbp)
mov    %rdi,%rcx
shl    $0x6,%rcx
lea    0x10(%rdx),%r10
mov    %r11,-0x88(%rbp)
neg    %r11
mov    %rdi,%rdx
shl    $0x4,%rdx
movdqa 0x9dd(%rip),%xmm0
mov    $0x3,%eax
mov    %rax,-0xa0(%rbp)
mov    $0x2,%eax
mov    %rax,-0xc8(%rbp)
mov    $0x1,%eax
mov    %rax,-0xc0(%rbp)
xor    %eax,%eax
mov    %rax,-0x38(%rbp)
mov    %rdx,-0xa8(%rbp)
jmp    16ac <problem11+0x52c>
cs nopw 0x0(%rax,%rax,1)
mov    -0x38(%rbp),%rbx
add    $0x1,%rbx
mov    -0x68(%rbp),%rax
mov    -0xf0(%rbp),%r14
add    %rax,%r14
mov    -0xe8(%rbp),%r10
add    %rax,%r10
addq   $0x1,-0xa0(%rbp)
01
addq   $0x1,-0xc8(%rbp)
01
addq   $0x1,-0xc0(%rbp)
01
mov    %rbx,%rax
mov    %rbx,-0x38(%rbp)
cmp    -0xb0(%rbp),%rbx
je     195a <problem11+0x7da>
cmpl   $0x0,-0x2c(%rbp)
mov    %r14,-0xf0(%rbp)
mov    %r10,-0xe8(%rbp)
je     1660 <problem11+0x4e0>
mov    -0x60(%rbp),%r12
xor    %r8d,%r8d
jmp    1705 <problem11+0x585>
nopl   0x0(%rax)
mov    $0x1,%ebx
mov    -0x40(%rbp),%eax
cmp    %eax,%ebx
cmovg  %ebx,%eax
mov    %eax,-0x40(%rbp)
add    $0x1,%r8
add    $0x4,%r14
add    $0x4,%r10
add    $0x4,%r12
mov    -0x70(%rbp),%rdi
cmp    %rdi,%r8
mov    -0x58(%rbp),%rsi
mov    -0x50(%rbp),%r9
je     1660 <problem11+0x4e0>
test   %esi,%esi
je     16d0 <problem11+0x550>
cmpb   $0x0,-0x90(%rbp)
je     1870 <problem11+0x6f0>
cmpq   $0x0,-0xb8(%rbp)
je     1941 <problem11+0x7c1>
mov    -0xf8(%rbp),%rax
xor    %esi,%esi
xor    %ebx,%ebx
movdqa %xmm0,%xmm2
movdqa %xmm0,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%r10,%rsi,1),%xmm3
movdqu (%r10,%rsi,1),%xmm4
pshufd $0xf5,%xmm3,%xmm5
pshufd $0xf5,%xmm2,%xmm6
pmuludq %xmm5,%xmm6
pmuludq %xmm2,%xmm3
pshufd $0xf5,%xmm4,%xmm2
pshufd $0xf5,%xmm1,%xmm5
pmuludq %xmm2,%xmm5
pmuludq %xmm1,%xmm4
movdqu -0x10(%r14,%rsi,1),%xmm1
movdqu (%r14,%rsi,1),%xmm7
pmuludq %xmm1,%xmm3
pshufd $0xe8,%xmm3,%xmm2
pshufd $0xf5,%xmm1,%xmm1
pmuludq %xmm6,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm2
pmuludq %xmm7,%xmm4
pshufd $0xe8,%xmm4,%xmm1
pshufd $0xf5,%xmm7,%xmm3
pmuludq %xmm5,%xmm3
pshufd $0xe8,%xmm3,%xmm3
punpckldq %xmm3,%xmm1
add    $0x10,%rbx
add    %rcx,%rsi
add    $0xfffffffffffffffe,%rax
jne    1740 <problem11+0x5c0>
testb  $0x1,-0x78(%rbp)
je     182e <problem11+0x6ae>
mov    -0x60(%rbp),%rax
lea    (%rax,%r8,4),%rax
add    -0x38(%rbp),%rbx
imul   %rdi,%rbx
movdqu (%rax,%rbx,4),%xmm3
movdqu 0x10(%rax,%rbx,4),%xmm4
pshufd $0xf5,%xmm3,%xmm5
pmuludq %xmm2,%xmm3
pshufd $0xf5,%xmm2,%xmm2
pshufd $0xe8,%xmm3,%xmm3
pmuludq %xmm5,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm3
pshufd $0xf5,%xmm4,%xmm2
pmuludq %xmm1,%xmm4
pshufd $0xf5,%xmm1,%xmm1
pshufd $0xe8,%xmm4,%xmm4
pmuludq %xmm2,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm1,%xmm4
movdqa %xmm3,%xmm2
movdqa %xmm4,%xmm1
pshufd $0xf5,%xmm2,%xmm3
pshufd $0xf5,%xmm1,%xmm4
pmuludq %xmm3,%xmm4
pmuludq %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
pmuludq %xmm1,%xmm2
pshufd $0xaa,%xmm4,%xmm1
pmuludq %xmm4,%xmm1
pmuludq %xmm2,%xmm1
movd   %xmm1,%ebx
mov    -0x80(%rbp),%rax
mov    %rax,%r13
cmp    %r9,%rax
je     16d5 <problem11+0x555>
jmp    1878 <problem11+0x6f8>
nopl   0x0(%rax)
mov    $0x1,%ebx
xor    %r13d,%r13d
mov    -0x98(%rbp),%rax
sub    %r13,%rax
cmpq   $0x0,-0x88(%rbp)
je     18c9 <problem11+0x749>
mov    -0x38(%rbp),%rdx
lea    (%rdx,%r13,1),%rsi
imul   -0x70(%rbp),%rsi
lea    (%r12,%rsi,4),%rsi
xor    %edi,%edi
mov    -0x68(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
imul   (%rsi),%ebx
add    $0xffffffffffffffff,%rdi
add    %rdx,%rsi
cmp    %rdi,%r11
jne    18b0 <problem11+0x730>
sub    %rdi,%r13
mov    -0xa8(%rbp),%rdx
cmp    $0x3,%rax
jb     16d5 <problem11+0x555>
mov    -0x50(%rbp),%rax
sub    %r13,%rax
mov    -0xa0(%rbp),%rdx
lea    (%rdx,%r13,1),%rsi
mov    -0x68(%rbp),%rdx
imul   %rdx,%rsi
mov    -0xc8(%rbp),%rdi
lea    (%rdi,%r13,1),%r9
imul   %rdx,%r9
mov    -0x38(%rbp),%rdi
lea    (%rdi,%r13,1),%r15
imul   %rdx,%r15
add    -0xc0(%rbp),%r13
imul   %rdx,%r13
mov    -0xa8(%rbp),%rdx
mov    %r12,%rdi
nopl   (%rax)
imul   (%rdi,%r15,1),%ebx
imul   (%rdi,%r13,1),%ebx
imul   (%rdi,%r9,1),%ebx
imul   (%rdi,%rsi,1),%ebx
add    %rdx,%rdi
add    $0xfffffffffffffffc,%rax
jne    1920 <problem11+0x7a0>
jmp    16d5 <problem11+0x555>
xor    %ebx,%ebx
movdqa %xmm0,%xmm2
movdqa %xmm0,%xmm1
testb  $0x1,-0x78(%rbp)
jne    17cb <problem11+0x64b>
jmp    182e <problem11+0x6ae>
cmpl   $0x0,-0x44(%rbp)
mov    -0x40(%rbp),%ecx
je     1cc1 <problem11+0xb41>
mov    -0x2c(%rbp),%eax
mov    %eax,%r12d
sub    %esi,%r12d
mov    %r9d,%eax
and    $0x3,%eax
mov    %rax,-0x58(%rbp)
mov    %r9d,%r15d
and    $0xfffffffc,%r15d
mov    -0x60(%rbp),%rbx
lea    (%rbx,%rdi,8),%r8
add    $0x8,%r8
lea    0x10(%rdx),%rax
lea    0x4(%rbx,%rdi,4),%r11
lea    (%rdi,%rdi,2),%rdx
mov    %rdx,-0x78(%rbp)
lea    (%rbx,%rdx,4),%r14
add    $0xc,%r14
lea    0x4(,%rdi,4),%rdx
xor    %edi,%edi
mov    %rdi,-0x38(%rbp)
mov    %rbx,%rdi
jmp    1a02 <problem11+0x882>
nopl   0x0(%rax)
mov    -0x38(%rbp),%r10
add    $0x1,%r10
mov    -0x68(%rbp),%r9
mov    -0x40(%rbp),%r8
add    %r9,%r8
mov    -0x90(%rbp),%r11
add    %r9,%r11
mov    -0x88(%rbp),%r14
add    %r9,%r14
mov    -0x80(%rbp),%rdi
add    %r9,%rdi
mov    %r10,%rbx
mov    %r10,-0x38(%rbp)
cmp    -0xb0(%rbp),%r10
je     1af2 <problem11+0x972>
test   %r12,%r12
mov    %r8,-0x40(%rbp)
mov    %r11,-0x90(%rbp)
mov    %r14,-0x88(%rbp)
mov    %rdi,-0x80(%rbp)
je     19c0 <problem11+0x840>
mov    %rdi,%r9
xor    %r13d,%r13d
jmp    1a5a <problem11+0x8da>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x1,%r10d
cmp    %ecx,%r10d
cmovg  %r10d,%ecx
add    $0x1,%r13
add    $0x4,%r8
add    $0x4,%r11
add    $0x4,%r14
add    $0x4,%r9
cmp    %r12,%r13
je     19c0 <problem11+0x840>
test   %esi,%esi
je     1a30 <problem11+0x8b0>
cmpq   $0x3,-0x98(%rbp)
03
jae    1a80 <problem11+0x900>
mov    $0x1,%r10d
xor    %ebx,%ebx
jmp    1ab0 <problem11+0x930>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    $0x1,%r10d
xor    %edi,%edi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
imul   (%r9,%rdi,1),%r10d
imul   (%r11,%rdi,1),%r10d
imul   (%r8,%rdi,1),%r10d
imul   (%r14,%rdi,1),%r10d
add    $0x4,%rbx
add    %rax,%rdi
cmp    %rbx,%r15
jne    1a90 <problem11+0x910>
cmpq   $0x0,-0x58(%rbp)
je     1a36 <problem11+0x8b6>
mov    -0x38(%rbp),%rdi
add    %rbx,%rdi
add    %r13,%rbx
imul   -0x70(%rbp),%rdi
add    %rbx,%rdi
mov    -0x60(%rbp),%rbx
lea    (%rbx,%rdi,4),%rbx
mov    -0x58(%rbp),%rdi
nopl   0x0(%rax)
imul   (%rbx),%r10d
add    %rdx,%rbx
add    $0xffffffffffffffff,%rdi
jne    1ae0 <problem11+0x960>
jmp    1a36 <problem11+0x8b6>
cmpl   $0x0,-0x44(%rbp)
je     1cc1 <problem11+0xb41>
lea    -0x1(%rsi),%eax
mov    %eax,-0xb8(%rbp)
movslq %eax,%rbx
mov    -0x50(%rbp),%rdx
mov    %edx,%r8d
and    $0x3,%r8d
lea    0x0(,%rbx,4),%r14
mov    -0x70(%rbp),%rax
lea    (%r14,%rax,8),%r10
add    $0xfffffffffffffff8,%r10
addq   $0xfffffffffffffff0,-0xa8(%rbp)
f0
lea    (%r9,%rbx,4),%r12
add    $0xfffffffffffffffc,%r12
mov    -0x78(%rbp),%rdi
lea    (%r14,%rdi,4),%rdi
add    $0xfffffffffffffff4,%rdi
and    $0xfffffffc,%edx
neg    %rdx
mov    %rdx,-0x50(%rbp)
mov    -0x60(%rbp),%rdx
mov    %rbx,-0x78(%rbp)
lea    (%rdx,%rbx,4),%rdx
mov    %rdx,-0xa0(%rbp)
lea    -0x4(,%rax,4),%r15
ff
xor    %eax,%eax
mov    %rax,-0x40(%rbp)
mov    %r8,-0x58(%rbp)
mov    -0xa8(%rbp),%r13
jmp    1bc2 <problem11+0xa42>
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rbp),%rdx
add    $0x1,%rdx
mov    -0x68(%rbp),%rax
mov    -0x90(%rbp),%r10
add    %rax,%r10
mov    -0x88(%rbp),%r12
add    %rax,%r12
mov    -0x80(%rbp),%rdi
add    %rax,%rdi
mov    -0x38(%rbp),%r14
add    %rax,%r14
mov    %rdx,%rax
mov    %rdx,-0x40(%rbp)
cmp    -0xb0(%rbp),%rdx
je     1cc1 <problem11+0xb41>
mov    -0xb8(%rbp),%eax
cmp    -0x2c(%rbp),%eax
mov    %r14,-0x38(%rbp)
mov    %r10,-0x90(%rbp)
mov    %r12,-0x88(%rbp)
mov    %rdi,-0x80(%rbp)
jae    1b80 <problem11+0xa00>
mov    -0xa0(%rbp),%r9
mov    %rdi,%rdx
mov    -0x78(%rbp),%r11
jmp    1c2c <problem11+0xaac>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x1,%ebx
cmp    %ecx,%ebx
cmovg  %ebx,%ecx
add    $0x1,%r11
add    $0x4,%r10
add    $0x4,%r12
add    $0x4,%rdx
add    $0x4,%r14
add    $0x4,%r9
cmp    -0x2c(%rbp),%r11d
jae    1b80 <problem11+0xa00>
test   %esi,%esi
je     1c00 <problem11+0xa80>
cmpq   $0x3,-0x98(%rbp)
03
jae    1c50 <problem11+0xad0>
mov    $0x1,%ebx
xor    %eax,%eax
test   %r8,%r8
jne    1c8f <problem11+0xb0f>
jmp    1c05 <problem11+0xa85>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%ebx
xor    %eax,%eax
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%r8
nop
imul   (%rdi,%r14,1),%ebx
imul   (%rdi,%r12,1),%ebx
imul   (%rdi,%r10,1),%ebx
imul   (%rdi,%rdx,1),%ebx
add    %r13,%rdi
add    $0xfffffffffffffffc,%rax
cmp    %rax,%r8
jne    1c60 <problem11+0xae0>
neg    %rax
mov    -0x58(%rbp),%r8
test   %r8,%r8
je     1c05 <problem11+0xa85>
mov    -0x40(%rbp),%rdi
add    %rax,%rdi
imul   -0x70(%rbp),%rdi
sub    %rax,%rdi
lea    (%r9,%rdi,4),%rax
mov    %r8,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
imul   (%rax),%ebx
add    %r15,%rax
add    $0xffffffffffffffff,%rdi
jne    1cb0 <problem11+0xb30>
jmp    1c05 <problem11+0xa85>
lea    0x374(%rip),%rdi
mov    -0xe0(%rbp),%rdx
call   1040 <printf@plt>
mov    -0xd8(%rbp),%rsp
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x22ef(%rip),%rax
mov    (%rax),%edi
lea    0x318(%rip),%rsi
mov    %rbx,%rdx
call   1070 <fprintf@plt>
mov    0x22cf(%rip),%rax
mov    (%rax),%edi
call   10a0 <exit@plt>

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

LLVM IR (-O2):
@.str = [2 x i8] c"r\00"
@stderr = global i32 0
@.str.1 = [42 x i8] c"Error: the file \22%s\22 could not be opened.\00"
@EXIT_FAILURE = global i32 0
@.str.2 = [76 x i8] c"Problem 11: The largest sum of %u colinear integers in the grid \22%s\22 is %u\0A\00"
define void @problem11(i32 %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca [3 x i8]
%6 = tail call i32* @fopen(i8* %1, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%7 = icmp eq i32* %6, null
br i1 %7, label %8, label %13
8: ; preds = %4
%9 = load i32, i32* @stderr
%10 = tail call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.1, i64 0, i64 0), i8* %1)
%11 = load i32, i32* @EXIT_FAILURE
%12 = tail call i32 @exit(i32 %11)
unreachable
13: ; preds = %4
%14 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 0
%15 = zext i32 %2 to i64
%16 = zext i32 %3 to i64
%17 = tail call i8* @llvm.stacksave()
%18 = mul nuw i64 %16, %15
%19 = alloca i32, i64 %18
%20 = icmp eq i32 %2, 0
br i1 %20, label %21, label %23
21: ; preds = %13
%22 = call i32 @fclose(i32* %6)
br label %66
23: ; preds = %13
%24 = icmp eq i32 %3, 0
br label %25
25: ; preds = %23, %49
%26 = phi i64 [ 0, %23 ], [ %50, %49 ]
br i1 %24, label %49, label %27
27: ; preds = %25
%28 = mul nuw nsw i64 %26, %16
%29 = getelementptr inbounds i32, i32* %19, i64 %28
br label %52
30: ; preds = %49
%31 = call i32 @fclose(i32* %6)
br i1 %20, label %66, label %32
32: ; preds = %30
%33 = sub i32 %3, %0
%34 = icmp eq i32 %33, 0
%35 = icmp eq i32 %0, 0
%36 = zext i32 %33 to i64
%37 = zext i32 %0 to i64
%38 = and i64 %37, 4294967288
%39 = add nsw i64 %38, -8
%40 = lshr exact i64 %39, 3
%41 = add nuw nsw i64 %40, 1
%42 = icmp ult i32 %0, 8
%43 = and i64 %37, 4294967288
%44 = and i64 %41, 3
%45 = icmp ult i64 %39, 24
%46 = and i64 %41, 4611686018427387900
%47 = icmp eq i64 %44, 0
%48 = icmp eq i64 %43, %37
br label %60
49: ; preds = %52, %25
%50 = add nuw nsw i64 %26, 1
%51 = icmp eq i64 %50, %15
br i1 %51, label %30, label %25
52: ; preds = %27, %52
%53 = phi i64 [ 0, %27 ], [ %58, %52 ]
%54 = call i32 @fgets(i8* %14, i32 3, i32* %6)
%55 = call i32 @atoi(i8* %14)
%56 = getelementptr inbounds i32, i32* %29, i64 %53
store i32 %55, i32* %56
%57 = call i32 @fgetc(i32* %6)
%58 = add nuw nsw i64 %53, 1
%59 = icmp eq i64 %58, %16
br i1 %59, label %49, label %52
60: ; preds = %32, %174
%61 = phi i64 [ 0, %32 ], [ %176, %174 ]
%62 = phi i32 [ 0, %32 ], [ %175, %174 ]
br i1 %34, label %174, label %63
63: ; preds = %60
%64 = mul nuw nsw i64 %61, %16
%65 = getelementptr inbounds i32, i32* %19, i64 %64
br label %91
66: ; preds = %174, %21, %30
%67 = phi i32 [ 0, %30 ], [ 0, %21 ], [ %175, %174 ]
%68 = sub i32 %2, %0
%69 = icmp eq i32 %68, 0
br i1 %69, label %407, label %70
70: ; preds = %66
%71 = icmp eq i32 %3, 0
%72 = icmp eq i32 %0, 0
%73 = zext i32 %68 to i64
%74 = zext i32 %0 to i64
%75 = and i64 %74, 4294967288
%76 = add nsw i64 %75, -8
%77 = lshr exact i64 %76, 3
%78 = add nuw nsw i64 %77, 1
%79 = add nsw i64 %74, -1
%80 = icmp ugt i32 %0, 7
%81 = icmp eq i32 %3, 1
%82 = and i1 %80, %81
%83 = and i64 %74, 4294967288
%84 = and i64 %78, 1
%85 = icmp eq i64 %76, 0
%86 = and i64 %78, 4611686018427387902
%87 = icmp eq i64 %84, 0
%88 = icmp eq i64 %83, %74
%89 = and i64 %74, 3
%90 = icmp eq i64 %89, 0
br label %193
91: ; preds = %63, %178
%92 = phi i64 [ 0, %63 ], [ %182, %178 ]
%93 = phi i32 [ %62, %63 ], [ %181, %178 ]
br i1 %35, label %178, label %94
94: ; preds = %91
br i1 %42, label %171, label %95
95: ; preds = %94
br i1 %45, label %143, label %96
96: ; preds = %95, %96
%97 = phi i64 [ %140, %96 ], [ 0, %95 ]
%98 = phi <4 x i32> [ %138, %96 ], [ <i32 1, i32 1, i32 1, i32 1>, %95 ]
%99 = phi <4 x i32> [ %139, %96 ], [ <i32 1, i32 1, i32 1, i32 1>, %95 ]
%100 = phi i64 [ %141, %96 ], [ 0, %95 ]
%101 = add nuw nsw i64 %97, %92
%102 = getelementptr inbounds i32, i32* %65, i64 %101
%103 = bitcast i32* %102 to <4 x i32>*
%104 = load <4 x i32>, <4 x i32>* %103
%105 = getelementptr inbounds i32, i32* %102, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = mul <4 x i32> %104, %98
%109 = mul <4 x i32> %107, %99
%110 = or i64 %97, 8
%111 = add nuw nsw i64 %110, %92
%112 = getelementptr inbounds i32, i32* %65, i64 %111
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = getelementptr inbounds i32, i32* %112, i64 4
%116 = bitcast i32* %115 to <4 x i32>*
%117 = load <4 x i32>, <4 x i32>* %116
%118 = mul <4 x i32> %114, %108
%119 = mul <4 x i32> %117, %109
%120 = or i64 %97, 16
%121 = add nuw nsw i64 %120, %92
%122 = getelementptr inbounds i32, i32* %65, i64 %121
%123 = bitcast i32* %122 to <4 x i32>*
%124 = load <4 x i32>, <4 x i32>* %123
%125 = getelementptr inbounds i32, i32* %122, i64 4
%126 = bitcast i32* %125 to <4 x i32>*
%127 = load <4 x i32>, <4 x i32>* %126
%128 = mul <4 x i32> %124, %118
%129 = mul <4 x i32> %127, %119
%130 = or i64 %97, 24
%131 = add nuw nsw i64 %130, %92
%132 = getelementptr inbounds i32, i32* %65, i64 %131
%133 = bitcast i32* %132 to <4 x i32>*
%134 = load <4 x i32>, <4 x i32>* %133
%135 = getelementptr inbounds i32, i32* %132, i64 4
%136 = bitcast i32* %135 to <4 x i32>*
%137 = load <4 x i32>, <4 x i32>* %136
%138 = mul <4 x i32> %134, %128
%139 = mul <4 x i32> %137, %129
%140 = add nuw i64 %97, 32
%141 = add i64 %100, 4
%142 = icmp eq i64 %141, %46
br i1 %142, label %143, label %96
143: ; preds = %96, %95
%144 = phi <4 x i32> [ undef, %95 ], [ %138, %96 ]
%145 = phi <4 x i32> [ undef, %95 ], [ %139, %96 ]
%146 = phi i64 [ 0, %95 ], [ %140, %96 ]
%147 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %95 ], [ %138, %96 ]
%148 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %95 ], [ %139, %96 ]
br i1 %47, label %166, label %149
149: ; preds = %143, %149
%150 = phi i64 [ %163, %149 ], [ %146, %143 ]
%151 = phi <4 x i32> [ %161, %149 ], [ %147, %143 ]
%152 = phi <4 x i32> [ %162, %149 ], [ %148, %143 ]
%153 = phi i64 [ %164, %149 ], [ 0, %143 ]
%154 = add nuw nsw i64 %150, %92
%155 = getelementptr inbounds i32, i32* %65, i64 %154
%156 = bitcast i32* %155 to <4 x i32>*
%157 = load <4 x i32>, <4 x i32>* %156
%158 = getelementptr inbounds i32, i32* %155, i64 4
%159 = bitcast i32* %158 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = mul <4 x i32> %157, %151
%162 = mul <4 x i32> %160, %152
%163 = add nuw i64 %150, 8
%164 = add i64 %153, 1
%165 = icmp eq i64 %164, %44
br i1 %165, label %166, label %149
166: ; preds = %149, %143
%167 = phi <4 x i32> [ %144, %143 ], [ %161, %149 ]
%168 = phi <4 x i32> [ %145, %143 ], [ %162, %149 ]
%169 = mul <4 x i32> %168, %167
%170 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %169)
br i1 %48, label %178, label %171
171: ; preds = %94, %166
%172 = phi i64 [ 0, %94 ], [ %43, %166 ]
%173 = phi i32 [ 1, %94 ], [ %170, %166 ]
br label %184
174: ; preds = %178, %60
%175 = phi i32 [ %62, %60 ], [ %181, %178 ]
%176 = add nuw nsw i64 %61, 1
%177 = icmp eq i64 %176, %15
br i1 %177, label %66, label %60
178: ; preds = %184, %166, %91
%179 = phi i32 [ 1, %91 ], [ %170, %166 ], [ %190, %184 ]
%180 = icmp sgt i32 %179, %93
%181 = select i1 %180, i32 %179, i32 %93
%182 = add nuw nsw i64 %92, 1
%183 = icmp eq i64 %182, %36
br i1 %183, label %174, label %91
184: ; preds = %171, %184
%185 = phi i64 [ %191, %184 ], [ %172, %171 ]
%186 = phi i32 [ %190, %184 ], [ %173, %171 ]
%187 = add nuw nsw i64 %185, %92
%188 = getelementptr inbounds i32, i32* %65, i64 %187
%189 = load i32, i32* %188
%190 = mul nsw i32 %189, %186
%191 = add nuw nsw i64 %185, 1
%192 = icmp eq i64 %191, %37
br i1 %192, label %178, label %184
193: ; preds = %70, %285
%194 = phi i64 [ 0, %70 ], [ %287, %285 ]
%195 = phi i32 [ %67, %70 ], [ %286, %285 ]
br i1 %71, label %285, label %207
196: ; preds = %285
br i1 %69, label %407, label %197
197: ; preds = %196
%198 = sub i32 %3, %0
%199 = icmp eq i32 %198, 0
%200 = icmp eq i32 %0, 0
%201 = zext i32 %68 to i64
%202 = zext i32 %198 to i64
%203 = and i64 %74, 3
%204 = icmp ult i64 %79, 3
%205 = and i64 %74, 4294967292
%206 = icmp eq i64 %203, 0
br label %323
207: ; preds = %193, %289
%208 = phi i64 [ %293, %289 ], [ 0, %193 ]
%209 = phi i32 [ %292, %289 ], [ %195, %193 ]
br i1 %72, label %289, label %210
210: ; preds = %207
%211 = getelementptr inbounds i32, i32* %19, i64 %208
br i1 %82, label %212, label %264
212: ; preds = %210
br i1 %85, label %242, label %213
213: ; preds = %212, %213
%214 = phi i64 [ %239, %213 ], [ 0, %212 ]
%215 = phi <4 x i32> [ %237, %213 ], [ <i32 1, i32 1, i32 1, i32 1>, %212 ]
%216 = phi <4 x i32> [ %238, %213 ], [ <i32 1, i32 1, i32 1, i32 1>, %212 ]
%217 = phi i64 [ %240, %213 ], [ 0, %212 ]
%218 = add nuw nsw i64 %214, %194
%219 = mul nuw nsw i64 %218, %16
%220 = getelementptr inbounds i32, i32* %211, i64 %219
%221 = bitcast i32* %220 to <4 x i32>*
%222 = load <4 x i32>, <4 x i32>* %221
%223 = getelementptr inbounds i32, i32* %220, i64 4
%224 = bitcast i32* %223 to <4 x i32>*
%225 = load <4 x i32>, <4 x i32>* %224
%226 = mul <4 x i32> %222, %215
%227 = mul <4 x i32> %225, %216
%228 = or i64 %214, 8
%229 = add nuw nsw i64 %228, %194
%230 = mul nuw nsw i64 %229, %16
%231 = getelementptr inbounds i32, i32* %211, i64 %230
%232 = bitcast i32* %231 to <4 x i32>*
%233 = load <4 x i32>, <4 x i32>* %232
%234 = getelementptr inbounds i32, i32* %231, i64 4
%235 = bitcast i32* %234 to <4 x i32>*
%236 = load <4 x i32>, <4 x i32>* %235
%237 = mul <4 x i32> %233, %226
%238 = mul <4 x i32> %236, %227
%239 = add nuw i64 %214, 16
%240 = add i64 %217, 2
%241 = icmp eq i64 %240, %86
br i1 %241, label %242, label %213
242: ; preds = %213, %212
%243 = phi <4 x i32> [ undef, %212 ], [ %237, %213 ]
%244 = phi <4 x i32> [ undef, %212 ], [ %238, %213 ]
%245 = phi i64 [ 0, %212 ], [ %239, %213 ]
%246 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %212 ], [ %237, %213 ]
%247 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %212 ], [ %238, %213 ]
br i1 %87, label %259, label %248
248: ; preds = %242
%249 = add nuw nsw i64 %245, %194
%250 = mul nuw nsw i64 %249, %16
%251 = getelementptr inbounds i32, i32* %211, i64 %250
%252 = bitcast i32* %251 to <4 x i32>*
%253 = load <4 x i32>, <4 x i32>* %252
%254 = getelementptr inbounds i32, i32* %251, i64 4
%255 = bitcast i32* %254 to <4 x i32>*
%256 = load <4 x i32>, <4 x i32>* %255
%257 = mul <4 x i32> %253, %246
%258 = mul <4 x i32> %256, %247
br label %259
259: ; preds = %242, %248
%260 = phi <4 x i32> [ %243, %242 ], [ %257, %248 ]
%261 = phi <4 x i32> [ %244, %242 ], [ %258, %248 ]
%262 = mul <4 x i32> %261, %260
%263 = call i32 @llvm.vector.reduce.mul.v4i32(<4 x i32> %262)
br i1 %88, label %289, label %264
264: ; preds = %210, %259
%265 = phi i64 [ 0, %210 ], [ %83, %259 ]
%266 = phi i32 [ 1, %210 ], [ %263, %259 ]
%267 = sub nsw i64 %79, %265
br i1 %90, label %280, label %268
268: ; preds = %264, %268
%269 = phi i64 [ %277, %268 ], [ %265, %264 ]
%270 = phi i32 [ %276, %268 ], [ %266, %264 ]
%271 = phi i64 [ %278, %268 ], [ 0, %264 ]
%272 = add nuw nsw i64 %269, %194
%273 = mul nuw nsw i64 %272, %16
%274 = getelementptr inbounds i32, i32* %211, i64 %273
%275 = load i32, i32* %274
%276 = mul nsw i32 %275, %270
%277 = add nuw nsw i64 %269, 1
%278 = add i64 %271, 1
%279 = icmp eq i64 %278, %89
br i1 %279, label %280, label %268
280: ; preds = %268, %264
%281 = phi i32 [ undef, %264 ], [ %276, %268 ]
%282 = phi i64 [ %265, %264 ], [ %277, %268 ]
%283 = phi i32 [ %266, %264 ], [ %276, %268 ]
%284 = icmp ult i64 %267, 3
br i1 %284, label %289, label %295
285: ; preds = %289, %193
%286 = phi i32 [ %195, %193 ], [ %292, %289 ]
%287 = add nuw nsw i64 %194, 1
%288 = icmp eq i64 %287, %73
br i1 %288, label %196, label %193
289: ; preds = %280, %295, %259, %207
%290 = phi i32 [ 1, %207 ], [ %263, %259 ], [ %281, %280 ], [ %320, %295 ]
%291 = icmp sgt i32 %290, %209
%292 = select i1 %291, i32 %290, i32 %209
%293 = add nuw nsw i64 %208, 1
%294 = icmp eq i64 %293, %16
br i1 %294, label %285, label %207
295: ; preds = %280, %295
%296 = phi i64 [ %321, %295 ], [ %282, %280 ]
%297 = phi i32 [ %320, %295 ], [ %283, %280 ]
%298 = add nuw nsw i64 %296, %194
%299 = mul nuw nsw i64 %298, %16
%300 = getelementptr inbounds i32, i32* %211, i64 %299
%301 = load i32, i32* %300
%302 = mul nsw i32 %301, %297
%303 = add nuw nsw i64 %296, 1
%304 = add nuw nsw i64 %303, %194
%305 = mul nuw nsw i64 %304, %16
%306 = getelementptr inbounds i32, i32* %211, i64 %305
%307 = load i32, i32* %306
%308 = mul nsw i32 %307, %302
%309 = add nuw nsw i64 %296, 2
%310 = add nuw nsw i64 %309, %194
%311 = mul nuw nsw i64 %310, %16
%312 = getelementptr inbounds i32, i32* %211, i64 %311
%313 = load i32, i32* %312
%314 = mul nsw i32 %313, %308
%315 = add nuw nsw i64 %296, 3
%316 = add nuw nsw i64 %315, %194
%317 = mul nuw nsw i64 %316, %16
%318 = getelementptr inbounds i32, i32* %211, i64 %317
%319 = load i32, i32* %318
%320 = mul nsw i32 %319, %314
%321 = add nuw nsw i64 %296, 4
%322 = icmp eq i64 %321, %74
br i1 %322, label %289, label %295
323: ; preds = %197, %341
%324 = phi i64 [ 0, %197 ], [ %343, %341 ]
%325 = phi i32 [ %286, %197 ], [ %342, %341 ]
br i1 %199, label %341, label %337
326: ; preds = %341
br i1 %69, label %407, label %327
327: ; preds = %326
%328 = add i32 %0, -1
%329 = icmp ult i32 %328, %3
%330 = icmp eq i32 %0, 0
%331 = sext i32 %328 to i64
%332 = zext i32 %68 to i64
%333 = and i64 %74, 3
%334 = icmp ult i64 %79, 3
%335 = and i64 %74, 4294967292
%336 = icmp eq i64 %333, 0
br label %410
337: ; preds = %323, %363
%338 = phi i64 [ %367, %363 ], [ 0, %323 ]
%339 = phi i32 [ %366, %363 ], [ %325, %323 ]
br i1 %200, label %363, label %340
340: ; preds = %337
br i1 %204, label %345, label %369
341: ; preds = %363, %323
%342 = phi i32 [ %325, %323 ], [ %366, %363 ]
%343 = add nuw nsw i64 %324, 1
%344 = icmp eq i64 %343, %201
br i1 %344, label %326, label %323
345: ; preds = %369, %340
%346 = phi i32 [ undef, %340 ], [ %403, %369 ]
%347 = phi i64 [ 0, %340 ], [ %404, %369 ]
%348 = phi i32 [ 1, %340 ], [ %403, %369 ]
br i1 %206, label %363, label %349
349: ; preds = %345, %349
%350 = phi i64 [ %360, %349 ], [ %347, %345 ]
%351 = phi i32 [ %359, %349 ], [ %348, %345 ]
%352 = phi i64 [ %361, %349 ], [ 0, %345 ]
%353 = add nuw nsw i64 %350, %324
%354 = mul nuw nsw i64 %353, %16
%355 = getelementptr inbounds i32, i32* %19, i64 %354
%356 = add nuw nsw i64 %350, %338
%357 = getelementptr inbounds i32, i32* %355, i64 %356
%358 = load i32, i32* %357
%359 = mul nsw i32 %358, %351
%360 = add nuw nsw i64 %350, 1
%361 = add i64 %352, 1
%362 = icmp eq i64 %361, %203
br i1 %362, label %363, label %349
363: ; preds = %345, %349, %337
%364 = phi i32 [ 1, %337 ], [ %346, %345 ], [ %359, %349 ]
%365 = icmp sgt i32 %364, %339
%366 = select i1 %365, i32 %364, i32 %339
%367 = add nuw nsw i64 %338, 1
%368 = icmp eq i64 %367, %202
br i1 %368, label %341, label %337
369: ; preds = %340, %369
%370 = phi i64 [ %404, %369 ], [ 0, %340 ]
%371 = phi i32 [ %403, %369 ], [ 1, %340 ]
%372 = phi i64 [ %405, %369 ], [ 0, %340 ]
%373 = add nuw nsw i64 %370, %324
%374 = mul nuw nsw i64 %373, %16
%375 = getelementptr inbounds i32, i32* %19, i64 %374
%376 = add nuw nsw i64 %370, %338
%377 = getelementptr inbounds i32, i32* %375, i64 %376
%378 = load i32, i32* %377
%379 = mul nsw i32 %378, %371
%380 = or i64 %370, 1
%381 = add nuw nsw i64 %380, %324
%382 = mul nuw nsw i64 %381, %16
%383 = getelementptr inbounds i32, i32* %19, i64 %382
%384 = add nuw nsw i64 %380, %338
%385 = getelementptr inbounds i32, i32* %383, i64 %384
%386 = load i32, i32* %385
%387 = mul nsw i32 %386, %379
%388 = or i64 %370, 2
%389 = add nuw nsw i64 %388, %324
%390 = mul nuw nsw i64 %389, %16
%391 = getelementptr inbounds i32, i32* %19, i64 %390
%392 = add nuw nsw i64 %388, %338
%393 = getelementptr inbounds i32, i32* %391, i64 %392
%394 = load i32, i32* %393
%395 = mul nsw i32 %394, %387
%396 = or i64 %370, 3
%397 = add nuw nsw i64 %396, %324
%398 = mul nuw nsw i64 %397, %16
%399 = getelementptr inbounds i32, i32* %19, i64 %398
%400 = add nuw nsw i64 %396, %338
%401 = getelementptr inbounds i32, i32* %399, i64 %400
%402 = load i32, i32* %401
%403 = mul nsw i32 %402, %395
%404 = add nuw nsw i64 %370, 4
%405 = add i64 %372, 4
%406 = icmp eq i64 %405, %205
br i1 %406, label %345, label %369
407: ; preds = %417, %66, %196, %326
%408 = phi i32 [ %342, %326 ], [ %286, %196 ], [ %67, %66 ], [ %418, %417 ]
%409 = call i32 @printf(i8* getelementptr inbounds ([76 x i8], [76 x i8]* @.str.2, i64 0, i64 0), i32 %0, i8* %1, i32 %408)
ret void
410: ; preds = %327, %417
%411 = phi i64 [ 0, %327 ], [ %419, %417 ]
%412 = phi i32 [ %342, %327 ], [ %418, %417 ]
br i1 %329, label %413, label %417
413: ; preds = %410, %439
%414 = phi i64 [ %443, %439 ], [ %331, %410 ]
%415 = phi i32 [ %442, %439 ], [ %412, %410 ]
br i1 %330, label %439, label %416
416: ; preds = %413
br i1 %334, label %421, label %446
417: ; preds = %439, %410
%418 = phi i32 [ %412, %410 ], [ %442, %439 ]
%419 = add nuw nsw i64 %411, 1
%420 = icmp eq i64 %419, %332
br i1 %420, label %407, label %410
421: ; preds = %446, %416
%422 = phi i32 [ undef, %416 ], [ %480, %446 ]
%423 = phi i64 [ 0, %416 ], [ %481, %446 ]
%424 = phi i32 [ 1, %416 ], [ %480, %446 ]
br i1 %336, label %439, label %425
425: ; preds = %421, %425
%426 = phi i64 [ %436, %425 ], [ %423, %421 ]
%427 = phi i32 [ %435, %425 ], [ %424, %421 ]
%428 = phi i64 [ %437, %425 ], [ 0, %421 ]
%429 = add nuw nsw i64 %426, %411
%430 = mul nuw nsw i64 %429, %16
%431 = getelementptr inbounds i32, i32* %19, i64 %430
%432 = sub nsw i64 %414, %426
%433 = getelementptr inbounds i32, i32* %431, i64 %432
%434 = load i32, i32* %433
%435 = mul nsw i32 %434, %427
%436 = add nuw nsw i64 %426, 1
%437 = add i64 %428, 1
%438 = icmp eq i64 %437, %333
br i1 %438, label %439, label %425
439: ; preds = %421, %425, %413
%440 = phi i32 [ 1, %413 ], [ %422, %421 ], [ %435, %425 ]
%441 = icmp sgt i32 %440, %415
%442 = select i1 %441, i32 %440, i32 %415
%443 = add nsw i64 %414, 1
%444 = trunc i64 %443 to i32
%445 = icmp ult i32 %444, %3
br i1 %445, label %413, label %417
446: ; preds = %416, %446
%447 = phi i64 [ %481, %446 ], [ 0, %416 ]
%448 = phi i32 [ %480, %446 ], [ 1, %416 ]
%449 = phi i64 [ %482, %446 ], [ 0, %416 ]
%450 = add nuw nsw i64 %447, %411
%451 = mul nuw nsw i64 %450, %16
%452 = getelementptr inbounds i32, i32* %19, i64 %451
%453 = sub nsw i64 %414, %447
%454 = getelementptr inbounds i32, i32* %452, i64 %453
%455 = load i32, i32* %454
%456 = mul nsw i32 %455, %448
%457 = or i64 %447, 1
%458 = add nuw nsw i64 %457, %411
%459 = mul nuw nsw i64 %458, %16
%460 = getelementptr inbounds i32, i32* %19, i64 %459
%461 = sub nsw i64 %414, %457
%462 = getelementptr inbounds i32, i32* %460, i64 %461
%463 = load i32, i32* %462
%464 = mul nsw i32 %463, %456
%465 = or i64 %447, 2
%466 = add nuw nsw i64 %465, %411
%467 = mul nuw nsw i64 %466, %16
%468 = getelementptr inbounds i32, i32* %19, i64 %467
%469 = sub nsw i64 %414, %465
%470 = getelementptr inbounds i32, i32* %468, i64 %469
%471 = load i32, i32* %470
%472 = mul nsw i32 %471, %464
%473 = or i64 %447, 3
%474 = add nuw nsw i64 %473, %411
%475 = mul nuw nsw i64 %474, %16
%476 = getelementptr inbounds i32, i32* %19, i64 %475
%477 = sub nsw i64 %414, %473
%478 = getelementptr inbounds i32, i32* %476, i64 %477
%479 = load i32, i32* %478
%480 = mul nsw i32 %479, %472
%481 = add nuw nsw i64 %447, 4
%482 = add i64 %449, 4
%483 = icmp eq i64 %482, %335
br i1 %483, label %421, label %446
}