int func(int n, int square[n][n]) {
  int i, a, b, h;
  a = 0;
  b = 0;
  for (h = 0; h < n; h++) {
    a = a + square[0][h];
  }
  for (i = 0; i < n; i++) {
    for (h = 0; h < n; h++) {
      b = b + square[i][h];
    }
    if (a != b) {
      return 0;
    } else {
      b = 0;
    }
  }
  for (i = 0; i < n; i++) {
    for (h = 0; h < n; h++) {
      b = b + square[h][i];
    }
    if (a != b) {
      return 0;
    } else {
      b = 0;
    }
  }
  for (i = 0; i < n; i++) {
    b = b + square[i][i];
  }
  if (a != b) {
    return 0;
  } else {
    b = 0;
  }
  for (i = 0; i < n; i++) {
    b = b + square[i][n - (i + 1)];
  }
  if (a != b) {
    return 0;
  } else {
    b = 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<func>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1161 <func+0x61>
mov    -0x28(%rbp),%rdx
mov    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
imul   $0x0,%rdx,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1127 <func+0x27>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11eb <func+0xeb>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11b9 <func+0xb9>
mov    -0x28(%rbp),%rsi
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x20(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    117b <func+0x7b>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     11d1 <func+0xd1>
movl   $0x0,-0x4(%rbp)
jmp    134e <func+0x24e>
movl   $0x0,-0x1c(%rbp)
jmp    11dd <func+0xdd>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1168 <func+0x68>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1275 <func+0x175>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1243 <func+0x143>
mov    -0x28(%rbp),%rsi
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x20(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1205 <func+0x105>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     125b <func+0x15b>
movl   $0x0,-0x4(%rbp)
jmp    134e <func+0x24e>
movl   $0x0,-0x1c(%rbp)
jmp    1267 <func+0x167>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11f2 <func+0xf2>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12ba <func+0x1ba>
mov    -0x28(%rbp),%rsi
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
movslq -0x14(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    127c <func+0x17c>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     12d2 <func+0x1d2>
movl   $0x0,-0x4(%rbp)
jmp    134e <func+0x24e>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1328 <func+0x228>
mov    -0x28(%rbp),%rsi
mov    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x14(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%edx
mov    -0x14(%rbp),%esi
add    $0x1,%esi
sub    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12e0 <func+0x1e0>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
je     1340 <func+0x240>
movl   $0x0,-0x4(%rbp)
jmp    134e <func+0x24e>
movl   $0x0,-0x1c(%rbp)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<func>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    111f <func+0x1f>
mov    %edi,%ecx
cmp    $0x8,%edi
jae    1131 <func+0x31>
xor    %eax,%eax
xor    %r8d,%r8d
jmp    1220 <func+0x120>
xor    %r8d,%r8d
xor    %edx,%edx
xor    %eax,%eax
cmp    %edx,%r8d
sete   %al
jmp    1501 <func+0x401>
mov    %ecx,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rbp
mov    %rbp,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x18,%rbp
jae    115e <func+0x5e>
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
jmp    11c9 <func+0xc9>
and    $0xfffffffffffffffc,%rdx
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu (%rsi,%rbx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rsi,%rbx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rsi,%rbx,4),%xmm1
movdqu 0x30(%rsi,%rbx,4),%xmm3
movdqu 0x40(%rsi,%rbx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rsi,%rbx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rsi,%rbx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rsi,%rbx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdx
jne    1170 <func+0x70>
test   %r8,%r8
je     11fc <func+0xfc>
lea    (%rsi,%rbx,4),%rdx
add    $0x10,%rdx
shl    $0x5,%r8
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,%r8
jne    11e0 <func+0xe0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r8d
cmp    %rcx,%rax
je     122d <func+0x12d>
nopl   0x0(%rax)
add    (%rsi,%rax,4),%r8d
add    $0x1,%rax
cmp    %rax,%rcx
jne    1220 <func+0x120>
xor    %eax,%eax
mov    $0x0,%ebx
test   %edi,%edi
jle    14dc <func+0x3dc>
mov    %ecx,%r9d
and    $0xfffffff8,%r9d
lea    -0x8(%r9),%r10
mov    %r10,-0x8(%rsp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%r10
lea    0x70(%rsi),%rbx
lea    0x0(,%rcx,4),%r15
mov    %r14,%r13
shl    $0x5,%r13
xor    %r12d,%r12d
mov    %rsi,%rdx
nopl   0x0(%rax,%rax,1)
cmp    $0x8,%edi
jae    1290 <func+0x190>
xor    %eax,%eax
xor    %ebp,%ebp
jmp    1370 <func+0x270>
xchg   %ax,%ax
cmpq   $0x18,-0x8(%rsp)
jae    12b0 <func+0x1b0>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    1319 <func+0x219>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
pxor   %xmm0,%xmm0
mov    %r10,%r11
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopl   (%rax)
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,%r11
jne    12c0 <func+0x1c0>
test   %r14,%r14
je     134c <func+0x24c>
lea    (%rdx,%rbp,4),%rax
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rax,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rax,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%r13
jne    1330 <func+0x230>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
mov    %r9,%rax
cmp    %rcx,%r9
je     137c <func+0x27c>
xchg   %ax,%ax
add    (%rdx,%rax,4),%ebp
add    $0x1,%rax
cmp    %rax,%rcx
jne    1370 <func+0x270>
cmp    %ebp,%r8d
jne    145d <func+0x35d>
add    $0x1,%r12
add    %r15,%rbx
add    %r15,%rdx
cmp    %rcx,%r12
jne    1280 <func+0x180>
test   %edi,%edi
jle    1464 <func+0x364>
mov    %edi,-0x8(%rsp)
lea    -0x1(%rcx),%r9
mov    %ecx,%r10d
and    $0x3,%r10d
mov    %ecx,%ebx
and    $0xfffffffc,%ebx
mov    %rcx,%r13
shl    $0x4,%r13
lea    (%r15,%r15,2),%r11
xor    %r14d,%r14d
mov    %rsi,%r12
cs nopw 0x0(%rax,%rax,1)
nop
xor    %eax,%eax
cmp    $0x3,%r9
jae    13e0 <func+0x2e0>
xor    %ebp,%ebp
jmp    1408 <func+0x308>
nopl   0x0(%rax)
mov    %r12,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
add    (%rdx),%ebp
add    (%rdx,%rcx,4),%ebp
add    (%rdx,%rcx,8),%ebp
add    (%rdx,%r11,1),%ebp
add    $0x4,%rax
add    %r13,%rdx
cmp    %rax,%rbx
jne    13f0 <func+0x2f0>
test   %r10,%r10
je     142b <func+0x32b>
imul   %rcx,%rax
lea    (%r12,%rax,4),%rax
mov    %r10,%rdx
nopl   0x0(%rax,%rax,1)
add    (%rax),%ebp
add    %r15,%rax
add    $0xffffffffffffffff,%rdx
jne    1420 <func+0x320>
cmp    %ebp,%r8d
jne    145d <func+0x35d>
add    $0x1,%r14
add    $0x4,%r12
cmp    %rcx,%r14
jne    13d0 <func+0x2d0>
cmpl   $0x0,-0x8(%rsp)
mov    $0x0,%eax
jle    146a <func+0x36a>
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0x3,%r9
jae    1472 <func+0x372>
xor    %r9d,%r9d
xor    %ebx,%ebx
jmp    14b8 <func+0x3b8>
xor    %eax,%eax
jmp    1501 <func+0x401>
xor    %ebx,%ebx
xor    %eax,%eax
jmp    14dc <func+0x3dc>
xor    %ebx,%ebx
mov    -0x8(%rsp),%edi
jmp    14dc <func+0x3dc>
add    $0x10,%r13
mov    %ecx,%ebp
and    $0xfffffffc,%ebp
neg    %rbp
xor    %ebx,%ebx
mov    $0x1,%r9d
mov    %rsi,%rdx
nopl   0x0(%rax)
add    (%rdx),%ebx
add    0x4(%rdx,%rcx,4),%ebx
add    0x8(%rdx,%rcx,8),%ebx
add    0xc(%rdx,%r11,1),%ebx
add    %r13,%rdx
lea    (%r9,%rbp,1),%rdi
add    $0x4,%rdi
add    $0x4,%r9
cmp    $0x1,%rdi
jne    1490 <func+0x390>
add    $0xffffffffffffffff,%r9
test   %r10,%r10
mov    -0x8(%rsp),%edi
je     14dc <func+0x3dc>
lea    0x4(,%rcx,4),%rdx
imul   %rdx,%r9
add    %rsi,%r9
add    (%r9),%ebx
add    %rdx,%r9
add    $0xffffffffffffffff,%r10
jne    14d0 <func+0x3d0>
cmp    %ebx,%r8d
jne    1501 <func+0x401>
test   %edi,%edi
jle    1122 <func+0x22>
lea    -0x1(%rcx),%rax
mov    %ecx,%r11d
and    $0x3,%r11d
cmp    $0x3,%rax
jae    150c <func+0x40c>
xor    %r14d,%r14d
xor    %edx,%edx
jmp    1571 <func+0x471>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ecx,%r9d
and    $0xfffffffc,%r9d
lea    -0x8(,%rcx,8),%rbx
ff
mov    %rcx,%r10
shl    $0x4,%r10
add    $0xfffffffffffffff0,%r10
lea    (%rcx,%rcx,2),%rax
lea    -0xc(,%rax,4),%rbp
ff
lea    -0x4(,%rcx,4),%rax
ff
xor    %r14d,%r14d
mov    %r10,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    (%rsi,%rax,1),%edx
add    (%rsi,%rbx,1),%edx
add    (%rsi,%rbp,1),%edx
add    $0x4,%r14
add    (%rsi,%rdi,1),%edx
add    %r10,%rbx
add    %r10,%rbp
add    %r10,%rax
add    %r10,%rdi
cmp    %r14,%r9
jne    1550 <func+0x450>
test   %r11,%r11
je     1124 <func+0x24>
lea    0x1(%r14),%rax
imul   %rcx,%rax
sub    %r14,%rax
lea    (%rsi,%rax,4),%rax
add    $0xfffffffffffffffc,%rax
lea    -0x4(,%rcx,4),%rcx
ff
cs nopw 0x0(%rax,%rax,1)
nop
add    (%rax),%edx
add    %rcx,%rax
add    $0xffffffffffffffff,%r11
jne    15a0 <func+0x4a0>
jmp    1124 <func+0x24>

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

LLVM IR (-O2):
define i32 @func(i32 %0, i32* nocapture %1) {
%3 = zext i32 %0 to i64
%4 = icmp sgt i32 %0, 0
br i1 %4, label %5, label %378
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 %315
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 %115
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 = %208
%114 = icmp eq i64 %211, %3
br i1 %114, label %193, label %115
115: ; preds = %93, %113
%116 = phi i64 [ %211, %113 ], [ 0, %93 ]
%117 = mul nuw nsw i64 %116, %3
%118 = getelementptr inbounds i32, i32* %1, i64 %117
br i1 %98, label %190, label %119
119: ; preds = %115
br i1 %101, 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 i32, i32* %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 i32, i32* %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 i32, i32* %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 i32, i32* %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, %102
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 %103, 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 i32, i32* %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, %100
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 %104, label %208, label %190
190: ; preds = %115, %185
%191 = phi i64 [ 0, %115 ], [ %99, %185 ]
%192 = phi i32 [ 0, %115 ], [ %189, %185 ]
br label %200
193: ; preds = %113
br i1 %4, label %194, label %315
194: ; preds = %193
%195 = add nsw i64 %3, -1
%196 = and i64 %3, 3
%197 = icmp ult i64 %195, 3
%198 = and i64 %3, 4294967292
%199 = icmp eq i64 %196, 0
br label %214
200: ; preds = %190, %200
%201 = phi i64 [ %206, %200 ], [ %191, %190 ]
%202 = phi i32 [ %205, %200 ], [ %192, %190 ]
%203 = getelementptr inbounds i32, i32* %118, i64 %201
%204 = load i32, i32* %203
%205 = add nsw i32 %204, %202
%206 = add nuw nsw i64 %201, 1
%207 = icmp eq i64 %206, %3
br i1 %207, label %208, label %200
208: ; preds = %200, %185
%209 = phi i32 [ %189, %185 ], [ %205, %200 ]
%210 = icmp eq i32 %92, %209
%211 = add nuw nsw i64 %116, 1
br i1 %210, label %113, label %383
212: ; preds = %264
%213 = icmp eq i64 %267, %3
br i1 %213, label %217, label %214
214: ; preds = %194, %212
%215 = phi i64 [ %267, %212 ], [ 0, %194 ]
%216 = getelementptr inbounds i32, i32* %1, i64 %215
br i1 %197, label %249, label %223
217: ; preds = %212
br i1 %4, label %218, label %315
218: ; preds = %217
%219 = and i64 %3, 3
%220 = icmp ult i64 %195, 3
br i1 %220, label %298, label %221
221: ; preds = %218
%222 = and i64 %3, 4294967292
br label %268
223: ; preds = %214, %223
%224 = phi i64 [ %246, %223 ], [ 0, %214 ]
%225 = phi i32 [ %245, %223 ], [ 0, %214 ]
%226 = phi i64 [ %247, %223 ], [ 0, %214 ]
%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, %198
br i1 %248, label %249, label %223
249: ; preds = %223, %214
%250 = phi i32 [ undef, %214 ], [ %245, %223 ]
%251 = phi i64 [ 0, %214 ], [ %246, %223 ]
%252 = phi i32 [ 0, %214 ], [ %245, %223 ]
br i1 %199, 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, %196
br i1 %263, label %264, label %253
264: ; preds = %253, %249
%265 = phi i32 [ %250, %249 ], [ %260, %253 ]
%266 = icmp eq i32 %92, %265
%267 = add nuw nsw i64 %215, 1
br i1 %266, label %212, label %383
268: ; preds = %268, %221
%269 = phi i64 [ 0, %221 ], [ %295, %268 ]
%270 = phi i32 [ 0, %221 ], [ %294, %268 ]
%271 = phi i64 [ 0, %221 ], [ %296, %268 ]
%272 = mul nuw nsw i64 %269, %3
%273 = getelementptr inbounds i32, i32* %1, i64 %272
%274 = getelementptr inbounds i32, i32* %273, i64 %269
%275 = load i32, i32* %274
%276 = add nsw i32 %275, %270
%277 = or i64 %269, 1
%278 = mul nuw nsw i64 %277, %3
%279 = getelementptr inbounds i32, i32* %1, i64 %278
%280 = getelementptr inbounds i32, i32* %279, i64 %277
%281 = load i32, i32* %280
%282 = add nsw i32 %281, %276
%283 = or i64 %269, 2
%284 = mul nuw nsw i64 %283, %3
%285 = getelementptr inbounds i32, i32* %1, i64 %284
%286 = getelementptr inbounds i32, i32* %285, i64 %283
%287 = load i32, i32* %286
%288 = add nsw i32 %287, %282
%289 = or i64 %269, 3
%290 = mul nuw nsw i64 %289, %3
%291 = getelementptr inbounds i32, i32* %1, i64 %290
%292 = getelementptr inbounds i32, i32* %291, i64 %289
%293 = load i32, i32* %292
%294 = add nsw i32 %293, %288
%295 = add nuw nsw i64 %269, 4
%296 = add i64 %271, 4
%297 = icmp eq i64 %296, %222
br i1 %297, label %298, label %268
298: ; preds = %268, %218
%299 = phi i32 [ undef, %218 ], [ %294, %268 ]
%300 = phi i64 [ 0, %218 ], [ %295, %268 ]
%301 = phi i32 [ 0, %218 ], [ %294, %268 ]
%302 = icmp eq i64 %219, 0
br i1 %302, label %315, label %303
303: ; preds = %298, %303
%304 = phi i64 [ %312, %303 ], [ %300, %298 ]
%305 = phi i32 [ %311, %303 ], [ %301, %298 ]
%306 = phi i64 [ %313, %303 ], [ 0, %298 ]
%307 = mul nuw nsw i64 %304, %3
%308 = getelementptr inbounds i32, i32* %1, i64 %307
%309 = getelementptr inbounds i32, i32* %308, i64 %304
%310 = load i32, i32* %309
%311 = add nsw i32 %310, %305
%312 = add nuw nsw i64 %304, 1
%313 = add i64 %306, 1
%314 = icmp eq i64 %313, %219
br i1 %314, label %315, label %303
315: ; preds = %298, %303, %91, %193, %217
%316 = phi i32 [ 0, %217 ], [ 0, %193 ], [ 0, %91 ], [ %299, %298 ], [ %311, %303 ]
%317 = icmp eq i32 %92, %316
br i1 %317, label %318, label %383
318: ; preds = %315
br i1 %4, label %319, label %378
319: ; preds = %318
%320 = zext i32 %0 to i64
%321 = add nsw i64 %3, -1
%322 = and i64 %3, 3
%323 = icmp ult i64 %321, 3
br i1 %323, label %360, label %324
324: ; preds = %319
%325 = and i64 %3, 4294967292
br label %326
326: ; preds = %326, %324
%327 = phi i64 [ 0, %324 ], [ %353, %326 ]
%328 = phi i32 [ 0, %324 ], [ %357, %326 ]
%329 = phi i64 [ 0, %324 ], [ %358, %326 ]
%330 = mul nuw nsw i64 %327, %3
%331 = getelementptr inbounds i32, i32* %1, i64 %330
%332 = or i64 %327, 1
%333 = sub nsw i64 %320, %332
%334 = getelementptr inbounds i32, i32* %331, i64 %333
%335 = load i32, i32* %334
%336 = add nsw i32 %335, %328
%337 = mul nuw nsw i64 %332, %3
%338 = getelementptr inbounds i32, i32* %1, i64 %337
%339 = or i64 %327, 2
%340 = sub nsw i64 %320, %339
%341 = getelementptr inbounds i32, i32* %338, i64 %340
%342 = load i32, i32* %341
%343 = add nsw i32 %342, %336
%344 = mul nuw nsw i64 %339, %3
%345 = getelementptr inbounds i32, i32* %1, i64 %344
%346 = or i64 %327, 3
%347 = sub nsw i64 %320, %346
%348 = getelementptr inbounds i32, i32* %345, i64 %347
%349 = load i32, i32* %348
%350 = add nsw i32 %349, %343
%351 = mul nuw nsw i64 %346, %3
%352 = getelementptr inbounds i32, i32* %1, i64 %351
%353 = add nuw nsw i64 %327, 4
%354 = sub nsw i64 %320, %353
%355 = getelementptr inbounds i32, i32* %352, i64 %354
%356 = load i32, i32* %355
%357 = add nsw i32 %356, %350
%358 = add i64 %329, 4
%359 = icmp eq i64 %358, %325
br i1 %359, label %360, label %326
360: ; preds = %326, %319
%361 = phi i32 [ undef, %319 ], [ %357, %326 ]
%362 = phi i64 [ 0, %319 ], [ %353, %326 ]
%363 = phi i32 [ 0, %319 ], [ %357, %326 ]
%364 = icmp eq i64 %322, 0
br i1 %364, label %378, label %365
365: ; preds = %360, %365
%366 = phi i64 [ %371, %365 ], [ %362, %360 ]
%367 = phi i32 [ %375, %365 ], [ %363, %360 ]
%368 = phi i64 [ %376, %365 ], [ 0, %360 ]
%369 = mul nuw nsw i64 %366, %3
%370 = getelementptr inbounds i32, i32* %1, i64 %369
%371 = add nuw nsw i64 %366, 1
%372 = sub nsw i64 %320, %371
%373 = getelementptr inbounds i32, i32* %370, i64 %372
%374 = load i32, i32* %373
%375 = add nsw i32 %374, %367
%376 = add i64 %368, 1
%377 = icmp eq i64 %376, %322
br i1 %377, label %378, label %365
378: ; preds = %360, %365, %2, %318
%379 = phi i32 [ %92, %318 ], [ 0, %2 ], [ %92, %365 ], [ %92, %360 ]
%380 = phi i32 [ 0, %318 ], [ 0, %2 ], [ %361, %360 ], [ %375, %365 ]
%381 = icmp eq i32 %379, %380
%382 = zext i1 %381 to i32
br label %383
383: ; preds = %208, %264, %378, %315
%384 = phi i32 [ 0, %315 ], [ %382, %378 ], [ 0, %264 ], [ 0, %208 ]
ret i32 %384
}