#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 */

/* Variables and functions */
int /*<<< orphan*/ scanf(char *, int *);
int magic_square(int number_square) {
  int i, j, magic_sum, number[999][999];
  int sum_rows[999], sum_colums[999], sum_diagonal_1, sum_diagonal_2;
  number[i][j] == 0;
  sum_rows[i] == 0;
  sum_colums[j] == 0;
  sum_diagonal_1 == 0;
  sum_diagonal_2 == 0;
  magic_sum = (number_square * (number_square * number_square + 1)) / 2;
  for (i = 0; i < number_square; ++i) {
    for (j = 0; j < number_square; ++j) {
      scanf("%d", &number[i][j]);
    }
  }
  for (i = 0; i < number_square; ++i) {
    for (j = 0; j < number_square; ++j) {
      sum_rows[i] += number[i][j];
    }
    if (sum_rows[i] != magic_sum) {
      return 0;
    }
  }
  for (j = 0; j < number_square; ++j) {
    for (i = 0; i < number_square; ++i) {
      sum_colums[j] += number[j][i];
    }
    if (sum_colums[j] != magic_sum) {
      return 0;
    }
  }
  for (i = 0; i < number_square; ++i) {
    for (j = 0; j < number_square; ++j) {
      if (j == i) {
        sum_diagonal_1 += number[i][j];
      }
    }
  }
  if (sum_diagonal_1 != magic_sum) {
    return 0;
  }
  for (i = 0; i < number_square; ++i) {
    for (j = 0; j < number_square; ++j) {
      if (i == j) {
        sum_diagonal_2 += number[j][i];
      }
    }
  }
  if (sum_diagonal_2 != magic_sum) {
    return 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<magic_square>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3d0930,%rsp
mov    %edi,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11ac <magic_square+0x9c>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1199 <magic_square+0x89>
movslq -0xc(%rbp),%rax
lea    -0x3ce9e0(%rbp),%rsi
imul   $0xf9c,%rax,%rax
add    %rax,%rsi
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe7a(%rip),%rdi
call   1030 <scanf@plt>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1153 <magic_square+0x43>
jmp    119e <magic_square+0x8e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1140 <magic_square+0x30>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1241 <magic_square+0x131>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    120e <magic_square+0xfe>
movslq -0xc(%rbp),%rcx
lea    -0x3ce9e0(%rbp),%rax
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0xc(%rbp),%rax
add    -0x3cf980(%rbp,%rax,4),%ecx
mov    %ecx,-0x3cf980(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11c6 <magic_square+0xb6>
movslq -0xc(%rbp),%rax
mov    -0x3cf980(%rbp,%rax,4),%eax
cmp    -0x14(%rbp),%eax
je     122e <magic_square+0x11e>
movl   $0x0,-0x4(%rbp)
jmp    1413 <magic_square+0x303>
jmp    1233 <magic_square+0x123>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11b3 <magic_square+0xa3>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12d6 <magic_square+0x1c6>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12a3 <magic_square+0x193>
movslq -0x10(%rbp),%rcx
lea    -0x3ce9e0(%rbp),%rax
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
movslq -0x10(%rbp),%rax
add    -0x3d0920(%rbp,%rax,4),%ecx
mov    %ecx,-0x3d0920(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    125b <magic_square+0x14b>
movslq -0x10(%rbp),%rax
mov    -0x3d0920(%rbp,%rax,4),%eax
cmp    -0x14(%rbp),%eax
je     12c3 <magic_square+0x1b3>
movl   $0x0,-0x4(%rbp)
jmp    1413 <magic_square+0x303>
jmp    12c8 <magic_square+0x1b8>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1248 <magic_square+0x138>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1356 <magic_square+0x246>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1343 <magic_square+0x233>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1330 <magic_square+0x220>
movslq -0xc(%rbp),%rcx
lea    -0x3ce9e0(%rbp),%rax
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x3d0924(%rbp),%eax
mov    %eax,-0x3d0924(%rbp)
jmp    1335 <magic_square+0x225>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    12f0 <magic_square+0x1e0>
jmp    1348 <magic_square+0x238>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12dd <magic_square+0x1cd>
mov    -0x3d0924(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     1371 <magic_square+0x261>
movl   $0x0,-0x4(%rbp)
jmp    1413 <magic_square+0x303>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13f1 <magic_square+0x2e1>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13de <magic_square+0x2ce>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    13cb <magic_square+0x2bb>
movslq -0x10(%rbp),%rcx
lea    -0x3ce9e0(%rbp),%rax
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x3d0928(%rbp),%eax
mov    %eax,-0x3d0928(%rbp)
jmp    13d0 <magic_square+0x2c0>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    138b <magic_square+0x27b>
jmp    13e3 <magic_square+0x2d3>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1378 <magic_square+0x268>
mov    -0x3d0928(%rbp),%eax
cmp    -0x14(%rbp),%eax
je     140c <magic_square+0x2fc>
movl   $0x0,-0x4(%rbp)
jmp    1413 <magic_square+0x303>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x3d0930,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<magic_square>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x3d0918,%rsp
mov    %edi,%eax
imul   %edi,%eax
add    $0x1,%eax
imul   %edi,%eax
mov    %eax,%r12d
shr    $0x1f,%r12d
add    %eax,%r12d
sar    %r12d
test   %edi,%edi
jle    15b7 <magic_square+0x4a7>
mov    %r12d,0xc(%rsp)
mov    %edi,0x8(%rsp)
mov    %edi,%r14d
lea    0x1f50(%rsp),%r13
xor    %r15d,%r15d
lea    0xea1(%rip),%rbx
nop
mov    %r14,%r12
mov    %r13,%rbp
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1030 <scanf@plt>
add    $0x4,%rbp
add    $0xffffffffffffffff,%r12
jne    1170 <magic_square+0x60>
add    $0x1,%r15
add    $0xf9c,%r13
cmp    %r14,%r15
jne    1160 <magic_square+0x50>
mov    0x8(%rsp),%r15d
test   %r15d,%r15d
jle    158a <magic_square+0x47a>
movabs $0x3ffffffffffffffc,%r8
ff ff 3f
mov    %r14d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r13d
and    $0x3,%r13d
mov    %r10,%r11
and    $0xfffffffffffffffc,%r11
lea    0x1fc0(%rsp),%rbx
mov    %r13,%rdi
shl    $0x5,%rdi
lea    0x1f50(%rsp),%rax
xor    %ebp,%ebp
mov    0xc(%rsp),%r12d
xchg   %ax,%ax
mov    0xfb0(%rsp,%rbp,4),%ecx
cmp    $0x8,%r15d
jae    1210 <magic_square+0x100>
xor    %edx,%edx
jmp    12f0 <magic_square+0x1e0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   %ecx,%xmm0
pxor   %xmm1,%xmm1
cmp    $0x18,%r9
jae    1230 <magic_square+0x120>
xor    %edx,%edx
jmp    1299 <magic_square+0x189>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r11,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x70(%rbx,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rbx,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rbx,%rdx,4),%xmm1
movdqu -0x40(%rbx,%rdx,4),%xmm3
movdqu -0x30(%rbx,%rdx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rbx,%rdx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rbx,%rdx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rbx,%rdx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1240 <magic_square+0x130>
test   %r13,%r13
je     12cc <magic_square+0x1bc>
lea    (%rax,%rdx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rcx,%rdx,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rcx,%rdx,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    12b0 <magic_square+0x1a0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
mov    %rsi,%rdx
cmp    %r14,%rsi
je     12fc <magic_square+0x1ec>
xchg   %ax,%ax
add    (%rax,%rdx,4),%ecx
add    $0x1,%rdx
cmp    %rdx,%r14
jne    12f0 <magic_square+0x1e0>
mov    %ecx,0xfb0(%rsp,%rbp,4)
cmp    %r12d,%ecx
jne    1586 <magic_square+0x476>
add    $0x1,%rbp
add    $0xf9c,%rbx
add    $0xf9c,%rax
cmp    %r14,%rbp
jne    11f0 <magic_square+0xe0>
test   %r15d,%r15d
jle    15b7 <magic_square+0x4a7>
mov    %r14d,%r15d
and    $0xfffffff8,%r15d
mov    %r10d,%r11d
and    $0x3,%r11d
and    %r10,%r8
lea    0x1fc0(%rsp),%rcx
mov    %r11,%rdx
shl    $0x5,%rdx
lea    0x1f50(%rsp),%rax
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    0x10(%rsp,%rbp,4),%edi
cmpl   $0x8,0x8(%rsp)
jae    1380 <magic_square+0x270>
xor    %esi,%esi
jmp    1460 <magic_square+0x350>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   %edi,%xmm0
pxor   %xmm1,%xmm1
cmp    $0x18,%r9
jae    13a0 <magic_square+0x290>
xor    %ebx,%ebx
jmp    1409 <magic_square+0x2f9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x70(%rcx,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rcx,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rcx,%rbx,4),%xmm1
movdqu -0x40(%rcx,%rbx,4),%xmm3
movdqu -0x30(%rcx,%rbx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rcx,%rbx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rcx,%rbx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rcx,%rbx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    13b0 <magic_square+0x2a0>
test   %r11,%r11
je     143c <magic_square+0x32c>
lea    (%rax,%rbx,4),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1420 <magic_square+0x310>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
mov    %r15,%rsi
cmp    %r14,%r15
je     146c <magic_square+0x35c>
xchg   %ax,%ax
add    (%rax,%rsi,4),%edi
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1460 <magic_square+0x350>
mov    %edi,0x10(%rsp,%rbp,4)
cmp    %r12d,%edi
jne    1586 <magic_square+0x476>
add    $0x1,%rbp
add    $0xf9c,%rcx
add    $0xf9c,%rax
cmp    %r14,%rbp
jne    1360 <magic_square+0x250>
mov    0x8(%rsp),%r11d
test   %r11d,%r11d
jle    15b7 <magic_square+0x4a7>
lea    -0x1(%r14),%r8
mov    %r14d,%r9d
and    $0x3,%r9d
mov    %r14d,%edx
and    $0xfffffffc,%edx
mov    %r9,%rsi
neg    %rsi
xor    %r10d,%r10d
xor    %ebx,%ebx
jmp    14d1 <magic_square+0x3c1>
nop
add    $0x1,%rbx
add    $0xffffffffffffffff,%r10
cmp    %r14,%rbx
je     1591 <magic_square+0x481>
imul   $0xf9c,%rbx,%rax
add    %rsp,%rax
add    $0x1f50,%rax
lea    (%rax,%rbx,4),%rcx
cmp    $0x3,%r8
jae    1500 <magic_square+0x3f0>
xor    %edi,%edi
test   %r9,%r9
jne    155d <magic_square+0x44d>
jmp    14c0 <magic_square+0x3b0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %eax,%eax
jmp    1519 <magic_square+0x409>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rdx,%rax
je     1550 <magic_square+0x440>
mov    %rax,%rdi
cmp    %rax,%rbx
jne    1523 <magic_square+0x413>
add    (%rcx),%ebp
lea    0x1(%rdi),%rax
cmp    %rbx,%rax
jne    152e <magic_square+0x41e>
add    (%rcx),%ebp
add    $0x1,%rax
cmp    %rbx,%rax
jne    1539 <magic_square+0x429>
add    (%rcx),%ebp
add    $0x1,%rax
cmp    %rbx,%rax
jne    1510 <magic_square+0x400>
add    (%rcx),%ebp
jmp    1510 <magic_square+0x400>
cs nopw 0x0(%rax,%rax,1)
add    $0x4,%rdi
test   %r9,%r9
je     14c0 <magic_square+0x3b0>
add    %r10,%rdi
xor    %eax,%eax
jmp    157d <magic_square+0x46d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffffffffffff,%rax
cmp    %rax,%rsi
je     14c0 <magic_square+0x3b0>
cmp    %rax,%rdi
jne    1570 <magic_square+0x460>
add    (%rcx),%ebp
jmp    1570 <magic_square+0x460>
xor    %eax,%eax
jmp    15bf <magic_square+0x4af>
mov    0xc(%rsp),%r12d
jmp    15b7 <magic_square+0x4a7>
xor    %eax,%eax
cmp    %r12d,%ebp
jne    15bf <magic_square+0x4af>
test   %r11d,%r11d
jle    15b7 <magic_square+0x4a7>
mov    %r14d,%r9d
and    $0x3,%r9d
mov    %r14d,%esi
and    $0xfffffffc,%esi
mov    %r9,%rdi
neg    %rdi
xor    %r10d,%r10d
xor    %ebx,%ebx
jmp    15ed <magic_square+0x4dd>
xor    %eax,%eax
cmp    %r12d,%edx
sete   %al
add    $0x3d0918,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0xffffffffffffffff,%r10
cmp    %r14,%rbx
je     15b7 <magic_square+0x4a7>
imul   $0xf9c,%rbx,%rax
add    %rsp,%rax
add    $0x1f50,%rax
lea    (%rax,%rbx,4),%rcx
cmp    $0x3,%r8
jae    1610 <magic_square+0x500>
xor    %ebp,%ebp
test   %r9,%r9
jne    165f <magic_square+0x54f>
jmp    15e0 <magic_square+0x4d0>
xor    %eax,%eax
jmp    1629 <magic_square+0x519>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
cmp    %rsi,%rax
je     1656 <magic_square+0x546>
mov    %rax,%rbp
cmp    %rax,%rbx
jne    1633 <magic_square+0x523>
add    (%rcx),%edx
lea    0x1(%rbp),%rax
cmp    %rax,%rbx
jne    163e <magic_square+0x52e>
add    (%rcx),%edx
add    $0x1,%rax
cmp    %rax,%rbx
jne    1649 <magic_square+0x539>
add    (%rcx),%edx
add    $0x1,%rax
cmp    %rax,%rbx
jne    1620 <magic_square+0x510>
add    (%rcx),%edx
jmp    1620 <magic_square+0x510>
add    $0x4,%rbp
test   %r9,%r9
je     15e0 <magic_square+0x4d0>
add    %r10,%rbp
xor    %eax,%eax
jmp    167d <magic_square+0x56d>
cs nopw 0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rax
cmp    %rax,%rdi
je     15e0 <magic_square+0x4d0>
cmp    %rax,%rbp
jne    1670 <magic_square+0x560>
add    (%rcx),%edx
jmp    1670 <magic_square+0x560>

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
define i32 @magic_square(i32 %0) {
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca [999 x [999 x i32]]
%8 = alloca [999 x i32]
%9 = alloca [999 x i32]
%10 = alloca i32
%11 = alloca i32
store i32 %0, i32* %3
%12 = load i32, i32* %4
%13 = sext i32 %12 to i64
%14 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %7, i64 0, i64 %13
%15 = load i32, i32* %5
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds [999 x i32], [999 x i32]* %14, i64 0, i64 %16
%18 = load i32, i32* %17
%19 = icmp eq i32 %18, 0
%20 = zext i1 %19 to i32
%21 = load i32, i32* %4
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds [999 x i32], [999 x i32]* %8, i64 0, i64 %22
%24 = load i32, i32* %23
%25 = icmp eq i32 %24, 0
%26 = zext i1 %25 to i32
%27 = load i32, i32* %5
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [999 x i32], [999 x i32]* %9, i64 0, i64 %28
%30 = load i32, i32* %29
%31 = icmp eq i32 %30, 0
%32 = zext i1 %31 to i32
%33 = load i32, i32* %10
%34 = icmp eq i32 %33, 0
%35 = zext i1 %34 to i32
%36 = load i32, i32* %11
%37 = icmp eq i32 %36, 0
%38 = zext i1 %37 to i32
%39 = load i32, i32* %3
%40 = load i32, i32* %3
%41 = load i32, i32* %3
%42 = mul nsw i32 %40, %41
%43 = add nsw i32 %42, 1
%44 = mul nsw i32 %39, %43
%45 = sdiv i32 %44, 2
store i32 %45, i32* %6
store i32 0, i32* %4
br label %46
46: ; preds = %67, %1
%47 = load i32, i32* %4
%48 = load i32, i32* %3
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %70
50: ; preds = %46
store i32 0, i32* %5
br label %51
51: ; preds = %63, %50
%52 = load i32, i32* %5
%53 = load i32, i32* %3
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %66
55: ; preds = %51
%56 = load i32, i32* %4
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %7, i64 0, i64 %57
%59 = load i32, i32* %5
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [999 x i32], [999 x i32]* %58, i64 0, i64 %60
%62 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %61)
br label %63
63: ; preds = %55
%64 = load i32, i32* %5
%65 = add nsw i32 %64, 1
store i32 %65, i32* %5
br label %51
66: ; preds = %51
br label %67
67: ; preds = %66
%68 = load i32, i32* %4
%69 = add nsw i32 %68, 1
store i32 %69, i32* %4
br label %46
70: ; preds = %46
store i32 0, i32* %4
br label %71
71: ; preds = %105, %70
%72 = load i32, i32* %4
%73 = load i32, i32* %3
%74 = icmp slt i32 %72, %73
br i1 %74, label %75, label %108
75: ; preds = %71
store i32 0, i32* %5
br label %76
76: ; preds = %93, %75
%77 = load i32, i32* %5
%78 = load i32, i32* %3
%79 = icmp slt i32 %77, %78
br i1 %79, label %80, label %96
80: ; preds = %76
%81 = load i32, i32* %4
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %7, i64 0, i64 %82
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds [999 x i32], [999 x i32]* %83, i64 0, i64 %85
%87 = load i32, i32* %86
%88 = load i32, i32* %4
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [999 x i32], [999 x i32]* %8, i64 0, i64 %89
%91 = load i32, i32* %90
%92 = add nsw i32 %91, %87
store i32 %92, i32* %90
br label %93
93: ; preds = %80
%94 = load i32, i32* %5
%95 = add nsw i32 %94, 1
store i32 %95, i32* %5
br label %76
96: ; preds = %76
%97 = load i32, i32* %4
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds [999 x i32], [999 x i32]* %8, i64 0, i64 %98
%100 = load i32, i32* %99
%101 = load i32, i32* %6
%102 = icmp ne i32 %100, %101
br i1 %102, label %103, label %104
103: ; preds = %96
store i32 0, i32* %2
br label %221
104: ; preds = %96
br label %105
105: ; preds = %104
%106 = load i32, i32* %4
%107 = add nsw i32 %106, 1
store i32 %107, i32* %4
br label %71
108: ; preds = %71
store i32 0, i32* %5
br label %109
109: ; preds = %143, %108
%110 = load i32, i32* %5
%111 = load i32, i32* %3
%112 = icmp slt i32 %110, %111
br i1 %112, label %113, label %146
113: ; preds = %109
store i32 0, i32* %4
br label %114
114: ; preds = %131, %113
%115 = load i32, i32* %4
%116 = load i32, i32* %3
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %134
118: ; preds = %114
%119 = load i32, i32* %5
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %7, i64 0, i64 %120
%122 = load i32, i32* %4
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [999 x i32], [999 x i32]* %121, i64 0, i64 %123
%125 = load i32, i32* %124
%126 = load i32, i32* %5
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [999 x i32], [999 x i32]* %9, i64 0, i64 %127
%129 = load i32, i32* %128
%130 = add nsw i32 %129, %125
store i32 %130, i32* %128
br label %131
131: ; preds = %118
%132 = load i32, i32* %4
%133 = add nsw i32 %132, 1
store i32 %133, i32* %4
br label %114
134: ; preds = %114
%135 = load i32, i32* %5
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds [999 x i32], [999 x i32]* %9, i64 0, i64 %136
%138 = load i32, i32* %137
%139 = load i32, i32* %6
%140 = icmp ne i32 %138, %139
br i1 %140, label %141, label %142
141: ; preds = %134
store i32 0, i32* %2
br label %221
142: ; preds = %134
br label %143
143: ; preds = %142
%144 = load i32, i32* %5
%145 = add nsw i32 %144, 1
store i32 %145, i32* %5
br label %109
146: ; preds = %109
store i32 0, i32* %4
br label %147
147: ; preds = %175, %146
%148 = load i32, i32* %4
%149 = load i32, i32* %3
%150 = icmp slt i32 %148, %149
br i1 %150, label %151, label %178
151: ; preds = %147
store i32 0, i32* %5
br label %152
152: ; preds = %171, %151
%153 = load i32, i32* %5
%154 = load i32, i32* %3
%155 = icmp slt i32 %153, %154
br i1 %155, label %156, label %174
156: ; preds = %152
%157 = load i32, i32* %5
%158 = load i32, i32* %4
%159 = icmp eq i32 %157, %158
br i1 %159, label %160, label %170
160: ; preds = %156
%161 = load i32, i32* %4
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %7, i64 0, i64 %162
%164 = load i32, i32* %5
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds [999 x i32], [999 x i32]* %163, i64 0, i64 %165
%167 = load i32, i32* %166
%168 = load i32, i32* %10
%169 = add nsw i32 %168, %167
store i32 %169, i32* %10
br label %170
170: ; preds = %160, %156
br label %171
171: ; preds = %170
%172 = load i32, i32* %5
%173 = add nsw i32 %172, 1
store i32 %173, i32* %5
br label %152
174: ; preds = %152
br label %175
175: ; preds = %174
%176 = load i32, i32* %4
%177 = add nsw i32 %176, 1
store i32 %177, i32* %4
br label %147
178: ; preds = %147
%179 = load i32, i32* %10
%180 = load i32, i32* %6
%181 = icmp ne i32 %179, %180
br i1 %181, label %182, label %183
182: ; preds = %178
store i32 0, i32* %2
br label %221
183: ; preds = %178
store i32 0, i32* %4
br label %184
184: ; preds = %212, %183
%185 = load i32, i32* %4
%186 = load i32, i32* %3
%187 = icmp slt i32 %185, %186
br i1 %187, label %188, label %215
188: ; preds = %184
store i32 0, i32* %5
br label %189
189: ; preds = %208, %188
%190 = load i32, i32* %5
%191 = load i32, i32* %3
%192 = icmp slt i32 %190, %191
br i1 %192, label %193, label %211
193: ; preds = %189
%194 = load i32, i32* %4
%195 = load i32, i32* %5
%196 = icmp eq i32 %194, %195
br i1 %196, label %197, label %207
197: ; preds = %193
%198 = load i32, i32* %5
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %7, i64 0, i64 %199
%201 = load i32, i32* %4
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [999 x i32], [999 x i32]* %200, i64 0, i64 %202
%204 = load i32, i32* %203
%205 = load i32, i32* %11
%206 = add nsw i32 %205, %204
store i32 %206, i32* %11
br label %207
207: ; preds = %197, %193
br label %208
208: ; preds = %207
%209 = load i32, i32* %5
%210 = add nsw i32 %209, 1
store i32 %210, i32* %5
br label %189
211: ; preds = %189
br label %212
212: ; preds = %211
%213 = load i32, i32* %4
%214 = add nsw i32 %213, 1
store i32 %214, i32* %4
br label %184
215: ; preds = %184
%216 = load i32, i32* %11
%217 = load i32, i32* %6
%218 = icmp ne i32 %216, %217
br i1 %218, label %219, label %220
219: ; preds = %215
store i32 0, i32* %2
br label %221
220: ; preds = %215
store i32 1, i32* %2
br label %221
221: ; preds = %220, %219, %182, %141, %103
%222 = load i32, i32* %2
ret i32 %222
}

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