int checkForMagic(int square[999][999], int n) {
  int i, j;
  int magic = 1;
  int sumd[2];
  sumd[0] = 0;
  sumd[1] = 0;
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      if (i == j)
        sumd[0] = sumd[0] + square[i][j];
    }
    sumd[1] += square[i][n - 1 - i];
  }
  if (sumd[0] != sumd[1])
    magic = 0;
  int sumr;
  for (i = 0; i < n; i++) {
    sumr = 0;
    for (j = 0; j < n; j++)
      sumr += square[i][j];
    if (sumr != sumd[0])
      magic = 0;
  }
  int sumc;
  for (j = 0; j < n; j++) {
    sumc = 0;
    for (i = 0; i < n; i++)
      sumc += square[i][j];
    if (sumc != sumd[0])
      magic = 0;
  }
  return magic;
}


x86 assembly (clang, -O0):
<checkForMagic>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x1,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b9 <checkForMagic+0xb9>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1184 <checkForMagic+0x84>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    1171 <checkForMagic+0x71>
mov    -0x20(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rdx
imul   $0xf9c,%rdx,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x20(%rbp)
jmp    1176 <checkForMagic+0x76>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    113a <checkForMagic+0x3a>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1127 <checkForMagic+0x27>
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     11cc <checkForMagic+0xcc>
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124c <checkForMagic+0x14c>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1226 <checkForMagic+0x126>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ed <checkForMagic+0xed>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     1239 <checkForMagic+0x139>
movl   $0x0,-0x18(%rbp)
jmp    123e <checkForMagic+0x13e>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11d3 <checkForMagic+0xd3>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12cc <checkForMagic+0x1cc>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12a6 <checkForMagic+0x1a6>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
imul   $0xf9c,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    126d <checkForMagic+0x16d>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     12b9 <checkForMagic+0x1b9>
movl   $0x0,-0x18(%rbp)
jmp    12be <checkForMagic+0x1be>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1253 <checkForMagic+0x153>
mov    -0x18(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<checkForMagic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %esi,%esi
jle    1391 <checkForMagic+0x291>
mov    %rdi,%r8
mov    %esi,%r12d
lea    -0x1(%r12),%rdi
mov    %r12d,%r9d
and    $0x3,%r9d
mov    %r12d,%r15d
and    $0xfffffffc,%r15d
mov    %r9,%r13
neg    %r13
xor    %r11d,%r11d
xor    %eax,%eax
xor    %edx,%edx
xor    %r10d,%r10d
jmp    115e <checkForMagic+0x5e>
nopl   (%rax)
mov    %eax,%ecx
not    %ecx
add    %esi,%ecx
movslq %ecx,%rcx
add    (%r14,%rcx,4),%r10d
add    $0x1,%rax
add    $0xffffffffffffffff,%r11
cmp    %r12,%rax
je     1206 <checkForMagic+0x106>
imul   $0xf9c,%rax,%r14
add    %r8,%r14
lea    (%r14,%rax,4),%rbx
cmp    $0x3,%rdi
jae    1180 <checkForMagic+0x80>
xor    %ecx,%ecx
test   %r9,%r9
jne    11dd <checkForMagic+0xdd>
jmp    1140 <checkForMagic+0x40>
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
jmp    1199 <checkForMagic+0x99>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %r15,%rbp
je     11d0 <checkForMagic+0xd0>
mov    %rbp,%rcx
cmp    %rbp,%rax
jne    11a3 <checkForMagic+0xa3>
add    (%rbx),%edx
lea    0x1(%rcx),%rbp
cmp    %rbp,%rax
jne    11ae <checkForMagic+0xae>
add    (%rbx),%edx
add    $0x1,%rbp
cmp    %rbp,%rax
jne    11b9 <checkForMagic+0xb9>
add    (%rbx),%edx
add    $0x1,%rbp
cmp    %rbp,%rax
jne    1190 <checkForMagic+0x90>
add    (%rbx),%edx
jmp    1190 <checkForMagic+0x90>
cs nopw 0x0(%rax,%rax,1)
add    $0x4,%rcx
test   %r9,%r9
je     1140 <checkForMagic+0x40>
add    %r11,%rcx
xor    %ebp,%ebp
jmp    11fd <checkForMagic+0xfd>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffffffffffff,%rbp
cmp    %rbp,%r13
je     1140 <checkForMagic+0x40>
cmp    %rbp,%rcx
jne    11f0 <checkForMagic+0xf0>
add    (%rbx),%edx
jmp    11f0 <checkForMagic+0xf0>
xor    %eax,%eax
cmp    %r10d,%edx
sete   %al
test   %esi,%esi
jle    14d4 <checkForMagic+0x3d4>
mov    %r12d,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%r9
mov    %r9,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r11d
and    $0x3,%r11d
and    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x8(%rsp)
lea    0x70(%r8),%rbx
mov    %r11,%r14
shl    $0x5,%r14
xor    %r10d,%r10d
mov    %r8,%rdi
xor    %r13d,%r13d
jmp    1281 <checkForMagic+0x181>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %edx,%ebp
cmovne %r10d,%eax
add    $0x1,%r13
add    $0xf9c,%rbx
add    $0xf9c,%rdi
cmp    %r12,%r13
je     139b <checkForMagic+0x29b>
cmp    $0x8,%esi
jae    1290 <checkForMagic+0x190>
xor    %ecx,%ecx
xor    %ebp,%ebp
jmp    1380 <checkForMagic+0x280>
nop
pxor   %xmm0,%xmm0
cmp    $0x18,%r9
jae    12b0 <checkForMagic+0x1b0>
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    1319 <checkForMagic+0x219>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x8(%rsp),%r10
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu -0x70(%rbx,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rbx,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rbx,%rbp,4),%xmm1
movdqu -0x40(%rbx,%rbp,4),%xmm3
movdqu -0x30(%rbx,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rbx,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rbx,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rbx,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%r10
jne    12c0 <checkForMagic+0x1c0>
test   %r11,%r11
je     134c <checkForMagic+0x24c>
lea    (%rdi,%rbp,4),%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rcx,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rcx,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1330 <checkForMagic+0x230>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
mov    %r15,%rcx
cmp    %r12,%r15
mov    $0x0,%r10d
je     1260 <checkForMagic+0x160>
nopl   0x0(%rax,%rax,1)
add    (%rdi,%rcx,4),%ebp
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1380 <checkForMagic+0x280>
jmp    1260 <checkForMagic+0x160>
mov    $0x1,%eax
jmp    14d4 <checkForMagic+0x3d4>
test   %esi,%esi
jle    14d4 <checkForMagic+0x3d4>
mov    %r12d,%r11d
and    $0xfffffff8,%r11d
lea    0x6d44(%r8),%rbx
mov    %r12,%rcx
shr    $0x3,%rcx
imul   $0x7ce0,%rcx,%r14
xor    %r9d,%r9d
xor    %r10d,%r10d
jmp    13eb <checkForMagic+0x2eb>
nopw   0x0(%rax,%rax,1)
cmp    %edx,%ebp
cmovne %r9d,%eax
add    $0x1,%r10
add    $0x4,%rbx
add    $0x4,%r8
cmp    %r12,%r10
je     14d4 <checkForMagic+0x3d4>
cmp    $0x8,%esi
jae    1400 <checkForMagic+0x300>
xor    %r15d,%r15d
xor    %ebp,%ebp
jmp    14a6 <checkForMagic+0x3a6>
nopw   0x0(%rax,%rax,1)
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movd   -0x3e70(%rbx,%rbp,1),%xmm2
ff ff
movd   -0x4e0c(%rbx,%rbp,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x5da8(%rbx,%rbp,1),%xmm2
ff ff
movd   -0x6d44(%rbx,%rbp,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm0
movd   (%rbx,%rbp,1),%xmm2
movd   -0xf9c(%rbx,%rbp,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x1f38(%rbx,%rbp,1),%xmm2
ff ff
movd   -0x2ed4(%rbx,%rbp,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0x7ce0,%rbp
cmp    %rbp,%r14
jne    1410 <checkForMagic+0x310>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebp
mov    %r11,%r15
cmp    %r12,%r11
je     13d0 <checkForMagic+0x2d0>
imul   $0xf9c,%r15,%rdi
add    %r8,%rdi
mov    %r12,%rcx
sub    %r15,%rcx
cs nopw 0x0(%rax,%rax,1)
add    (%rdi),%ebp
add    $0xf9c,%rdi
add    $0xffffffffffffffff,%rcx
jne    14c0 <checkForMagic+0x3c0>
jmp    13d0 <checkForMagic+0x2d0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @checkForMagic([999 x i32]* nocapture %0, i32 %1) {
%3 = icmp sgt i32 %1, 0
br i1 %3, label %4, label %253
4: ; preds = %2
%5 = zext i32 %1 to i64
%6 = add nsw i64 %5, -1
%7 = and i64 %5, 3
%8 = icmp ult i64 %6, 3
%9 = and i64 %5, 4294967292
%10 = icmp eq i64 %7, 0
br label %11
11: ; preds = %67, %4
%12 = phi i64 [ 0, %4 ], [ %76, %67 ]
%13 = phi i32 [ 0, %4 ], [ %68, %67 ]
%14 = phi i32 [ 0, %4 ], [ %75, %67 ]
%15 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %12, i64 %12
br i1 %8, label %50, label %16
16: ; preds = %11, %45
%17 = phi i64 [ %47, %45 ], [ 0, %11 ]
%18 = phi i32 [ %46, %45 ], [ %13, %11 ]
%19 = phi i64 [ %48, %45 ], [ 0, %11 ]
%20 = icmp eq i64 %12, %17
br i1 %20, label %21, label %24
21: ; preds = %16
%22 = load i32, i32* %15
%23 = add nsw i32 %22, %18
br label %24
24: ; preds = %16, %21
%25 = phi i32 [ %23, %21 ], [ %18, %16 ]
%26 = or i64 %17, 1
%27 = icmp eq i64 %12, %26
br i1 %27, label %28, label %31
28: ; preds = %24
%29 = load i32, i32* %15
%30 = add nsw i32 %29, %25
br label %31
31: ; preds = %28, %24
%32 = phi i32 [ %30, %28 ], [ %25, %24 ]
%33 = or i64 %17, 2
%34 = icmp eq i64 %12, %33
br i1 %34, label %35, label %38
35: ; preds = %31
%36 = load i32, i32* %15
%37 = add nsw i32 %36, %32
br label %38
38: ; preds = %35, %31
%39 = phi i32 [ %37, %35 ], [ %32, %31 ]
%40 = or i64 %17, 3
%41 = icmp eq i64 %12, %40
br i1 %41, label %42, label %45
42: ; preds = %38
%43 = load i32, i32* %15
%44 = add nsw i32 %43, %39
br label %45
45: ; preds = %42, %38
%46 = phi i32 [ %44, %42 ], [ %39, %38 ]
%47 = add nuw nsw i64 %17, 4
%48 = add i64 %19, 4
%49 = icmp eq i64 %48, %9
br i1 %49, label %50, label %16
50: ; preds = %45, %11
%51 = phi i32 [ undef, %11 ], [ %46, %45 ]
%52 = phi i64 [ 0, %11 ], [ %47, %45 ]
%53 = phi i32 [ %13, %11 ], [ %46, %45 ]
br i1 %10, label %67, label %54
54: ; preds = %50, %62
%55 = phi i64 [ %64, %62 ], [ %52, %50 ]
%56 = phi i32 [ %63, %62 ], [ %53, %50 ]
%57 = phi i64 [ %65, %62 ], [ 0, %50 ]
%58 = icmp eq i64 %12, %55
br i1 %58, label %59, label %62
59: ; preds = %54
%60 = load i32, i32* %15
%61 = add nsw i32 %60, %56
br label %62
62: ; preds = %59, %54
%63 = phi i32 [ %61, %59 ], [ %56, %54 ]
%64 = add nuw nsw i64 %55, 1
%65 = add i64 %57, 1
%66 = icmp eq i64 %65, %7
br i1 %66, label %67, label %54
67: ; preds = %62, %50
%68 = phi i32 [ %51, %50 ], [ %63, %62 ]
%69 = trunc i64 %12 to i32
%70 = xor i32 %69, -1
%71 = add i32 %70, %1
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %12, i64 %72
%74 = load i32, i32* %73
%75 = add nsw i32 %74, %14
%76 = add nuw nsw i64 %12, 1
%77 = icmp eq i64 %76, %5
br i1 %77, label %78, label %11
78: ; preds = %67
%79 = icmp eq i32 %68, %75
%80 = zext i1 %79 to i32
br i1 %3, label %81, label %253
81: ; preds = %78
%82 = zext i32 %1 to i64
%83 = and i64 %5, 4294967288
%84 = add nsw i64 %83, -8
%85 = lshr exact i64 %84, 3
%86 = add nuw nsw i64 %85, 1
%87 = icmp ult i32 %1, 8
%88 = and i64 %5, 4294967288
%89 = and i64 %86, 3
%90 = icmp ult i64 %84, 24
%91 = and i64 %86, 4611686018427387900
%92 = icmp eq i64 %89, 0
%93 = icmp eq i64 %88, %5
br label %94
94: ; preds = %185, %81
%95 = phi i64 [ 0, %81 ], [ %189, %185 ]
%96 = phi i32 [ %80, %81 ], [ %188, %185 ]
br i1 %87, label %168, label %97
97: ; preds = %94
br i1 %90, label %141, label %98
98: ; preds = %97, %98
%99 = phi i64 [ %138, %98 ], [ 0, %97 ]
%100 = phi <4 x i32> [ %136, %98 ], [ zeroinitializer, %97 ]
%101 = phi <4 x i32> [ %137, %98 ], [ zeroinitializer, %97 ]
%102 = phi i64 [ %139, %98 ], [ 0, %97 ]
%103 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %95, i64 %99
%104 = bitcast i32* %103 to <4 x i32>*
%105 = load <4 x i32>, <4 x i32>* %104
%106 = getelementptr inbounds i32, i32* %103, i64 4
%107 = bitcast i32* %106 to <4 x i32>*
%108 = load <4 x i32>, <4 x i32>* %107
%109 = add <4 x i32> %105, %100
%110 = add <4 x i32> %108, %101
%111 = or i64 %99, 8
%112 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %95, i64 %111
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = getelementptr inbounds i32, i32* %112, i64 4
%116 = bitcast i32* %115 to <4 x i32>*
%117 = load <4 x i32>, <4 x i32>* %116
%118 = add <4 x i32> %114, %109
%119 = add <4 x i32> %117, %110
%120 = or i64 %99, 16
%121 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %95, i64 %120
%122 = bitcast i32* %121 to <4 x i32>*
%123 = load <4 x i32>, <4 x i32>* %122
%124 = getelementptr inbounds i32, i32* %121, i64 4
%125 = bitcast i32* %124 to <4 x i32>*
%126 = load <4 x i32>, <4 x i32>* %125
%127 = add <4 x i32> %123, %118
%128 = add <4 x i32> %126, %119
%129 = or i64 %99, 24
%130 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %95, i64 %129
%131 = bitcast i32* %130 to <4 x i32>*
%132 = load <4 x i32>, <4 x i32>* %131
%133 = getelementptr inbounds i32, i32* %130, i64 4
%134 = bitcast i32* %133 to <4 x i32>*
%135 = load <4 x i32>, <4 x i32>* %134
%136 = add <4 x i32> %132, %127
%137 = add <4 x i32> %135, %128
%138 = add nuw i64 %99, 32
%139 = add i64 %102, 4
%140 = icmp eq i64 %139, %91
br i1 %140, label %141, label %98
141: ; preds = %98, %97
%142 = phi <4 x i32> [ undef, %97 ], [ %136, %98 ]
%143 = phi <4 x i32> [ undef, %97 ], [ %137, %98 ]
%144 = phi i64 [ 0, %97 ], [ %138, %98 ]
%145 = phi <4 x i32> [ zeroinitializer, %97 ], [ %136, %98 ]
%146 = phi <4 x i32> [ zeroinitializer, %97 ], [ %137, %98 ]
br i1 %92, label %163, label %147
147: ; preds = %141, %147
%148 = phi i64 [ %160, %147 ], [ %144, %141 ]
%149 = phi <4 x i32> [ %158, %147 ], [ %145, %141 ]
%150 = phi <4 x i32> [ %159, %147 ], [ %146, %141 ]
%151 = phi i64 [ %161, %147 ], [ 0, %141 ]
%152 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %95, i64 %148
%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 %148, 8
%161 = add i64 %151, 1
%162 = icmp eq i64 %161, %89
br i1 %162, label %163, label %147
163: ; preds = %147, %141
%164 = phi <4 x i32> [ %142, %141 ], [ %158, %147 ]
%165 = phi <4 x i32> [ %143, %141 ], [ %159, %147 ]
%166 = add <4 x i32> %165, %164
%167 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %166)
br i1 %93, label %185, label %168
168: ; preds = %94, %163
%169 = phi i64 [ 0, %94 ], [ %88, %163 ]
%170 = phi i32 [ 0, %94 ], [ %167, %163 ]
br label %177
171: ; preds = %185
br i1 %3, label %172, label %253
172: ; preds = %171
%173 = zext i32 %1 to i64
%174 = icmp ult i32 %1, 8
%175 = and i64 %5, 4294967288
%176 = icmp eq i64 %175, %5
br label %191
177: ; preds = %168, %177
%178 = phi i64 [ %183, %177 ], [ %169, %168 ]
%179 = phi i32 [ %182, %177 ], [ %170, %168 ]
%180 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %95, i64 %178
%181 = load i32, i32* %180
%182 = add nsw i32 %181, %179
%183 = add nuw nsw i64 %178, 1
%184 = icmp eq i64 %183, %82
br i1 %184, label %185, label %177
185: ; preds = %177, %163
%186 = phi i32 [ %167, %163 ], [ %182, %177 ]
%187 = icmp eq i32 %186, %68
%188 = select i1 %187, i32 %96, i32 0
%189 = add nuw nsw i64 %95, 1
%190 = icmp eq i64 %189, %82
br i1 %190, label %171, label %94
191: ; preds = %247, %172
%192 = phi i64 [ 0, %172 ], [ %251, %247 ]
%193 = phi i32 [ %188, %172 ], [ %250, %247 ]
br i1 %174, label %236, label %194
194: ; preds = %191, %194
%195 = phi i64 [ %231, %194 ], [ 0, %191 ]
%196 = phi <4 x i32> [ %229, %194 ], [ zeroinitializer, %191 ]
%197 = phi <4 x i32> [ %230, %194 ], [ zeroinitializer, %191 ]
%198 = or i64 %195, 1
%199 = or i64 %195, 2
%200 = or i64 %195, 3
%201 = or i64 %195, 4
%202 = or i64 %195, 5
%203 = or i64 %195, 6
%204 = or i64 %195, 7
%205 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %195, i64 %192
%206 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %198, i64 %192
%207 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %199, i64 %192
%208 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %200, i64 %192
%209 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %201, i64 %192
%210 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %202, i64 %192
%211 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %203, i64 %192
%212 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %204, i64 %192
%213 = load i32, i32* %205
%214 = load i32, i32* %206
%215 = load i32, i32* %207
%216 = load i32, i32* %208
%217 = insertelement <4 x i32> poison, i32 %213, i64 0
%218 = insertelement <4 x i32> %217, i32 %214, i64 1
%219 = insertelement <4 x i32> %218, i32 %215, i64 2
%220 = insertelement <4 x i32> %219, i32 %216, i64 3
%221 = load i32, i32* %209
%222 = load i32, i32* %210
%223 = load i32, i32* %211
%224 = load i32, i32* %212
%225 = insertelement <4 x i32> poison, i32 %221, i64 0
%226 = insertelement <4 x i32> %225, i32 %222, i64 1
%227 = insertelement <4 x i32> %226, i32 %223, i64 2
%228 = insertelement <4 x i32> %227, i32 %224, i64 3
%229 = add <4 x i32> %220, %196
%230 = add <4 x i32> %228, %197
%231 = add nuw i64 %195, 8
%232 = icmp eq i64 %231, %175
br i1 %232, label %233, label %194
233: ; preds = %194
%234 = add <4 x i32> %230, %229
%235 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %234)
br i1 %176, label %247, label %236
236: ; preds = %191, %233
%237 = phi i64 [ 0, %191 ], [ %175, %233 ]
%238 = phi i32 [ 0, %191 ], [ %235, %233 ]
br label %239
239: ; preds = %236, %239
%240 = phi i64 [ %245, %239 ], [ %237, %236 ]
%241 = phi i32 [ %244, %239 ], [ %238, %236 ]
%242 = getelementptr inbounds [999 x i32], [999 x i32]* %0, i64 %240, i64 %192
%243 = load i32, i32* %242
%244 = add nsw i32 %243, %241
%245 = add nuw nsw i64 %240, 1
%246 = icmp eq i64 %245, %173
br i1 %246, label %247, label %239
247: ; preds = %239, %233
%248 = phi i32 [ %235, %233 ], [ %244, %239 ]
%249 = icmp eq i32 %248, %68
%250 = select i1 %249, i32 %193, i32 0
%251 = add nuw nsw i64 %192, 1
%252 = icmp eq i64 %251, %173
br i1 %252, label %253, label %191
253: ; preds = %247, %2, %78, %171
%254 = phi i32 [ %188, %171 ], [ %80, %78 ], [ 1, %2 ], [ %250, %247 ]
ret i32 %254
}