int magiic(int square[999][999], int size) {
  int i, count, sum = 0, sum2 = 0;
  for (i = 0; i < size; i++) {
    sum += square[0][i];
  }
  for (i = 1; i < size; i++) {
    for (count = 0; count < size; count++)
      sum2 += square[i][count];
    if (sum2 != sum)
      return 0;
    sum2 = 0;
  }
  for (i = 0; i < size; i++) {
    for (count = 0; count < size; count++)
      sum2 += square[count][i];
    if (sum2 != sum)
      return 0;
    sum2 = 0;
  }
  for (i = 0; i < size; i++) {
    sum2 += square[i][i];
  }
  if (sum2 != sum)
    return 0;
  sum2 = 0;
  for (i = size; i > 0; i--) {
    for (count = 0; count < size; count++)
      sum2 += square[i - 1][count];
    if (sum2 != sum)
      return 0;
    sum2 = 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<magiic>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    114b <magiic+0x4b>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1120 <magiic+0x20>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11cb <magiic+0xcb>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    119e <magiic+0x9e>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1165 <magiic+0x65>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     11b6 <magiic+0xb6>
movl   $0x0,-0x4(%rbp)
jmp    1333 <magiic+0x233>
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1152 <magiic+0x52>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    124b <magiic+0x14b>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    121e <magiic+0x11e>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e5 <magiic+0xe5>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     1236 <magiic+0x136>
movl   $0x0,-0x4(%rbp)
jmp    1333 <magiic+0x233>
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d2 <magiic+0xd2>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    128b <magiic+0x18b>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1252 <magiic+0x152>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     12a3 <magiic+0x1a3>
movl   $0x0,-0x4(%rbp)
jmp    1333 <magiic+0x233>
movl   $0x0,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    132c <magiic+0x22c>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12ff <magiic+0x1ff>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12c1 <magiic+0x1c1>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     1317 <magiic+0x217>
movl   $0x0,-0x4(%rbp)
jmp    1333 <magiic+0x233>
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    12b0 <magiic+0x1b0>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<magiic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %esi,%esi
jle    1745 <magiic+0x645>
mov    %esi,%r8d
cmp    $0x8,%esi
jae    1124 <magiic+0x24>
xor    %eax,%eax
xor    %r12d,%r12d
jmp    1210 <magiic+0x110>
mov    %r8d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ebx
and    $0x3,%ebx
cmp    $0x18,%rcx
jae    1150 <magiic+0x50>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    11b9 <magiic+0xb9>
and    $0xfffffffffffffffc,%rdx
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
xchg   %ax,%ax
movdqu (%rdi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rdi,%rbp,4),%xmm1
movdqu 0x30(%rdi,%rbp,4),%xmm3
movdqu 0x40(%rdi,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rdi,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rdi,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rdi,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdx
jne    1160 <magiic+0x60>
test   %rbx,%rbx
je     11ec <magiic+0xec>
lea    (%rdi,%rbp,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movdqu -0x10(%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    11d0 <magiic+0xd0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r12d
cmp    %r8,%rax
je     121d <magiic+0x11d>
nopl   0x0(%rax)
add    (%rdi,%rax,4),%r12d
add    $0x1,%rax
cmp    %rax,%r8
jne    1210 <magiic+0x110>
cmp    $0x2,%esi
jl     1394 <magiic+0x294>
mov    %r8d,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9d,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%r9
lea    0x100c(%rdi),%rbx
mov    %r10,%r15
shl    $0x5,%r15
mov    $0x1,%r14d
mov    %rdi,%rbp
xchg   %ax,%ax
cmp    $0x8,%esi
jae    1270 <magiic+0x170>
xor    %edx,%edx
xor    %eax,%eax
jmp    1360 <magiic+0x260>
xchg   %ax,%ax
pxor   %xmm0,%xmm0
cmp    $0x18,%rcx
jae    1290 <magiic+0x190>
xor    %edx,%edx
pxor   %xmm1,%xmm1
jmp    12f9 <magiic+0x1f9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r9,%rax
xor    %edx,%edx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
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,%rax
jne    12a0 <magiic+0x1a0>
test   %r10,%r10
je     1333 <magiic+0x233>
lea    0x0(,%rdx,4),%rax
add    %rbp,%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movdqu 0xf9c(%rax,%rdx,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0xfac(%rax,%rdx,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdx
cmp    %rdx,%r15
jne    1310 <magiic+0x210>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
mov    %r11,%rdx
cmp    %r8,%r11
je     1370 <magiic+0x270>
cs nopw 0x0(%rax,%rax,1)
nop
add    0xf9c(%rbp,%rdx,4),%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1360 <magiic+0x260>
cmp    %r12d,%eax
jne    174c <magiic+0x64c>
add    $0x1,%r14
add    $0xf9c,%rbx
add    $0xf9c,%rbp
cmp    %r8,%r14
jne    1260 <magiic+0x160>
test   %esi,%esi
jle    14ce <magiic+0x3ce>
mov    %r8d,%r9d
and    $0xfffffff8,%r9d
lea    0x6d44(%rdi),%rbp
mov    %r8,%r14
shr    $0x3,%r14
imul   $0x7ce0,%r14,%rbx
xor    %r11d,%r11d
mov    %rdi,%r10
xchg   %ax,%ax
cmp    $0x8,%esi
jae    13d0 <magiic+0x2d0>
xor    %r15d,%r15d
xor    %edx,%edx
jmp    1473 <magiic+0x373>
nop
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movd   -0x3e70(%rbp,%rdx,1),%xmm2
ff ff
movd   -0x4e0c(%rbp,%rdx,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x5da8(%rbp,%rdx,1),%xmm2
ff ff
movd   -0x6d44(%rbp,%rdx,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm0
movd   0x0(%rbp,%rdx,1),%xmm2
movd   -0xf9c(%rbp,%rdx,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x1f38(%rbp,%rdx,1),%xmm2
ff ff
movd   -0x2ed4(%rbp,%rdx,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0x7ce0,%rdx
cmp    %rdx,%rbx
jne    13e0 <magiic+0x2e0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
mov    %r9,%r15
cmp    %r8,%r9
je     149e <magiic+0x39e>
imul   $0xf9c,%r15,%rax
add    %r10,%rax
mov    %r8,%rcx
sub    %r15,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    (%rax),%edx
add    $0xf9c,%rax
add    $0xffffffffffffffff,%rcx
jne    1490 <magiic+0x390>
cmp    %r12d,%edx
jne    174c <magiic+0x64c>
add    $0x1,%r11
add    $0x4,%rbp
add    $0x4,%r10
cmp    %r8,%r11
jne    13c0 <magiic+0x2c0>
test   %esi,%esi
jle    14ce <magiic+0x3ce>
cmp    $0x8,%esi
jae    14d5 <magiic+0x3d5>
xor    %eax,%eax
xor    %edx,%edx
jmp    157f <magiic+0x47f>
xor    %edx,%edx
jmp    15a0 <magiic+0x4a0>
mov    %r8d,%eax
and    $0xfffffff8,%eax
imul   $0x7d00,%r14,%rdx
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movd   0x2ee0(%rdi,%rbp,1),%xmm2
movd   0x1f40(%rdi,%rbp,1),%xmm3
punpckldq %xmm2,%xmm3
movd   0xfa0(%rdi,%rbp,1),%xmm2
movd   (%rdi,%rbp,1),%xmm4
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm0
movd   0x6d60(%rdi,%rbp,1),%xmm2
movd   0x5dc0(%rdi,%rbp,1),%xmm3
punpckldq %xmm2,%xmm3
movd   0x4e20(%rdi,%rbp,1),%xmm2
movd   0x3e80(%rdi,%rbp,1),%xmm4
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0x7d00,%rbp
cmp    %rbp,%rdx
jne    14f0 <magiic+0x3f0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
cmp    %r8,%rax
je     15a0 <magiic+0x4a0>
imul   $0xfa0,%rax,%rbp
add    %rdi,%rbp
mov    %r8,%rcx
sub    %rax,%rcx
nop
add    0x0(%rbp),%edx
add    $0xfa0,%rbp
add    $0xffffffffffffffff,%rcx
jne    1590 <magiic+0x490>
xor    %eax,%eax
cmp    %r12d,%edx
sete   %al
jne    174e <magiic+0x64e>
test   %esi,%esi
jle    174e <magiic+0x64e>
mov    %r8d,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%rax
mov    %rax,-0x8(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%ecx
and    $0x3,%ecx
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rsp)
lea    0x70(%rdi),%rax
mov    %rax,-0x28(%rsp)
lea    -0x1(%rsi),%ebx
lea    0x10(%rdi),%rax
mov    %rax,-0x18(%rsp)
mov    %rcx,-0x10(%rsp)
mov    %rcx,%rax
shl    $0x5,%rax
mov    %r8,%r10
mov    %ebx,%ecx
cmp    $0x8,%esi
jae    1610 <magiic+0x510>
xor    %edx,%edx
xor    %ebp,%ebp
jmp    170e <magiic+0x60e>
imul   $0x3e7,%rcx,%r13
cmpq   $0x18,-0x8(%rsp)
jae    1630 <magiic+0x530>
pxor   %xmm0,%xmm0
xor    %r11d,%r11d
pxor   %xmm1,%xmm1
jmp    16b1 <magiic+0x5b1>
nop
mov    -0x28(%rsp),%rdx
lea    (%rdx,%r13,4),%r14
pxor   %xmm0,%xmm0
mov    -0x20(%rsp),%r9
xor    %r11d,%r11d
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu -0x70(%r14,%r11,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%r14,%r11,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%r14,%r11,4),%xmm1
movdqu -0x40(%r14,%r11,4),%xmm3
movdqu -0x30(%r14,%r11,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%r14,%r11,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%r14,%r11,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%r14,%r11,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%r11
add    $0xfffffffffffffffc,%r9
jne    1650 <magiic+0x550>
cmpq   $0x0,-0x10(%rsp)
je     16ec <magiic+0x5ec>
add    %r13,%r11
mov    -0x18(%rsp),%rdx
lea    (%rdx,%r11,4),%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%rax
jne    16d0 <magiic+0x5d0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
mov    %r15,%rdx
cmp    %r8,%r15
je     172c <magiic+0x62c>
imul   $0xf9c,%rcx,%rcx
add    %rdi,%rcx
nopl   0x0(%rax,%rax,1)
add    (%rcx,%rdx,4),%ebp
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1720 <magiic+0x620>
cmp    %r12d,%ebp
jne    174c <magiic+0x64c>
lea    -0x1(%r10),%rcx
add    $0xffffffff,%ebx
cmp    $0x2,%r10
mov    %rcx,%r10
jge    1600 <magiic+0x500>
mov    $0x1,%eax
jmp    174e <magiic+0x64e>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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