int magicBaDka(int madafakinsquare[999][999], int n) {
  int i1, i2, sum1 = 0, sum2 = 0;
  for (i1 = 0; i1 < n; i1++) {
    sum1 = sum1 + madafakinsquare[0][i1];
  }
  for (i1 = 1; i1 < n; i1++) {
    for (i2 = 0; i2 < n; i2++)
      sum2 = sum2 + madafakinsquare[i1][i2];
    if (sum2 != sum1)
      return 69;
    sum2 = 0;
  }
  for (i1 = 0; i1 < n; i1++) {
    for (i2 = 0; i2 < n; i2++)
      sum2 = sum2 + madafakinsquare[i2][i1];
    if (sum2 != sum1)
      return 69;
    sum2 = 0;
  }
  for (i1 = 0; i1 < n; i1++) {
    sum2 = sum2 + madafakinsquare[i1][i1];
  }
  if (sum2 != sum1)
    return 69;
  sum2 = 0;
  for (i1 = n; i1 > 0; i1--) {
    for (i2 = 0; i2 < n; i2++)
      sum2 = sum2 + madafakinsquare[i1 - 1][i2];
    if (sum2 != sum1)
      return 69;
    sum2 = 0;
  }
  return 505;
}


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

x86 assembly (clang, -O2):
<magicBaDka>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %esi,%esi
jle    1755 <magicBaDka+0x655>
mov    %esi,%r8d
cmp    $0x8,%esi
jae    1124 <magicBaDka+0x24>
xor    %eax,%eax
xor    %r12d,%r12d
jmp    1210 <magicBaDka+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 <magicBaDka+0x50>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    11b9 <magicBaDka+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 <magicBaDka+0x60>
test   %rbx,%rbx
je     11ec <magicBaDka+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 <magicBaDka+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 <magicBaDka+0x11d>
nopl   0x0(%rax)
add    (%rdi,%rax,4),%r12d
add    $0x1,%rax
cmp    %rax,%r8
jne    1210 <magicBaDka+0x110>
cmp    $0x2,%esi
jl     1394 <magicBaDka+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 <magicBaDka+0x170>
xor    %edx,%edx
xor    %eax,%eax
jmp    1360 <magicBaDka+0x260>
xchg   %ax,%ax
pxor   %xmm0,%xmm0
cmp    $0x18,%rcx
jae    1290 <magicBaDka+0x190>
xor    %edx,%edx
pxor   %xmm1,%xmm1
jmp    12f9 <magicBaDka+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 <magicBaDka+0x1a0>
test   %r10,%r10
je     1333 <magicBaDka+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 <magicBaDka+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 <magicBaDka+0x270>
cs nopw 0x0(%rax,%rax,1)
nop
add    0xf9c(%rbp,%rdx,4),%eax
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1360 <magicBaDka+0x260>
cmp    %r12d,%eax
jne    175c <magicBaDka+0x65c>
add    $0x1,%r14
add    $0xf9c,%rbx
add    $0xf9c,%rbp
cmp    %r8,%r14
jne    1260 <magicBaDka+0x160>
test   %esi,%esi
jle    14ce <magicBaDka+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 <magicBaDka+0x2d0>
xor    %r15d,%r15d
xor    %edx,%edx
jmp    1473 <magicBaDka+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 <magicBaDka+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 <magicBaDka+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 <magicBaDka+0x390>
cmp    %r12d,%edx
jne    175c <magicBaDka+0x65c>
add    $0x1,%r11
add    $0x4,%rbp
add    $0x4,%r10
cmp    %r8,%r11
jne    13c0 <magicBaDka+0x2c0>
test   %esi,%esi
jle    14ce <magicBaDka+0x3ce>
cmp    $0x8,%esi
jae    14d5 <magicBaDka+0x3d5>
xor    %eax,%eax
xor    %edx,%edx
jmp    157f <magicBaDka+0x47f>
xor    %edx,%edx
jmp    15a0 <magicBaDka+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 <magicBaDka+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 <magicBaDka+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 <magicBaDka+0x490>
mov    $0x45,%ecx
mov    $0x1f9,%eax
cmp    %r12d,%edx
cmovne %ecx,%eax
jne    1761 <magicBaDka+0x661>
test   %esi,%esi
jle    1761 <magicBaDka+0x661>
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
nopl   0x0(%rax,%rax,1)
mov    %ebx,%ecx
cmp    $0x8,%esi
jae    1620 <magicBaDka+0x520>
xor    %edx,%edx
xor    %ebp,%ebp
jmp    171e <magicBaDka+0x61e>
imul   $0x3e7,%rcx,%r13
cmpq   $0x18,-0x8(%rsp)
jae    1640 <magicBaDka+0x540>
pxor   %xmm0,%xmm0
xor    %r11d,%r11d
pxor   %xmm1,%xmm1
jmp    16c1 <magicBaDka+0x5c1>
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    1660 <magicBaDka+0x560>
cmpq   $0x0,-0x10(%rsp)
je     16fc <magicBaDka+0x5fc>
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    16e0 <magicBaDka+0x5e0>
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     173c <magicBaDka+0x63c>
imul   $0xf9c,%rcx,%rcx
add    %rdi,%rcx
nopl   0x0(%rax,%rax,1)
add    (%rcx,%rdx,4),%ebp
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1730 <magicBaDka+0x630>
cmp    %r12d,%ebp
jne    175c <magicBaDka+0x65c>
lea    -0x1(%r10),%rcx
add    $0xffffffff,%ebx
cmp    $0x2,%r10
mov    %rcx,%r10
jge    1610 <magicBaDka+0x510>
mov    $0x1f9,%eax
jmp    1761 <magicBaDka+0x661>
mov    $0x45,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @magicBaDka([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 i32, i32* %8
%16 = load [999 x i32]*, [999 x i32]** %4
%17 = getelementptr inbounds [999 x i32], [999 x i32]* %16, i64 0
%18 = load i32, i32* %6
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [999 x i32], [999 x i32]* %17, i64 0, i64 %19
%21 = load i32, i32* %20
%22 = add nsw i32 %15, %21
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 i32, i32* %9
%38 = load [999 x i32]*, [999 x i32]** %4
%39 = load i32, i32* %6
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [999 x i32], [999 x i32]* %38, i64 %40
%42 = load i32, i32* %7
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [999 x i32], [999 x i32]* %41, i64 0, i64 %43
%45 = load i32, i32* %44
%46 = add nsw i32 %37, %45
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 69, 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 i32, i32* %9
%71 = load [999 x i32]*, [999 x i32]** %4
%72 = load i32, i32* %7
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [999 x i32], [999 x i32]* %71, i64 %73
%75 = load i32, i32* %6
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [999 x i32], [999 x i32]* %74, i64 0, i64 %76
%78 = load i32, i32* %77
%79 = add nsw i32 %70, %78
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 69, 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 i32, i32* %9
%99 = load [999 x i32]*, [999 x i32]** %4
%100 = load i32, i32* %6
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [999 x i32], [999 x i32]* %99, i64 %101
%103 = load i32, i32* %6
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds [999 x i32], [999 x i32]* %102, i64 0, i64 %104
%106 = load i32, i32* %105
%107 = add nsw i32 %98, %106
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 69, 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 i32, i32* %9
%128 = load [999 x i32]*, [999 x i32]** %4
%129 = load i32, i32* %6
%130 = sub nsw i32 %129, 1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [999 x i32], [999 x i32]* %128, i64 %131
%133 = load i32, i32* %7
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [999 x i32], [999 x i32]* %132, i64 0, i64 %134
%136 = load i32, i32* %135
%137 = add nsw i32 %127, %136
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 69, 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 505, 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 @magicBaDka([999 x i32]* nocapture %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
br i1 %3, label %4, label %443
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 %443
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 %443
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 = select i1 %334, i32 69, i32 505
br i1 %336, label %443, label %338
338: ; preds = %332
%339 = zext i32 %1 to i64
%340 = and i64 %5, 4294967288
%341 = add nsw i64 %340, -8
%342 = lshr exact i64 %341, 3
%343 = add nuw nsw i64 %342, 1
%344 = icmp ult i32 %1, 8
%345 = and i64 %5, 4294967288
%346 = and i64 %343, 3
%347 = icmp ult i64 %341, 24
%348 = and i64 %343, 4611686018427387900
%349 = icmp eq i64 %346, 0
%350 = icmp eq i64 %345, %5
br label %354
351: ; preds = %440
%352 = add nsw i64 %355, -1
%353 = icmp sgt i64 %355, 1
br i1 %353, label %354, label %443
354: ; preds = %351, %338
%355 = phi i64 [ %339, %338 ], [ %352, %351 ]
%356 = add nuw i64 %355, 4294967295
%357 = and i64 %356, 4294967295
br i1 %344, label %429, label %358
358: ; preds = %354
br i1 %347, label %402, label %359
359: ; preds = %358, %359
%360 = phi i64 [ %399, %359 ], [ 0, %358 ]
%361 = phi <4 x i32> [ %397, %359 ], [ zeroinitializer, %358 ]
%362 = phi <4 x i32> [ %398, %359 ], [ zeroinitializer, %358 ]
%363 = phi i64 [ %400, %359 ], [ 0, %358 ]
%364 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %357, i64 %360
%365 = bitcast i32* %364 to <4 x i32>*
%366 = load <4 x i32>, <4 x i32>* %365
%367 = getelementptr inbounds i32, i32* %364, i64 4
%368 = bitcast i32* %367 to <4 x i32>*
%369 = load <4 x i32>, <4 x i32>* %368
%370 = add <4 x i32> %366, %361
%371 = add <4 x i32> %369, %362
%372 = or i64 %360, 8
%373 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %357, i64 %372
%374 = bitcast i32* %373 to <4 x i32>*
%375 = load <4 x i32>, <4 x i32>* %374
%376 = getelementptr inbounds i32, i32* %373, i64 4
%377 = bitcast i32* %376 to <4 x i32>*
%378 = load <4 x i32>, <4 x i32>* %377
%379 = add <4 x i32> %375, %370
%380 = add <4 x i32> %378, %371
%381 = or i64 %360, 16
%382 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %357, i64 %381
%383 = bitcast i32* %382 to <4 x i32>*
%384 = load <4 x i32>, <4 x i32>* %383
%385 = getelementptr inbounds i32, i32* %382, i64 4
%386 = bitcast i32* %385 to <4 x i32>*
%387 = load <4 x i32>, <4 x i32>* %386
%388 = add <4 x i32> %384, %379
%389 = add <4 x i32> %387, %380
%390 = or i64 %360, 24
%391 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %357, i64 %390
%392 = bitcast i32* %391 to <4 x i32>*
%393 = load <4 x i32>, <4 x i32>* %392
%394 = getelementptr inbounds i32, i32* %391, i64 4
%395 = bitcast i32* %394 to <4 x i32>*
%396 = load <4 x i32>, <4 x i32>* %395
%397 = add <4 x i32> %393, %388
%398 = add <4 x i32> %396, %389
%399 = add nuw i64 %360, 32
%400 = add i64 %363, 4
%401 = icmp eq i64 %400, %348
br i1 %401, label %402, label %359
402: ; preds = %359, %358
%403 = phi <4 x i32> [ undef, %358 ], [ %397, %359 ]
%404 = phi <4 x i32> [ undef, %358 ], [ %398, %359 ]
%405 = phi i64 [ 0, %358 ], [ %399, %359 ]
%406 = phi <4 x i32> [ zeroinitializer, %358 ], [ %397, %359 ]
%407 = phi <4 x i32> [ zeroinitializer, %358 ], [ %398, %359 ]
br i1 %349, label %424, label %408
408: ; preds = %402, %408
%409 = phi i64 [ %421, %408 ], [ %405, %402 ]
%410 = phi <4 x i32> [ %419, %408 ], [ %406, %402 ]
%411 = phi <4 x i32> [ %420, %408 ], [ %407, %402 ]
%412 = phi i64 [ %422, %408 ], [ 0, %402 ]
%413 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %357, i64 %409
%414 = bitcast i32* %413 to <4 x i32>*
%415 = load <4 x i32>, <4 x i32>* %414
%416 = getelementptr inbounds i32, i32* %413, i64 4
%417 = bitcast i32* %416 to <4 x i32>*
%418 = load <4 x i32>, <4 x i32>* %417
%419 = add <4 x i32> %415, %410
%420 = add <4 x i32> %418, %411
%421 = add nuw i64 %409, 8
%422 = add i64 %412, 1
%423 = icmp eq i64 %422, %346
br i1 %423, label %424, label %408
424: ; preds = %408, %402
%425 = phi <4 x i32> [ %403, %402 ], [ %419, %408 ]
%426 = phi <4 x i32> [ %404, %402 ], [ %420, %408 ]
%427 = add <4 x i32> %426, %425
%428 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %427)
br i1 %350, label %440, label %429
429: ; preds = %354, %424
%430 = phi i64 [ 0, %354 ], [ %345, %424 ]
%431 = phi i32 [ 0, %354 ], [ %428, %424 ]
br label %432
432: ; preds = %429, %432
%433 = phi i64 [ %438, %432 ], [ %430, %429 ]
%434 = phi i32 [ %437, %432 ], [ %431, %429 ]
%435 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %357, i64 %433
%436 = load i32, i32* %435
%437 = add nsw i32 %436, %434
%438 = add nuw nsw i64 %433, 1
%439 = icmp eq i64 %438, %339
br i1 %439, label %440, label %432
440: ; preds = %432, %424
%441 = phi i32 [ %428, %424 ], [ %437, %432 ]
%442 = icmp eq i32 %441, %92
br i1 %442, label %351, label %443
443: ; preds = %207, %320, %440, %351, %332, %2
%444 = phi i32 [ %337, %332 ], [ 505, %2 ], [ 69, %440 ], [ 505, %351 ], [ 69, %320 ], [ 69, %207 ]
ret i32 %444
}