#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 int64_t;

/* Variables and functions */
scalar_t__ fgets_unlocked(char *, int, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, int);
int /*<<< orphan*/ sscanf(char *, char *, int *, int *, int *);
int /*<<< orphan*/ stdin;
int main() {
  int N, L1, L2;
  char line[32];
  int64_t f[301][301] = {0};
  int i, c, n;
  f[0][0] = 1;
  for (i = 1; i <= 300; ++i)
    for (c = i; c <= 300; ++c)
      for (n = 1; n <= 300; ++n)
        f[c][n] += f[c - i][n - 1];
  while (fgets_unlocked(line, 31, stdin)) {
    L1 = L2 = -1;
    sscanf(line, "%d%d%d", &N, &L1, &L2);
    L1 = (((L1) < (300)) ? (L1) : (300));
    L2 = (((L2) < (300)) ? (L2) : (300));
    int64_t ans = 0;
    if (L1 == -1)
      for (i = 0; i <= N; ++i)
        ans += f[N][i];
    else if (L2 == -1)
      for (i = 0; i <= L1; ++i)
        ans += f[N][i];
    else
      for (i = L1; i <= L2; ++i)
        ans += f[N][i];
    printf("%lld\n", ans);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x58800,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x587e0(%rbp),%rdi
xor    %esi,%esi
mov    $0x587a4,%edx
call   1040 <memset@plt>
movl   $0x1,-0x587e0(%rbp)
movl   $0x1,-0x587e4(%rbp)
cmpl   $0x12c,-0x587e4(%rbp)
jg     1259 <main+0x119>
mov    -0x587e4(%rbp),%eax
mov    %eax,-0x587e8(%rbp)
cmpl   $0x12c,-0x587e8(%rbp)
jg     1240 <main+0x100>
movl   $0x1,-0x587ec(%rbp)
cmpl   $0x12c,-0x587ec(%rbp)
jg     1227 <main+0xe7>
mov    -0x587e8(%rbp),%eax
sub    -0x587e4(%rbp),%eax
movslq %eax,%rcx
lea    -0x587e0(%rbp),%rax
imul   $0x4b4,%rcx,%rcx
add    %rcx,%rax
mov    -0x587ec(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x587e8(%rbp),%rcx
lea    -0x587e0(%rbp),%rax
imul   $0x4b4,%rcx,%rcx
add    %rcx,%rax
movslq -0x587ec(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x587ec(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x587ec(%rbp)
jmp    11af <main+0x6f>
jmp    122c <main+0xec>
mov    -0x587e8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x587e8(%rbp)
jmp    1195 <main+0x55>
jmp    1245 <main+0x105>
mov    -0x587e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x587e4(%rbp)
jmp    1179 <main+0x39>
jmp    125e <main+0x11e>
lea    -0x30(%rbp),%rdi
mov    0x2d7f(%rip),%rax
mov    (%rax),%edx
mov    $0x1f,%esi
call   1050 <fgets_unlocked@plt>
cmp    $0x0,%rax
je     1461 <main+0x321>
movl   $0xffffffff,-0x10(%rbp)
movl   $0xffffffff,-0xc(%rbp)
lea    -0x30(%rbp),%rdi
lea    0xd68(%rip),%rsi
lea    -0x8(%rbp),%rdx
lea    -0xc(%rbp),%rcx
lea    -0x10(%rbp),%r8
call   1060 <sscanf@plt>
cmpl   $0x12c,-0xc(%rbp)
jge    12c4 <main+0x184>
mov    -0xc(%rbp),%eax
mov    %eax,-0x587f4(%rbp)
jmp    12d4 <main+0x194>
mov    $0x12c,%eax
mov    %eax,-0x587f4(%rbp)
jmp    12d4 <main+0x194>
mov    -0x587f4(%rbp),%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x12c,-0x10(%rbp)
jge    12f8 <main+0x1b8>
mov    -0x10(%rbp),%eax
mov    %eax,-0x587f8(%rbp)
jmp    1308 <main+0x1c8>
mov    $0x12c,%eax
mov    %eax,-0x587f8(%rbp)
jmp    1308 <main+0x1c8>
mov    -0x587f8(%rbp),%eax
mov    %eax,-0x10(%rbp)
movl   $0x0,-0x587f0(%rbp)
cmpl   $0xffffffff,-0xc(%rbp)
jne    1382 <main+0x242>
movl   $0x0,-0x587e4(%rbp)
mov    -0x587e4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     137d <main+0x23d>
movslq -0x8(%rbp),%rcx
lea    -0x587e0(%rbp),%rax
imul   $0x4b4,%rcx,%rcx
add    %rcx,%rax
movslq -0x587e4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x587f0(%rbp),%eax
mov    %eax,-0x587f0(%rbp)
mov    -0x587e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x587e4(%rbp)
jmp    132f <main+0x1ef>
jmp    144a <main+0x30a>
cmpl   $0xffffffff,-0x10(%rbp)
jne    13e9 <main+0x2a9>
movl   $0x0,-0x587e4(%rbp)
mov    -0x587e4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     13e4 <main+0x2a4>
movslq -0x8(%rbp),%rcx
lea    -0x587e0(%rbp),%rax
imul   $0x4b4,%rcx,%rcx
add    %rcx,%rax
movslq -0x587e4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x587f0(%rbp),%eax
mov    %eax,-0x587f0(%rbp)
mov    -0x587e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x587e4(%rbp)
jmp    1396 <main+0x256>
jmp    1445 <main+0x305>
mov    -0xc(%rbp),%eax
mov    %eax,-0x587e4(%rbp)
mov    -0x587e4(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1440 <main+0x300>
movslq -0x8(%rbp),%rcx
lea    -0x587e0(%rbp),%rax
imul   $0x4b4,%rcx,%rcx
add    %rcx,%rax
movslq -0x587e4(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x587f0(%rbp),%eax
mov    %eax,-0x587f0(%rbp)
mov    -0x587e4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x587e4(%rbp)
jmp    13f2 <main+0x2b2>
jmp    1445 <main+0x305>
jmp    144a <main+0x30a>
mov    -0x587f0(%rbp),%esi
lea    0xbb0(%rip),%rdi
call   1030 <printf@plt>
jmp    125e <main+0x11e>
xor    %eax,%eax
add    $0x58800,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x587d8,%rsp
lea    0x30(%rsp),%rdi
mov    $0x587a4,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movl   $0x1,0x30(%rsp)
lea    0x518(%rsp),%r8
mov    $0x1,%ecx
lea    0x60(%rsp),%r14
jmp    1198 <main+0x58>
xchg   %ax,%ax
add    $0x1,%rcx
add    $0x4b4,%r8
cmp    $0x12d,%rcx
je     1288 <main+0x148>
mov    %r14,%rdx
mov    %r8,%rsi
mov    %rcx,%rdi
jmp    1215 <main+0xd5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
imul   $0x4b4,%rbp,%rbp
mov    0x4d0(%rsp,%rbp,1),%ebx
imul   $0x4b4,%rdi,%rax
add    %ebx,0x4d4(%rsp,%rax,1)
mov    0x4d4(%rsp,%rbp,1),%ebx
add    %ebx,0x4d8(%rsp,%rax,1)
mov    0x4d8(%rsp,%rbp,1),%ebx
add    %ebx,0x4dc(%rsp,%rax,1)
mov    0x4dc(%rsp,%rbp,1),%ebp
add    %ebp,0x4e0(%rsp,%rax,1)
add    $0x1,%rdi
add    $0x4b4,%rsi
add    $0x4b4,%rdx
cmp    $0x12d,%rdi
je     1180 <main+0x40>
mov    %rdi,%rbp
sub    %rcx,%rbp
xor    %ebx,%ebx
nopl   (%rax)
movdqu -0x30(%rdx,%rbx,4),%xmm0
movdqu -0x20(%rdx,%rbx,4),%xmm1
movdqu -0x30(%rsi,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rsi,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x30(%rsi,%rbx,4)
movdqu %xmm0,-0x20(%rsi,%rbx,4)
cmp    $0x120,%rbx
je     11b0 <main+0x70>
movdqu -0x10(%rdx,%rbx,4),%xmm0
movdqu (%rdx,%rbx,4),%xmm1
movdqu -0x10(%rsi,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu (%rsi,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu %xmm2,-0x10(%rsi,%rbx,4)
movdqu %xmm0,(%rsi,%rbx,4)
add    $0x10,%rbx
jmp    1220 <main+0xe0>
mov    0x2d59(%rip),%r15
mov    (%r15),%edx
lea    0x10(%rsp),%rdi
mov    $0x1f,%esi
call   1050 <fgets_unlocked@plt>
test   %rax,%rax
je     1781 <main+0x641>
lea    0xd4f(%rip),%rbx
lea    0x10(%rsp),%r13
lea    0x4(%rsp),%rbp
mov    $0x12c,%r12d
jmp    12f7 <main+0x1b7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %esi,%esi
lea    0xd2e(%rip),%rdi
call   1030 <printf@plt>
mov    (%r15),%edx
mov    %r13,%rdi
mov    $0x1f,%esi
call   1050 <fgets_unlocked@plt>
test   %rax,%rax
je     1781 <main+0x641>
movl   $0xffffffff,0x8(%rsp)
ff
movl   $0xffffffff,0xc(%rsp)
ff
mov    %r13,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
lea    0xc(%rsp),%rcx
lea    0x8(%rsp),%r8
call   1060 <sscanf@plt>
mov    0xc(%rsp),%ecx
cmp    $0x12c,%ecx
cmovge %r12d,%ecx
mov    %ecx,0xc(%rsp)
mov    0x8(%rsp),%eax
cmp    $0x12c,%eax
cmovge %r12d,%eax
mov    %eax,0x8(%rsp)
cmp    $0xffffffff,%ecx
je     1400 <main+0x2c0>
cmp    $0xffffffff,%eax
je     1420 <main+0x2e0>
xor    %esi,%esi
mov    %eax,%edi
sub    %ecx,%edi
jl     12d2 <main+0x192>
movslq 0x4(%rsp),%r8
movslq %ecx,%rcx
xor    %esi,%esi
cmp    $0x7,%edi
jb     162f <main+0x4ef>
add    $0x1,%rdi
mov    %rdi,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     15c1 <main+0x481>
movabs $0x3ffffffffffffffc,%rdx
ff ff 3f
add    $0x2,%rdx
and    %rsi,%rdx
imul   $0x12d,%r8,%rbp
add    %rcx,%rbp
lea    (%r14,%rbp,4),%rbp
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
nop
movdqu -0x30(%rbp,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rbp,%rbx,4),%xmm3
paddd  %xmm1,%xmm3
movdqu -0x10(%rbp,%rbx,4),%xmm0
paddd  %xmm2,%xmm0
movdqu 0x0(%rbp,%rbx,4),%xmm1
paddd  %xmm3,%xmm1
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdx
jne    13c0 <main+0x280>
jmp    15cb <main+0x48b>
nopw   0x0(%rax,%rax,1)
mov    0x4(%rsp),%edx
test   %edx,%edx
js     12d0 <main+0x190>
lea    0x1(%rdx),%rax
cmp    $0x7,%edx
jae    143e <main+0x2fe>
xor    %ecx,%ecx
xor    %esi,%esi
jmp    159b <main+0x45b>
xchg   %ax,%ax
test   %ecx,%ecx
js     12d0 <main+0x190>
movslq 0x4(%rsp),%rdx
lea    0x1(%rcx),%eax
cmp    $0x7,%ecx
jae    146c <main+0x32c>
xor    %ecx,%ecx
xor    %esi,%esi
jmp    175b <main+0x61b>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    149e <main+0x35e>
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
jmp    1529 <main+0x3e9>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    1660 <main+0x520>
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
jmp    16e9 <main+0x5a9>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
and    %rdi,%rsi
imul   $0x4b4,%rdx,%rbx
lea    0xa0(%rsp),%rdi
add    %rdi,%rbx
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu -0x70(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rbx,%rdi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rbx,%rdi,4),%xmm1
movdqu -0x40(%rbx,%rdi,4),%xmm3
movdqu -0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rbx,%rdi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rbx,%rdi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rbx,%rdi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    14d0 <main+0x390>
test   %rbp,%rbp
je     156c <main+0x42c>
imul   $0x12d,%rdx,%rsi
add    %rsi,%rdi
lea    0xa0(%rsp),%rsi
lea    (%rsi,%rdi,4),%rsi
add    $0xffffffffffffffa0,%rsi
shl    $0x5,%rbp
xor    %edi,%edi
xchg   %ax,%ax
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    1550 <main+0x410>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %rax,%rcx
lea    0xa70(%rip),%rbx
lea    0x4(%rsp),%rbp
je     12d2 <main+0x192>
imul   $0x4b4,%rdx,%rdx
add    %rsp,%rdx
add    $0x30,%rdx
nopl   0x0(%rax)
add    (%rdx,%rcx,4),%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    15b0 <main+0x470>
jmp    12d2 <main+0x192>
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
test   $0x1,%sil
lea    0x4(%rsp),%rbp
je     15fa <main+0x4ba>
add    %rcx,%rbx
imul   $0x4b4,%r8,%rdx
add    %rsp,%rdx
add    $0x30,%rdx
movdqu (%rdx,%rbx,4),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rdx,%rbx,4),%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %r9,%rdi
jne    1625 <main+0x4e5>
lea    0x9e0(%rip),%rbx
jmp    12d2 <main+0x192>
add    %r9,%rcx
lea    0x9d1(%rip),%rbx
imul   $0x4b4,%r8,%rdx
add    %rsp,%rdx
add    $0x30,%rdx
cltq
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    (%rdx,%rcx,4),%esi
add    $0x1,%rcx
cmp    %ecx,%eax
jne    1650 <main+0x510>
jmp    12d2 <main+0x192>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
and    %rdi,%rsi
imul   $0x4b4,%rdx,%rbx
lea    0xa0(%rsp),%rdi
add    %rdi,%rbx
pxor   %xmm0,%xmm0
xor    %edi,%edi
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu -0x70(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rbx,%rdi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rbx,%rdi,4),%xmm1
movdqu -0x40(%rbx,%rdi,4),%xmm3
movdqu -0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rbx,%rdi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rbx,%rdi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rbx,%rdi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1690 <main+0x550>
test   %rbp,%rbp
je     172c <main+0x5ec>
imul   $0x12d,%rdx,%rsi
add    %rsi,%rdi
lea    0xa0(%rsp),%rsi
lea    (%rsi,%rdi,4),%rsi
add    $0xffffffffffffffa0,%rsi
shl    $0x5,%rbp
xor    %edi,%edi
xchg   %ax,%ax
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    1710 <main+0x5d0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %rax,%rcx
lea    0x8b0(%rip),%rbx
lea    0x4(%rsp),%rbp
je     12d2 <main+0x192>
imul   $0x4b4,%rdx,%rdx
add    %rsp,%rdx
add    $0x30,%rdx
nopl   0x0(%rax)
add    (%rdx,%rcx,4),%esi
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1770 <main+0x630>
jmp    12d2 <main+0x192>
xor    %eax,%eax
add    $0x587d8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@stdin = global i32 0
@.str = [7 x i8] c"%d%d%d\00"
@.str.1 = [6 x i8] c"%lld\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [32 x i8]
%5 = alloca [301 x [301 x i32]]
%6 = bitcast i32* %1 to i8*
%7 = bitcast i32* %2 to i8*
%8 = bitcast i32* %3 to i8*
%9 = getelementptr inbounds [32 x i8], [32 x i8]* %4, i64 0, i64 0
%10 = bitcast [301 x [301 x i32]]* %5 to i8*
%11 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 0, i64 0
store i32 1, i32* %11
br label %12
12: ; preds = %84, %0
%13 = phi i64 [ 1, %0 ], [ %85, %84 ]
br label %18
14: ; preds = %84
%15 = load i32, i32* @stdin
%16 = call i64 @fgets_unlocked(i8* %9, i32 31, i32 %15)
%17 = icmp eq i64 %16, 0
br i1 %17, label %387, label %87
18: ; preds = %12, %61
%19 = phi i64 [ %13, %12 ], [ %82, %61 ]
%20 = sub nuw nsw i64 %19, %13
br label %21
21: ; preds = %42, %18
%22 = phi i64 [ 0, %18 ], [ %60, %42 ]
%23 = or i64 %22, 1
%24 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %20, i64 %22
%25 = bitcast i32* %24 to <4 x i32>*
%26 = load <4 x i32>, <4 x i32>* %25
%27 = getelementptr inbounds i32, i32* %24, i64 4
%28 = bitcast i32* %27 to <4 x i32>*
%29 = load <4 x i32>, <4 x i32>* %28
%30 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %19, i64 %23
%31 = bitcast i32* %30 to <4 x i32>*
%32 = load <4 x i32>, <4 x i32>* %31
%33 = getelementptr inbounds i32, i32* %30, i64 4
%34 = bitcast i32* %33 to <4 x i32>*
%35 = load <4 x i32>, <4 x i32>* %34
%36 = add nsw <4 x i32> %32, %26
%37 = add nsw <4 x i32> %35, %29
%38 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %36, <4 x i32>* %38
%39 = bitcast i32* %33 to <4 x i32>*
store <4 x i32> %37, <4 x i32>* %39
%40 = or i64 %22, 8
%41 = icmp eq i64 %40, 296
br i1 %41, label %61, label %42
42: ; preds = %21
%43 = or i64 %22, 9
%44 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %20, i64 %40
%45 = bitcast i32* %44 to <4 x i32>*
%46 = load <4 x i32>, <4 x i32>* %45
%47 = getelementptr inbounds i32, i32* %44, i64 4
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %19, i64 %43
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = add nsw <4 x i32> %52, %46
%57 = add nsw <4 x i32> %55, %49
%58 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> %56, <4 x i32>* %58
%59 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %57, <4 x i32>* %59
%60 = add nuw nsw i64 %22, 16
br label %21
61: ; preds = %21
%62 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %20, i64 296
%63 = load i32, i32* %62
%64 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %19, i64 297
%65 = load i32, i32* %64
%66 = add nsw i32 %65, %63
store i32 %66, i32* %64
%67 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %20, i64 297
%68 = load i32, i32* %67
%69 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %19, i64 298
%70 = load i32, i32* %69
%71 = add nsw i32 %70, %68
store i32 %71, i32* %69
%72 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %20, i64 298
%73 = load i32, i32* %72
%74 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %19, i64 299
%75 = load i32, i32* %74
%76 = add nsw i32 %75, %73
store i32 %76, i32* %74
%77 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %20, i64 299
%78 = load i32, i32* %77
%79 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %19, i64 300
%80 = load i32, i32* %79
%81 = add nsw i32 %80, %78
store i32 %81, i32* %79
%82 = add nuw nsw i64 %19, 1
%83 = icmp eq i64 %82, 301
br i1 %83, label %84, label %18
84: ; preds = %61
%85 = add nuw nsw i64 %13, 1
%86 = icmp eq i64 %85, 301
br i1 %86, label %14, label %12
87: ; preds = %14, %381
store i32 -1, i32* %3
store i32 -1, i32* %2
%88 = call i32 @sscanf(i8* %9, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0), i32* %1, i32* %2, i32* %3)
%89 = load i32, i32* %2
%90 = icmp slt i32 %89, 300
%91 = select i1 %90, i32 %89, i32 300
store i32 %91, i32* %2
%92 = load i32, i32* %3
%93 = icmp slt i32 %92, 300
%94 = select i1 %93, i32 %92, i32 300
store i32 %94, i32* %3
%95 = icmp eq i32 %91, -1
br i1 %95, label %96, label %196
96: ; preds = %87
%97 = load i32, i32* %1
%98 = icmp slt i32 %97, 0
br i1 %98, label %381, label %99
99: ; preds = %96
%100 = zext i32 %97 to i64
%101 = add nuw i32 %97, 1
%102 = zext i32 %101 to i64
%103 = icmp ult i32 %97, 7
br i1 %103, label %185, label %104
104: ; preds = %99
%105 = and i64 %102, 4294967288
%106 = add nsw i64 %105, -8
%107 = lshr exact i64 %106, 3
%108 = add nuw nsw i64 %107, 1
%109 = and i64 %108, 3
%110 = icmp ult i64 %106, 24
br i1 %110, label %156, label %111
111: ; preds = %104
%112 = and i64 %108, 4611686018427387900
br label %113
113: ; preds = %113, %111
%114 = phi i64 [ 0, %111 ], [ %153, %113 ]
%115 = phi <4 x i32> [ zeroinitializer, %111 ], [ %151, %113 ]
%116 = phi <4 x i32> [ zeroinitializer, %111 ], [ %152, %113 ]
%117 = phi i64 [ 0, %111 ], [ %154, %113 ]
%118 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %100, i64 %114
%119 = bitcast i32* %118 to <4 x i32>*
%120 = load <4 x i32>, <4 x i32>* %119
%121 = getelementptr inbounds i32, i32* %118, i64 4
%122 = bitcast i32* %121 to <4 x i32>*
%123 = load <4 x i32>, <4 x i32>* %122
%124 = add <4 x i32> %120, %115
%125 = add <4 x i32> %123, %116
%126 = or i64 %114, 8
%127 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %100, i64 %126
%128 = bitcast i32* %127 to <4 x i32>*
%129 = load <4 x i32>, <4 x i32>* %128
%130 = getelementptr inbounds i32, i32* %127, i64 4
%131 = bitcast i32* %130 to <4 x i32>*
%132 = load <4 x i32>, <4 x i32>* %131
%133 = add <4 x i32> %129, %124
%134 = add <4 x i32> %132, %125
%135 = or i64 %114, 16
%136 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %100, i64 %135
%137 = bitcast i32* %136 to <4 x i32>*
%138 = load <4 x i32>, <4 x i32>* %137
%139 = getelementptr inbounds i32, i32* %136, i64 4
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = add <4 x i32> %138, %133
%143 = add <4 x i32> %141, %134
%144 = or i64 %114, 24
%145 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %100, i64 %144
%146 = bitcast i32* %145 to <4 x i32>*
%147 = load <4 x i32>, <4 x i32>* %146
%148 = getelementptr inbounds i32, i32* %145, i64 4
%149 = bitcast i32* %148 to <4 x i32>*
%150 = load <4 x i32>, <4 x i32>* %149
%151 = add <4 x i32> %147, %142
%152 = add <4 x i32> %150, %143
%153 = add nuw i64 %114, 32
%154 = add i64 %117, 4
%155 = icmp eq i64 %154, %112
br i1 %155, label %156, label %113
156: ; preds = %113, %104
%157 = phi <4 x i32> [ undef, %104 ], [ %151, %113 ]
%158 = phi <4 x i32> [ undef, %104 ], [ %152, %113 ]
%159 = phi i64 [ 0, %104 ], [ %153, %113 ]
%160 = phi <4 x i32> [ zeroinitializer, %104 ], [ %151, %113 ]
%161 = phi <4 x i32> [ zeroinitializer, %104 ], [ %152, %113 ]
%162 = icmp eq i64 %109, 0
br i1 %162, label %179, label %163
163: ; preds = %156, %163
%164 = phi i64 [ %176, %163 ], [ %159, %156 ]
%165 = phi <4 x i32> [ %174, %163 ], [ %160, %156 ]
%166 = phi <4 x i32> [ %175, %163 ], [ %161, %156 ]
%167 = phi i64 [ %177, %163 ], [ 0, %156 ]
%168 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %100, i64 %164
%169 = bitcast i32* %168 to <4 x i32>*
%170 = load <4 x i32>, <4 x i32>* %169
%171 = getelementptr inbounds i32, i32* %168, i64 4
%172 = bitcast i32* %171 to <4 x i32>*
%173 = load <4 x i32>, <4 x i32>* %172
%174 = add <4 x i32> %170, %165
%175 = add <4 x i32> %173, %166
%176 = add nuw i64 %164, 8
%177 = add i64 %167, 1
%178 = icmp eq i64 %177, %109
br i1 %178, label %179, label %163
179: ; preds = %163, %156
%180 = phi <4 x i32> [ %157, %156 ], [ %174, %163 ]
%181 = phi <4 x i32> [ %158, %156 ], [ %175, %163 ]
%182 = add <4 x i32> %181, %180
%183 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %182)
%184 = icmp eq i64 %105, %102
br i1 %184, label %381, label %185
185: ; preds = %99, %179
%186 = phi i64 [ 0, %99 ], [ %105, %179 ]
%187 = phi i32 [ 0, %99 ], [ %183, %179 ]
br label %188
188: ; preds = %185, %188
%189 = phi i64 [ %194, %188 ], [ %186, %185 ]
%190 = phi i32 [ %193, %188 ], [ %187, %185 ]
%191 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %100, i64 %189
%192 = load i32, i32* %191
%193 = add nsw i32 %192, %190
%194 = add nuw nsw i64 %189, 1
%195 = icmp eq i64 %194, %102
br i1 %195, label %381, label %188
196: ; preds = %87
%197 = icmp eq i32 %94, -1
br i1 %197, label %272, label %198
198: ; preds = %196
%199 = icmp slt i32 %94, %91
br i1 %199, label %381, label %200
200: ; preds = %198
%201 = load i32, i32* %1
%202 = sext i32 %201 to i64
%203 = sext i32 %91 to i64
%204 = add nsw i32 %94, 1
%205 = sub i32 %94, %91
%206 = zext i32 %205 to i64
%207 = add nuw nsw i64 %206, 1
%208 = icmp ult i32 %205, 7
br i1 %208, label %269, label %209
209: ; preds = %200
%210 = and i64 %207, 8589934584
%211 = add nsw i64 %210, %203
%212 = add nsw i64 %210, -8
%213 = lshr exact i64 %212, 3
%214 = add nuw nsw i64 %213, 1
%215 = and i64 %214, 1
%216 = icmp eq i64 %212, 0
br i1 %216, label %246, label %217
217: ; preds = %209
%218 = and i64 %214, 4611686018427387902
br label %219
219: ; preds = %219, %217
%220 = phi i64 [ 0, %217 ], [ %243, %219 ]
%221 = phi <4 x i32> [ zeroinitializer, %217 ], [ %241, %219 ]
%222 = phi <4 x i32> [ zeroinitializer, %217 ], [ %242, %219 ]
%223 = phi i64 [ 0, %217 ], [ %244, %219 ]
%224 = add i64 %220, %203
%225 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %202, i64 %224
%226 = bitcast i32* %225 to <4 x i32>*
%227 = load <4 x i32>, <4 x i32>* %226
%228 = getelementptr inbounds i32, i32* %225, i64 4
%229 = bitcast i32* %228 to <4 x i32>*
%230 = load <4 x i32>, <4 x i32>* %229
%231 = add <4 x i32> %227, %221
%232 = add <4 x i32> %230, %222
%233 = or i64 %220, 8
%234 = add i64 %233, %203
%235 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %202, i64 %234
%236 = bitcast i32* %235 to <4 x i32>*
%237 = load <4 x i32>, <4 x i32>* %236
%238 = getelementptr inbounds i32, i32* %235, i64 4
%239 = bitcast i32* %238 to <4 x i32>*
%240 = load <4 x i32>, <4 x i32>* %239
%241 = add <4 x i32> %237, %231
%242 = add <4 x i32> %240, %232
%243 = add nuw i64 %220, 16
%244 = add i64 %223, 2
%245 = icmp eq i64 %244, %218
br i1 %245, label %246, label %219
246: ; preds = %219, %209
%247 = phi <4 x i32> [ undef, %209 ], [ %241, %219 ]
%248 = phi <4 x i32> [ undef, %209 ], [ %242, %219 ]
%249 = phi i64 [ 0, %209 ], [ %243, %219 ]
%250 = phi <4 x i32> [ zeroinitializer, %209 ], [ %241, %219 ]
%251 = phi <4 x i32> [ zeroinitializer, %209 ], [ %242, %219 ]
%252 = icmp eq i64 %215, 0
br i1 %252, label %263, label %253
253: ; preds = %246
%254 = add i64 %249, %203
%255 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %202, i64 %254
%256 = bitcast i32* %255 to <4 x i32>*
%257 = load <4 x i32>, <4 x i32>* %256
%258 = getelementptr inbounds i32, i32* %255, i64 4
%259 = bitcast i32* %258 to <4 x i32>*
%260 = load <4 x i32>, <4 x i32>* %259
%261 = add <4 x i32> %257, %250
%262 = add <4 x i32> %260, %251
br label %263
263: ; preds = %246, %253
%264 = phi <4 x i32> [ %247, %246 ], [ %261, %253 ]
%265 = phi <4 x i32> [ %248, %246 ], [ %262, %253 ]
%266 = add <4 x i32> %265, %264
%267 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %266)
%268 = icmp eq i64 %207, %210
br i1 %268, label %381, label %269
269: ; preds = %200, %263
%270 = phi i64 [ %203, %200 ], [ %211, %263 ]
%271 = phi i32 [ 0, %200 ], [ %267, %263 ]
br label %372
272: ; preds = %196
%273 = icmp slt i32 %91, 0
br i1 %273, label %381, label %274
274: ; preds = %272
%275 = load i32, i32* %1
%276 = sext i32 %275 to i64
%277 = add nuw nsw i32 %91, 1
%278 = zext i32 %277 to i64
%279 = icmp ult i32 %91, 7
br i1 %279, label %361, label %280
280: ; preds = %274
%281 = and i64 %278, 4294967288
%282 = add nsw i64 %281, -8
%283 = lshr exact i64 %282, 3
%284 = add nuw nsw i64 %283, 1
%285 = and i64 %284, 3
%286 = icmp ult i64 %282, 24
br i1 %286, label %332, label %287
287: ; preds = %280
%288 = and i64 %284, 4611686018427387900
br label %289
289: ; preds = %289, %287
%290 = phi i64 [ 0, %287 ], [ %329, %289 ]
%291 = phi <4 x i32> [ zeroinitializer, %287 ], [ %327, %289 ]
%292 = phi <4 x i32> [ zeroinitializer, %287 ], [ %328, %289 ]
%293 = phi i64 [ 0, %287 ], [ %330, %289 ]
%294 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %276, i64 %290
%295 = bitcast i32* %294 to <4 x i32>*
%296 = load <4 x i32>, <4 x i32>* %295
%297 = getelementptr inbounds i32, i32* %294, i64 4
%298 = bitcast i32* %297 to <4 x i32>*
%299 = load <4 x i32>, <4 x i32>* %298
%300 = add <4 x i32> %296, %291
%301 = add <4 x i32> %299, %292
%302 = or i64 %290, 8
%303 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %276, i64 %302
%304 = bitcast i32* %303 to <4 x i32>*
%305 = load <4 x i32>, <4 x i32>* %304
%306 = getelementptr inbounds i32, i32* %303, i64 4
%307 = bitcast i32* %306 to <4 x i32>*
%308 = load <4 x i32>, <4 x i32>* %307
%309 = add <4 x i32> %305, %300
%310 = add <4 x i32> %308, %301
%311 = or i64 %290, 16
%312 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %276, i64 %311
%313 = bitcast i32* %312 to <4 x i32>*
%314 = load <4 x i32>, <4 x i32>* %313
%315 = getelementptr inbounds i32, i32* %312, i64 4
%316 = bitcast i32* %315 to <4 x i32>*
%317 = load <4 x i32>, <4 x i32>* %316
%318 = add <4 x i32> %314, %309
%319 = add <4 x i32> %317, %310
%320 = or i64 %290, 24
%321 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %276, i64 %320
%322 = bitcast i32* %321 to <4 x i32>*
%323 = load <4 x i32>, <4 x i32>* %322
%324 = getelementptr inbounds i32, i32* %321, i64 4
%325 = bitcast i32* %324 to <4 x i32>*
%326 = load <4 x i32>, <4 x i32>* %325
%327 = add <4 x i32> %323, %318
%328 = add <4 x i32> %326, %319
%329 = add nuw i64 %290, 32
%330 = add i64 %293, 4
%331 = icmp eq i64 %330, %288
br i1 %331, label %332, label %289
332: ; preds = %289, %280
%333 = phi <4 x i32> [ undef, %280 ], [ %327, %289 ]
%334 = phi <4 x i32> [ undef, %280 ], [ %328, %289 ]
%335 = phi i64 [ 0, %280 ], [ %329, %289 ]
%336 = phi <4 x i32> [ zeroinitializer, %280 ], [ %327, %289 ]
%337 = phi <4 x i32> [ zeroinitializer, %280 ], [ %328, %289 ]
%338 = icmp eq i64 %285, 0
br i1 %338, label %355, label %339
339: ; preds = %332, %339
%340 = phi i64 [ %352, %339 ], [ %335, %332 ]
%341 = phi <4 x i32> [ %350, %339 ], [ %336, %332 ]
%342 = phi <4 x i32> [ %351, %339 ], [ %337, %332 ]
%343 = phi i64 [ %353, %339 ], [ 0, %332 ]
%344 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %276, i64 %340
%345 = bitcast i32* %344 to <4 x i32>*
%346 = load <4 x i32>, <4 x i32>* %345
%347 = getelementptr inbounds i32, i32* %344, i64 4
%348 = bitcast i32* %347 to <4 x i32>*
%349 = load <4 x i32>, <4 x i32>* %348
%350 = add <4 x i32> %346, %341
%351 = add <4 x i32> %349, %342
%352 = add nuw i64 %340, 8
%353 = add i64 %343, 1
%354 = icmp eq i64 %353, %285
br i1 %354, label %355, label %339
355: ; preds = %339, %332
%356 = phi <4 x i32> [ %333, %332 ], [ %350, %339 ]
%357 = phi <4 x i32> [ %334, %332 ], [ %351, %339 ]
%358 = add <4 x i32> %357, %356
%359 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %358)
%360 = icmp eq i64 %281, %278
br i1 %360, label %381, label %361
361: ; preds = %274, %355
%362 = phi i64 [ 0, %274 ], [ %281, %355 ]
%363 = phi i32 [ 0, %274 ], [ %359, %355 ]
br label %364
364: ; preds = %361, %364
%365 = phi i64 [ %370, %364 ], [ %362, %361 ]
%366 = phi i32 [ %369, %364 ], [ %363, %361 ]
%367 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %276, i64 %365
%368 = load i32, i32* %367
%369 = add nsw i32 %368, %366
%370 = add nuw nsw i64 %365, 1
%371 = icmp eq i64 %370, %278
br i1 %371, label %381, label %364
372: ; preds = %269, %372
%373 = phi i64 [ %378, %372 ], [ %270, %269 ]
%374 = phi i32 [ %377, %372 ], [ %271, %269 ]
%375 = getelementptr inbounds [301 x [301 x i32]], [301 x [301 x i32]]* %5, i64 0, i64 %202, i64 %373
%376 = load i32, i32* %375
%377 = add nsw i32 %376, %374
%378 = add nsw i64 %373, 1
%379 = trunc i64 %378 to i32
%380 = icmp eq i32 %204, %379
br i1 %380, label %381, label %372
381: ; preds = %372, %364, %188, %263, %355, %179, %198, %272, %96
%382 = phi i32 [ 0, %96 ], [ 0, %272 ], [ 0, %198 ], [ %183, %179 ], [ %359, %355 ], [ %267, %263 ], [ %193, %188 ], [ %369, %364 ], [ %377, %372 ]
%383 = call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i32 %382)
%384 = load i32, i32* @stdin
%385 = call i64 @fgets_unlocked(i8* %9, i32 31, i32 %384)
%386 = icmp eq i64 %385, 0
br i1 %386, label %387, label %87
387: ; preds = %381, %14
ret i32 0
}