int if_square_is_magic(int size, int square[size][size]) {
  int row, column, magic = 1, i;
  int sum = 0;
  int new_sum = 0;
  for (column = 0; column < size; column++) {
    sum = sum + square[0][column];
  }
  for (row = 0; row < size; row++) {
    for (column = 0; column < size; column++) {
      new_sum = new_sum + square[row][column];
    }
    if (!(new_sum == sum)) {
      magic = 0;
    }
    new_sum = 0;
  }
  new_sum = 0;
  for (column = 0; column < size; column++) {
    for (row = 0; row < size; row++) {
      new_sum = new_sum + square[row][column];
    }
    if (!(new_sum == sum)) {
      magic = 0;
    }
    new_sum = 0;
  }
  new_sum = 0;
  for (i = 0; i < size; i++) {
    new_sum = new_sum + square[i][i];
  }
  if (!(new_sum == sum)) {
    magic = 0;
  }
  new_sum = 0;
  row = 0;
  column = size - 1;
  for (i = 0; i < size; i++) {
    new_sum = new_sum + square[row][column];
    row++;
    column--;
  }
  if (!(new_sum == sum)) {
    magic = 0;
  }
  return magic;
}


x86 assembly (clang, -O0):
<if_square_is_magic>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0x30(%rbp)
movl   $0x1,-0x1c(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1168 <if_square_is_magic+0x68>
mov    -0x30(%rbp),%rdx
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%rcx
imul   $0x0,%rdx,%rdx
shl    $0x2,%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    112e <if_square_is_magic+0x2e>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11e8 <if_square_is_magic+0xe8>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11c0 <if_square_is_magic+0xc0>
mov    -0x30(%rbp),%rsi
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1182 <if_square_is_magic+0x82>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     11d3 <if_square_is_magic+0xd3>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    116f <if_square_is_magic+0x6f>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    126f <if_square_is_magic+0x16f>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1247 <if_square_is_magic+0x147>
mov    -0x30(%rbp),%rsi
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1209 <if_square_is_magic+0x109>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     125a <if_square_is_magic+0x15a>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11f6 <if_square_is_magic+0xf6>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12bb <if_square_is_magic+0x1bb>
mov    -0x30(%rbp),%rsi
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    127d <if_square_is_magic+0x17d>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     12ce <if_square_is_magic+0x1ce>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    133c <if_square_is_magic+0x23c>
mov    -0x30(%rbp),%rsi
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x18(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12ec <if_square_is_magic+0x1ec>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
je     134f <if_square_is_magic+0x24f>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<if_square_is_magic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    $0x1,%r8d
xor    %eax,%eax
test   %edi,%edi
jle    112a <if_square_is_magic+0x2a>
mov    %rsi,%r14
mov    %edi,%edx
cmp    $0x8,%edi
jae    1136 <if_square_is_magic+0x36>
xor    %ebx,%ebx
xor    %r9d,%r9d
jmp    1240 <if_square_is_magic+0x140>
xor    %ecx,%ecx
xor    %r9d,%r9d
xor    %ebp,%ebp
jmp    1538 <if_square_is_magic+0x438>
mov    %edx,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rsi
mov    %rsi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %ecx,%r9d
and    $0x3,%r9d
cmp    $0x18,%rsi
jae    1163 <if_square_is_magic+0x63>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    11e1 <if_square_is_magic+0xe1>
and    $0xfffffffffffffffc,%rcx
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu (%r14,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%r14,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%r14,%rbp,4),%xmm1
movdqu 0x30(%r14,%rbp,4),%xmm3
movdqu 0x40(%r14,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%r14,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%r14,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%r14,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rcx
jne    1180 <if_square_is_magic+0x80>
test   %r9,%r9
je     121c <if_square_is_magic+0x11c>
lea    (%r14,%rbp,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%rcx,%rsi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rcx,%rsi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rsi
cmp    %rsi,%r9
jne    1200 <if_square_is_magic+0x100>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r9d
cmp    %rdx,%rbx
je     124d <if_square_is_magic+0x14d>
nopl   0x0(%rax)
add    (%r14,%rbx,4),%r9d
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1240 <if_square_is_magic+0x140>
test   %edi,%edi
jle    14ad <if_square_is_magic+0x3ad>
mov    %edi,-0xc(%rsp)
mov    %edx,%r15d
and    $0xfffffff8,%r15d
lea    -0x8(%r15),%r10
mov    %r10,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x8(%rsp)
lea    0x70(%r14),%rbx
lea    0x0(,%rdx,4),%r12
mov    %rsi,%rcx
shl    $0x5,%rcx
mov    $0x1,%r8d
xor    %r13d,%r13d
mov    %r14,%rbp
xor    %r11d,%r11d
jmp    12ca <if_square_is_magic+0x1ca>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    %r9d,%eax
cmovne %r13d,%r8d
add    $0x1,%r11
add    %r12,%rbx
add    %r12,%rbp
cmp    %rdx,%r11
je     13e2 <if_square_is_magic+0x2e2>
cmpl   $0x8,-0xc(%rsp)
jae    12e0 <if_square_is_magic+0x1e0>
xor    %edi,%edi
xor    %eax,%eax
jmp    13d0 <if_square_is_magic+0x2d0>
nopw   0x0(%rax,%rax,1)
pxor   %xmm0,%xmm0
cmp    $0x18,%r10
jae    1300 <if_square_is_magic+0x200>
xor    %eax,%eax
pxor   %xmm1,%xmm1
jmp    1369 <if_square_is_magic+0x269>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x8(%rsp),%rdi
xor    %eax,%eax
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu -0x70(%rbx,%rax,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rbx,%rax,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rbx,%rax,4),%xmm1
movdqu -0x40(%rbx,%rax,4),%xmm3
movdqu -0x30(%rbx,%rax,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rbx,%rax,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rbx,%rax,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rbx,%rax,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rax
add    $0xfffffffffffffffc,%rdi
jne    1310 <if_square_is_magic+0x210>
test   %rsi,%rsi
je     139c <if_square_is_magic+0x29c>
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu (%rax,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rax,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1380 <if_square_is_magic+0x280>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%eax
mov    %r15,%rdi
cmp    %rdx,%r15
je     12b0 <if_square_is_magic+0x1b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    0x0(%rbp,%rdi,4),%eax
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    13d0 <if_square_is_magic+0x2d0>
jmp    12b0 <if_square_is_magic+0x1b0>
cmpl   $0x0,-0xc(%rsp)
jle    14b6 <if_square_is_magic+0x3b6>
lea    -0x1(%rdx),%r15
mov    %edx,%r13d
and    $0x3,%r13d
mov    %edx,%ecx
and    $0xfffffffc,%ecx
mov    %rdx,%r10
shl    $0x4,%r10
lea    (%r12,%r12,2),%r11
mov    %r14,%rsi
xor    %ebx,%ebx
jmp    1429 <if_square_is_magic+0x329>
nop
cmp    %r9d,%edi
mov    $0x0,%eax
cmovne %eax,%r8d
add    $0x1,%rbx
add    $0x4,%rsi
cmp    %rdx,%rbx
je     148d <if_square_is_magic+0x38d>
xor    %eax,%eax
cmp    $0x3,%r15
jae    1440 <if_square_is_magic+0x340>
xor    %edi,%edi
jmp    146c <if_square_is_magic+0x36c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rsi,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
add    0x0(%rbp),%edi
add    0x0(%rbp,%rdx,4),%edi
add    0x0(%rbp,%rdx,8),%edi
add    0x0(%rbp,%r11,1),%edi
add    $0x4,%rax
add    %r10,%rbp
cmp    %rax,%rcx
jne    1450 <if_square_is_magic+0x350>
test   %r13,%r13
je     1410 <if_square_is_magic+0x310>
imul   %rdx,%rax
lea    (%rsi,%rax,4),%rax
mov    %r13,%rbp
nopl   0x0(%rax)
add    (%rax),%edi
add    %r12,%rax
add    $0xffffffffffffffff,%rbp
jne    1480 <if_square_is_magic+0x380>
jmp    1410 <if_square_is_magic+0x310>
mov    -0xc(%rsp),%r13d
test   %r13d,%r13d
jle    14b6 <if_square_is_magic+0x3b6>
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%r15
jae    14ba <if_square_is_magic+0x3ba>
xor    %ebx,%ebx
xor    %ecx,%ecx
test   %rax,%rax
jne    14fd <if_square_is_magic+0x3fd>
jmp    151b <if_square_is_magic+0x41b>
xor    %ecx,%ecx
xor    %ebp,%ebp
jmp    1538 <if_square_is_magic+0x438>
xor    %ecx,%ecx
jmp    1534 <if_square_is_magic+0x434>
lea    0x10(%r10),%r12
mov    %edx,%ebp
and    $0xfffffffc,%ebp
neg    %rbp
xor    %ecx,%ecx
mov    $0x1,%ebx
mov    %r14,%rsi
add    (%rsi),%ecx
add    0x4(%rsi,%rdx,4),%ecx
add    0x8(%rsi,%rdx,8),%ecx
add    0xc(%rsi,%r11,1),%ecx
add    %r12,%rsi
lea    (%rbx,%rbp,1),%rdi
add    $0x4,%rdi
add    $0x4,%rbx
cmp    $0x1,%rdi
jne    14d0 <if_square_is_magic+0x3d0>
add    $0xffffffffffffffff,%rbx
test   %rax,%rax
je     151b <if_square_is_magic+0x41b>
lea    0x4(,%rdx,4),%rsi
imul   %rsi,%rbx
add    %r14,%rbx
nopl   0x0(%rax)
add    (%rbx),%ecx
add    %rsi,%rbx
add    $0xffffffffffffffff,%rax
jne    1510 <if_square_is_magic+0x410>
test   %r13d,%r13d
jle    1534 <if_square_is_magic+0x434>
mov    %edx,%edi
and    $0x3,%edi
cmp    $0x3,%r15
jae    154f <if_square_is_magic+0x44f>
xor    %ebx,%ebx
mov    %rdx,%rsi
xor    %ebp,%ebp
jmp    1594 <if_square_is_magic+0x494>
xor    %ebp,%ebp
xor    %eax,%eax
xor    %r9d,%ecx
xor    %r9d,%ebp
or     %ecx,%ebp
cmove  %r8d,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xfffffffffffffff0,%r10
mov    %edx,%eax
and    $0xfffffffc,%eax
neg    %rax
xor    %ebx,%ebx
mov    %r14,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    -0x4(%rsi,%rdx,4),%ebp
add    -0x8(%rsi,%rdx,8),%ebp
add    -0xc(%rsi,%r11,1),%ebp
add    (%rsi,%r10,1),%ebp
add    %r10,%rsi
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%rax
jne    1570 <if_square_is_magic+0x470>
lea    (%rdx,%rbx,1),%rsi
neg    %rbx
xor    %eax,%eax
test   %rdi,%rdi
je     1538 <if_square_is_magic+0x438>
imul   %rdx,%rbx
add    %rbx,%rsi
lea    (%r14,%rsi,4),%rsi
add    $0xfffffffffffffffc,%rsi
lea    -0x4(,%rdx,4),%rdx
ff
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    (%rsi),%ebp
add    %rdx,%rsi
add    $0xffffffffffffffff,%rdi
jne    15c0 <if_square_is_magic+0x4c0>
jmp    1538 <if_square_is_magic+0x438>

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

LLVM IR (-O2):
define i32 @if_square_is_magic(i32 %0, i32* nocapture %1) {
%3 = zext i32 %0 to i64
%4 = icmp sgt i32 %0, 0
br i1 %4, label %5, label %380
5: ; preds = %2
%6 = icmp ult i32 %0, 8
br i1 %6, label %88, label %7
7: ; preds = %5
%8 = and i64 %3, 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 i32, i32* %1, 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 i32, i32* %1, 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 i32, i32* %1, 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 i32, i32* %1, 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 i32, i32* %1, 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, %3
br i1 %87, label %91, label %88
88: ; preds = %5, %82
%89 = phi i64 [ 0, %5 ], [ %8, %82 ]
%90 = phi i32 [ 0, %5 ], [ %86, %82 ]
br label %105
91: ; preds = %105, %82
%92 = phi i32 [ %86, %82 ], [ %110, %105 ]
br i1 %4, label %93, label %380
93: ; preds = %91
%94 = and i64 %3, 4294967288
%95 = add nsw i64 %94, -8
%96 = lshr exact i64 %95, 3
%97 = add nuw nsw i64 %96, 1
%98 = icmp ult i32 %0, 8
%99 = and i64 %3, 4294967288
%100 = and i64 %97, 3
%101 = icmp ult i64 %95, 24
%102 = and i64 %97, 4611686018427387900
%103 = icmp eq i64 %100, 0
%104 = icmp eq i64 %99, %3
br label %113
105: ; preds = %88, %105
%106 = phi i64 [ %111, %105 ], [ %89, %88 ]
%107 = phi i32 [ %110, %105 ], [ %90, %88 ]
%108 = getelementptr inbounds i32, i32* %1, i64 %106
%109 = load i32, i32* %108
%110 = add nsw i32 %109, %107
%111 = add nuw nsw i64 %106, 1
%112 = icmp eq i64 %111, %3
br i1 %112, label %91, label %105
113: ; preds = %93, %207
%114 = phi i64 [ %211, %207 ], [ 0, %93 ]
%115 = phi i32 [ %210, %207 ], [ 1, %93 ]
%116 = mul nuw nsw i64 %114, %3
%117 = getelementptr inbounds i32, i32* %1, i64 %116
br i1 %98, label %189, label %118
118: ; preds = %113
br i1 %101, label %162, label %119
119: ; preds = %118, %119
%120 = phi i64 [ %159, %119 ], [ 0, %118 ]
%121 = phi <4 x i32> [ %157, %119 ], [ zeroinitializer, %118 ]
%122 = phi <4 x i32> [ %158, %119 ], [ zeroinitializer, %118 ]
%123 = phi i64 [ %160, %119 ], [ 0, %118 ]
%124 = getelementptr inbounds i32, i32* %117, i64 %120
%125 = bitcast i32* %124 to <4 x i32>*
%126 = load <4 x i32>, <4 x i32>* %125
%127 = getelementptr inbounds i32, i32* %124, i64 4
%128 = bitcast i32* %127 to <4 x i32>*
%129 = load <4 x i32>, <4 x i32>* %128
%130 = add <4 x i32> %126, %121
%131 = add <4 x i32> %129, %122
%132 = or i64 %120, 8
%133 = getelementptr inbounds i32, i32* %117, i64 %132
%134 = bitcast i32* %133 to <4 x i32>*
%135 = load <4 x i32>, <4 x i32>* %134
%136 = getelementptr inbounds i32, i32* %133, i64 4
%137 = bitcast i32* %136 to <4 x i32>*
%138 = load <4 x i32>, <4 x i32>* %137
%139 = add <4 x i32> %135, %130
%140 = add <4 x i32> %138, %131
%141 = or i64 %120, 16
%142 = getelementptr inbounds i32, i32* %117, i64 %141
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = getelementptr inbounds i32, i32* %142, i64 4
%146 = bitcast i32* %145 to <4 x i32>*
%147 = load <4 x i32>, <4 x i32>* %146
%148 = add <4 x i32> %144, %139
%149 = add <4 x i32> %147, %140
%150 = or i64 %120, 24
%151 = getelementptr inbounds i32, i32* %117, i64 %150
%152 = bitcast i32* %151 to <4 x i32>*
%153 = load <4 x i32>, <4 x i32>* %152
%154 = getelementptr inbounds i32, i32* %151, i64 4
%155 = bitcast i32* %154 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = add <4 x i32> %153, %148
%158 = add <4 x i32> %156, %149
%159 = add nuw i64 %120, 32
%160 = add i64 %123, 4
%161 = icmp eq i64 %160, %102
br i1 %161, label %162, label %119
162: ; preds = %119, %118
%163 = phi <4 x i32> [ undef, %118 ], [ %157, %119 ]
%164 = phi <4 x i32> [ undef, %118 ], [ %158, %119 ]
%165 = phi i64 [ 0, %118 ], [ %159, %119 ]
%166 = phi <4 x i32> [ zeroinitializer, %118 ], [ %157, %119 ]
%167 = phi <4 x i32> [ zeroinitializer, %118 ], [ %158, %119 ]
br i1 %103, label %184, label %168
168: ; preds = %162, %168
%169 = phi i64 [ %181, %168 ], [ %165, %162 ]
%170 = phi <4 x i32> [ %179, %168 ], [ %166, %162 ]
%171 = phi <4 x i32> [ %180, %168 ], [ %167, %162 ]
%172 = phi i64 [ %182, %168 ], [ 0, %162 ]
%173 = getelementptr inbounds i32, i32* %117, i64 %169
%174 = bitcast i32* %173 to <4 x i32>*
%175 = load <4 x i32>, <4 x i32>* %174
%176 = getelementptr inbounds i32, i32* %173, i64 4
%177 = bitcast i32* %176 to <4 x i32>*
%178 = load <4 x i32>, <4 x i32>* %177
%179 = add <4 x i32> %175, %170
%180 = add <4 x i32> %178, %171
%181 = add nuw i64 %169, 8
%182 = add i64 %172, 1
%183 = icmp eq i64 %182, %100
br i1 %183, label %184, label %168
184: ; preds = %168, %162
%185 = phi <4 x i32> [ %163, %162 ], [ %179, %168 ]
%186 = phi <4 x i32> [ %164, %162 ], [ %180, %168 ]
%187 = add <4 x i32> %186, %185
%188 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %187)
br i1 %104, label %207, label %189
189: ; preds = %113, %184
%190 = phi i64 [ 0, %113 ], [ %99, %184 ]
%191 = phi i32 [ 0, %113 ], [ %188, %184 ]
br label %199
192: ; preds = %207
br i1 %4, label %193, label %380
193: ; preds = %192
%194 = add nsw i64 %3, -1
%195 = and i64 %3, 3
%196 = icmp ult i64 %194, 3
%197 = and i64 %3, 4294967292
%198 = icmp eq i64 %195, 0
br label %213
199: ; preds = %189, %199
%200 = phi i64 [ %205, %199 ], [ %190, %189 ]
%201 = phi i32 [ %204, %199 ], [ %191, %189 ]
%202 = getelementptr inbounds i32, i32* %117, 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, %3
br i1 %206, label %207, label %199
207: ; preds = %199, %184
%208 = phi i32 [ %188, %184 ], [ %204, %199 ]
%209 = icmp eq i32 %208, %92
%210 = select i1 %209, i32 %115, i32 0
%211 = add nuw nsw i64 %114, 1
%212 = icmp eq i64 %211, %3
br i1 %212, label %192, label %113
213: ; preds = %193, %264
%214 = phi i64 [ %268, %264 ], [ 0, %193 ]
%215 = phi i32 [ %267, %264 ], [ %210, %193 ]
%216 = getelementptr inbounds i32, i32* %1, i64 %214
br i1 %196, label %249, label %223
217: ; preds = %264
br i1 %4, label %218, label %380
218: ; preds = %217
%219 = and i64 %3, 3
%220 = icmp ult i64 %194, 3
br i1 %220, label %270, label %221
221: ; preds = %218
%222 = and i64 %3, 4294967292
br label %295
223: ; preds = %213, %223
%224 = phi i64 [ %246, %223 ], [ 0, %213 ]
%225 = phi i32 [ %245, %223 ], [ 0, %213 ]
%226 = phi i64 [ %247, %223 ], [ 0, %213 ]
%227 = mul nuw nsw i64 %224, %3
%228 = getelementptr inbounds i32, i32* %216, i64 %227
%229 = load i32, i32* %228
%230 = add nsw i32 %229, %225
%231 = or i64 %224, 1
%232 = mul nuw nsw i64 %231, %3
%233 = getelementptr inbounds i32, i32* %216, i64 %232
%234 = load i32, i32* %233
%235 = add nsw i32 %234, %230
%236 = or i64 %224, 2
%237 = mul nuw nsw i64 %236, %3
%238 = getelementptr inbounds i32, i32* %216, i64 %237
%239 = load i32, i32* %238
%240 = add nsw i32 %239, %235
%241 = or i64 %224, 3
%242 = mul nuw nsw i64 %241, %3
%243 = getelementptr inbounds i32, i32* %216, i64 %242
%244 = load i32, i32* %243
%245 = add nsw i32 %244, %240
%246 = add nuw nsw i64 %224, 4
%247 = add i64 %226, 4
%248 = icmp eq i64 %247, %197
br i1 %248, label %249, label %223
249: ; preds = %223, %213
%250 = phi i32 [ undef, %213 ], [ %245, %223 ]
%251 = phi i64 [ 0, %213 ], [ %246, %223 ]
%252 = phi i32 [ 0, %213 ], [ %245, %223 ]
br i1 %198, label %264, label %253
253: ; preds = %249, %253
%254 = phi i64 [ %261, %253 ], [ %251, %249 ]
%255 = phi i32 [ %260, %253 ], [ %252, %249 ]
%256 = phi i64 [ %262, %253 ], [ 0, %249 ]
%257 = mul nuw nsw i64 %254, %3
%258 = getelementptr inbounds i32, i32* %216, i64 %257
%259 = load i32, i32* %258
%260 = add nsw i32 %259, %255
%261 = add nuw nsw i64 %254, 1
%262 = add i64 %256, 1
%263 = icmp eq i64 %262, %195
br i1 %263, label %264, label %253
264: ; preds = %253, %249
%265 = phi i32 [ %250, %249 ], [ %260, %253 ]
%266 = icmp eq i32 %265, %92
%267 = select i1 %266, i32 %215, i32 0
%268 = add nuw nsw i64 %214, 1
%269 = icmp eq i64 %268, %3
br i1 %269, label %217, label %213
270: ; preds = %295, %218
%271 = phi i32 [ undef, %218 ], [ %321, %295 ]
%272 = phi i64 [ 0, %218 ], [ %322, %295 ]
%273 = phi i32 [ 0, %218 ], [ %321, %295 ]
%274 = icmp eq i64 %219, 0
br i1 %274, label %287, label %275
275: ; preds = %270, %275
%276 = phi i64 [ %284, %275 ], [ %272, %270 ]
%277 = phi i32 [ %283, %275 ], [ %273, %270 ]
%278 = phi i64 [ %285, %275 ], [ 0, %270 ]
%279 = mul nuw nsw i64 %276, %3
%280 = getelementptr inbounds i32, i32* %1, i64 %279
%281 = getelementptr inbounds i32, i32* %280, i64 %276
%282 = load i32, i32* %281
%283 = add nsw i32 %282, %277
%284 = add nuw nsw i64 %276, 1
%285 = add i64 %278, 1
%286 = icmp eq i64 %285, %219
br i1 %286, label %287, label %275
287: ; preds = %275, %270
%288 = phi i32 [ %271, %270 ], [ %283, %275 ]
br i1 %4, label %289, label %380
289: ; preds = %287
%290 = zext i32 %0 to i64
%291 = and i64 %3, 3
%292 = icmp ult i64 %194, 3
br i1 %292, label %360, label %293
293: ; preds = %289
%294 = and i64 %3, 4294967292
br label %325
295: ; preds = %295, %221
%296 = phi i64 [ 0, %221 ], [ %322, %295 ]
%297 = phi i32 [ 0, %221 ], [ %321, %295 ]
%298 = phi i64 [ 0, %221 ], [ %323, %295 ]
%299 = mul nuw nsw i64 %296, %3
%300 = getelementptr inbounds i32, i32* %1, i64 %299
%301 = getelementptr inbounds i32, i32* %300, i64 %296
%302 = load i32, i32* %301
%303 = add nsw i32 %302, %297
%304 = or i64 %296, 1
%305 = mul nuw nsw i64 %304, %3
%306 = getelementptr inbounds i32, i32* %1, i64 %305
%307 = getelementptr inbounds i32, i32* %306, i64 %304
%308 = load i32, i32* %307
%309 = add nsw i32 %308, %303
%310 = or i64 %296, 2
%311 = mul nuw nsw i64 %310, %3
%312 = getelementptr inbounds i32, i32* %1, i64 %311
%313 = getelementptr inbounds i32, i32* %312, i64 %310
%314 = load i32, i32* %313
%315 = add nsw i32 %314, %309
%316 = or i64 %296, 3
%317 = mul nuw nsw i64 %316, %3
%318 = getelementptr inbounds i32, i32* %1, i64 %317
%319 = getelementptr inbounds i32, i32* %318, i64 %316
%320 = load i32, i32* %319
%321 = add nsw i32 %320, %315
%322 = add nuw nsw i64 %296, 4
%323 = add i64 %298, 4
%324 = icmp eq i64 %323, %222
br i1 %324, label %270, label %295
325: ; preds = %325, %293
%326 = phi i64 [ 0, %293 ], [ %357, %325 ]
%327 = phi i64 [ %290, %293 ], [ %351, %325 ]
%328 = phi i32 [ 0, %293 ], [ %356, %325 ]
%329 = phi i64 [ 0, %293 ], [ %358, %325 ]
%330 = add nsw i64 %327, -1
%331 = mul nuw nsw i64 %326, %3
%332 = getelementptr inbounds i32, i32* %1, i64 %331
%333 = getelementptr inbounds i32, i32* %332, i64 %330
%334 = load i32, i32* %333
%335 = add nsw i32 %334, %328
%336 = or i64 %326, 1
%337 = add nsw i64 %327, -2
%338 = mul nuw nsw i64 %336, %3
%339 = getelementptr inbounds i32, i32* %1, i64 %338
%340 = getelementptr inbounds i32, i32* %339, i64 %337
%341 = load i32, i32* %340
%342 = add nsw i32 %341, %335
%343 = or i64 %326, 2
%344 = add nsw i64 %327, -3
%345 = mul nuw nsw i64 %343, %3
%346 = getelementptr inbounds i32, i32* %1, i64 %345
%347 = getelementptr inbounds i32, i32* %346, i64 %344
%348 = load i32, i32* %347
%349 = add nsw i32 %348, %342
%350 = or i64 %326, 3
%351 = add nsw i64 %327, -4
%352 = mul nuw nsw i64 %350, %3
%353 = getelementptr inbounds i32, i32* %1, i64 %352
%354 = getelementptr inbounds i32, i32* %353, i64 %351
%355 = load i32, i32* %354
%356 = add nsw i32 %355, %349
%357 = add nuw nsw i64 %326, 4
%358 = add i64 %329, 4
%359 = icmp eq i64 %358, %294
br i1 %359, label %360, label %325
360: ; preds = %325, %289
%361 = phi i32 [ undef, %289 ], [ %356, %325 ]
%362 = phi i64 [ 0, %289 ], [ %357, %325 ]
%363 = phi i64 [ %290, %289 ], [ %351, %325 ]
%364 = phi i32 [ 0, %289 ], [ %356, %325 ]
%365 = icmp eq i64 %291, 0
br i1 %365, label %380, label %366
366: ; preds = %360, %366
%367 = phi i64 [ %377, %366 ], [ %362, %360 ]
%368 = phi i64 [ %371, %366 ], [ %363, %360 ]
%369 = phi i32 [ %376, %366 ], [ %364, %360 ]
%370 = phi i64 [ %378, %366 ], [ 0, %360 ]
%371 = add nsw i64 %368, -1
%372 = mul nuw nsw i64 %367, %3
%373 = getelementptr inbounds i32, i32* %1, i64 %372
%374 = getelementptr inbounds i32, i32* %373, i64 %371
%375 = load i32, i32* %374
%376 = add nsw i32 %375, %369
%377 = add nuw nsw i64 %367, 1
%378 = add i64 %370, 1
%379 = icmp eq i64 %378, %291
br i1 %379, label %380, label %366
380: ; preds = %360, %366, %2, %91, %192, %217, %287
%381 = phi i32 [ %288, %287 ], [ 0, %217 ], [ 0, %192 ], [ 0, %91 ], [ 0, %2 ], [ %288, %366 ], [ %288, %360 ]
%382 = phi i32 [ %92, %287 ], [ %92, %217 ], [ %92, %192 ], [ %92, %91 ], [ 0, %2 ], [ %92, %366 ], [ %92, %360 ]
%383 = phi i32 [ %267, %287 ], [ %267, %217 ], [ %210, %192 ], [ 1, %91 ], [ 1, %2 ], [ %267, %366 ], [ %267, %360 ]
%384 = phi i32 [ 0, %287 ], [ 0, %217 ], [ 0, %192 ], [ 0, %91 ], [ 0, %2 ], [ %361, %360 ], [ %376, %366 ]
%385 = icmp eq i32 %381, %382
%386 = icmp eq i32 %384, %382
%387 = select i1 %386, i1 %385, i1 false
%388 = select i1 %387, i32 %383, i32 0
ret i32 %388
}