int is_magic(int n, int (*sqr)[n]) {
  int i = 0, j;
  int sum = 0, tmp = 0;
  for (i = 0; i < n; i++)
    sum += sqr[i][i];
  for (j = n - 1, i = 0; i < n; i++, j--) {
    tmp += sqr[i][i];
  }
  if (sum != tmp)
    return 0;
  sum = 0;
  for (i = 0; i < n; i++)
    sum += sqr[0][i];
  if (sum != tmp)
    return 0;
  sum = 0;
  for (i = 0; i < n; i++)
    sum += sqr[i][0];
  if (sum != tmp)
    return 0;
  return 1;
}


x86 assembly (clang, -O0):
<is_magic>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    116c <is_magic+0x6c>
mov    -0x28(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    112e <is_magic+0x2e>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11c3 <is_magic+0xc3>
mov    -0x28(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    117c <is_magic+0x7c>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     11db <is_magic+0xdb>
movl   $0x0,-0x4(%rbp)
jmp    129b <is_magic+0x19b>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1223 <is_magic+0x123>
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
imul   $0x0,%rcx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11e9 <is_magic+0xe9>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     123b <is_magic+0x13b>
movl   $0x0,-0x4(%rbp)
jmp    129b <is_magic+0x19b>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    127c <is_magic+0x17c>
mov    -0x28(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   %rdx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1249 <is_magic+0x149>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
je     1294 <is_magic+0x194>
movl   $0x0,-0x4(%rbp)
jmp    129b <is_magic+0x19b>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<is_magic>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %edi,%edi
jle    112b <is_magic+0x2b>
mov    %edi,%r10d
lea    -0x1(%r10),%r8
mov    %r10d,%eax
and    $0x3,%eax
cmp    $0x3,%r8
jae    113b <is_magic+0x3b>
xor    %ecx,%ecx
xor    %ebp,%ebp
test   %rax,%rax
jne    119f <is_magic+0x9f>
jmp    11bb <is_magic+0xbb>
xor    %ebp,%ebp
xor    %edi,%edi
xor    %eax,%eax
cmp    %ebp,%edi
sete   %al
jmp    13ac <is_magic+0x2ac>
mov    %r10,%r9
shl    $0x4,%r9
add    $0x10,%r9
lea    0x0(,%r10,4),%rcx
lea    (%rcx,%rcx,2),%r11
mov    %r10d,%r14d
and    $0xfffffffc,%r14d
neg    %r14
xor    %ebp,%ebp
mov    $0x1,%ecx
mov    %rsi,%rbx
cs nopw 0x0(%rax,%rax,1)
add    (%rbx),%ebp
add    0x4(%rbx,%r10,4),%ebp
add    0x8(%rbx,%r10,8),%ebp
add    0xc(%rbx,%r11,1),%ebp
add    %r9,%rbx
lea    (%r14,%rcx,1),%rdx
add    $0x4,%rdx
add    $0x4,%rcx
cmp    $0x1,%rdx
jne    1170 <is_magic+0x70>
add    $0xffffffffffffffff,%rcx
test   %rax,%rax
je     11bb <is_magic+0xbb>
lea    0x4(,%r10,4),%rbx
imul   %rbx,%rcx
add    %rsi,%rcx
xchg   %ax,%ax
add    (%rcx),%ebp
add    %rbx,%rcx
add    $0xffffffffffffffff,%rax
jne    11b0 <is_magic+0xb0>
test   %edi,%edi
jle    11da <is_magic+0xda>
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%r8
jae    11f3 <is_magic+0xf3>
xor    %eax,%eax
xor    %ecx,%ecx
test   %r9,%r9
jne    124f <is_magic+0x14f>
jmp    126b <is_magic+0x16b>
xor    %ecx,%ecx
mov    $0x0,%eax
test   %ebp,%ebp
mov    $0x0,%ebp
jne    13ac <is_magic+0x2ac>
jmp    138c <is_magic+0x28c>
mov    %r10,%r11
shl    $0x4,%r11
add    $0x10,%r11
lea    0x0(,%r10,4),%rax
lea    (%rax,%rax,2),%r14
mov    %r10d,%r15d
and    $0xfffffffc,%r15d
neg    %r15
xor    %ecx,%ecx
mov    $0x1,%eax
mov    %rsi,%rbx
xchg   %ax,%ax
add    (%rbx),%ecx
add    0x4(%rbx,%r10,4),%ecx
add    0x8(%rbx,%r10,8),%ecx
add    0xc(%rbx,%r14,1),%ecx
add    %r11,%rbx
lea    (%r15,%rax,1),%rdx
add    $0x4,%rdx
add    $0x4,%rax
cmp    $0x1,%rdx
jne    1220 <is_magic+0x120>
add    $0xffffffffffffffff,%rax
test   %r9,%r9
je     126b <is_magic+0x16b>
lea    0x4(,%r10,4),%rbx
imul   %rbx,%rax
add    %rsi,%rax
xchg   %ax,%ax
add    (%rax),%ecx
add    %rbx,%rax
add    $0xffffffffffffffff,%r9
jne    1260 <is_magic+0x160>
xor    %eax,%eax
cmp    %ecx,%ebp
jne    13ac <is_magic+0x2ac>
test   %edi,%edi
jle    1287 <is_magic+0x187>
cmp    $0x8,%edi
jae    128e <is_magic+0x18e>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    1380 <is_magic+0x280>
xor    %ecx,%ecx
jmp    138c <is_magic+0x28c>
mov    %r10d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rcx
jae    12bc <is_magic+0x1bc>
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
jmp    1329 <is_magic+0x229>
and    $0xfffffffffffffffc,%r11
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movdqu (%rsi,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rsi,%rcx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rsi,%rcx,4),%xmm1
movdqu 0x30(%rsi,%rcx,4),%xmm3
movdqu 0x40(%rsi,%rcx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rsi,%rcx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rsi,%rcx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rsi,%rcx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rcx
add    $0xfffffffffffffffc,%r11
jne    12d0 <is_magic+0x1d0>
test   %r9,%r9
je     135c <is_magic+0x25c>
lea    (%rsi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %ebx,%ebx
nopl   0x0(%rax)
movdqu -0x10(%rcx,%rbx,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rcx,%rbx,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1340 <is_magic+0x240>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
cmp    %r10,%rax
je     138c <is_magic+0x28c>
nopl   0x0(%rax,%rax,1)
add    (%rsi,%rax,4),%ecx
add    $0x1,%rax
cmp    %rax,%r10
jne    1380 <is_magic+0x280>
xor    %eax,%eax
cmp    %ebp,%ecx
jne    13ac <is_magic+0x2ac>
test   %edi,%edi
jle    112d <is_magic+0x2d>
mov    %r10d,%eax
and    $0x3,%eax
cmp    $0x3,%r8
jae    13b3 <is_magic+0x2b3>
xor    %ecx,%ecx
xor    %edi,%edi
jmp    13fa <is_magic+0x2fa>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r10d,%r8d
and    $0xfffffffc,%r8d
mov    %r10,%r11
shl    $0x4,%r11
lea    0x0(,%r10,4),%rcx
lea    (%rcx,%rcx,2),%r9
xor    %ecx,%ecx
mov    %rsi,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    (%rbx),%edi
add    (%rbx,%r10,4),%edi
add    (%rbx,%r10,8),%edi
add    (%rbx,%r9,1),%edi
add    $0x4,%rcx
add    %r11,%rbx
cmp    %rcx,%r8
jne    13e0 <is_magic+0x2e0>
test   %rax,%rax
je     112f <is_magic+0x2f>
imul   %r10,%rcx
lea    (%rsi,%rcx,4),%rcx
shl    $0x2,%r10
nop
add    (%rcx),%edi
add    %r10,%rcx
add    $0xffffffffffffffff,%rax
jne    1410 <is_magic+0x310>
jmp    112f <is_magic+0x2f>

LLVM IR (-O0):
define i32 @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
store i32 %0, i32* %4
store i32* %1, i32** %5
%10 = load i32, i32* %4
%11 = zext i32 %10 to i64
store i32 0, i32* %6
store i32 0, i32* %8
store i32 0, i32* %9
store i32 0, i32* %6
br label %12
12: ; preds = %28, %2
%13 = load i32, i32* %6
%14 = load i32, i32* %4
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %31
16: ; preds = %12
%17 = load i32*, i32** %5
%18 = load i32, i32* %6
%19 = sext i32 %18 to i64
%20 = mul nsw i64 %19, %11
%21 = getelementptr inbounds i32, i32* %17, i64 %20
%22 = load i32, i32* %6
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %21, i64 %23
%25 = load i32, i32* %24
%26 = load i32, i32* %8
%27 = add nsw i32 %26, %25
store i32 %27, i32* %8
br label %28
28: ; preds = %16
%29 = load i32, i32* %6
%30 = add nsw i32 %29, 1
store i32 %30, i32* %6
br label %12
31: ; preds = %12
%32 = load i32, i32* %4
%33 = sub nsw i32 %32, 1
store i32 %33, i32* %7
store i32 0, i32* %6
br label %34
34: ; preds = %50, %31
%35 = load i32, i32* %6
%36 = load i32, i32* %4
%37 = icmp slt i32 %35, %36
br i1 %37, label %38, label %55
38: ; preds = %34
%39 = load i32*, i32** %5
%40 = load i32, i32* %6
%41 = sext i32 %40 to i64
%42 = mul nsw i64 %41, %11
%43 = getelementptr inbounds i32, i32* %39, i64 %42
%44 = load i32, i32* %6
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %43, i64 %45
%47 = load i32, i32* %46
%48 = load i32, i32* %9
%49 = add nsw i32 %48, %47
store i32 %49, i32* %9
br label %50
50: ; preds = %38
%51 = load i32, i32* %6
%52 = add nsw i32 %51, 1
store i32 %52, i32* %6
%53 = load i32, i32* %7
%54 = add nsw i32 %53, -1
store i32 %54, i32* %7
br label %34
55: ; preds = %34
%56 = load i32, i32* %8
%57 = load i32, i32* %9
%58 = icmp ne i32 %56, %57
br i1 %58, label %59, label %60
59: ; preds = %55
store i32 0, i32* %3
br label %107
60: ; preds = %55
store i32 0, i32* %8
store i32 0, i32* %6
br label %61
61: ; preds = %75, %60
%62 = load i32, i32* %6
%63 = load i32, i32* %4
%64 = icmp slt i32 %62, %63
br i1 %64, label %65, label %78
65: ; preds = %61
%66 = load i32*, i32** %5
%67 = mul nsw i64 0, %11
%68 = getelementptr inbounds i32, i32* %66, i64 %67
%69 = load i32, i32* %6
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %68, i64 %70
%72 = load i32, i32* %71
%73 = load i32, i32* %8
%74 = add nsw i32 %73, %72
store i32 %74, i32* %8
br label %75
75: ; preds = %65
%76 = load i32, i32* %6
%77 = add nsw i32 %76, 1
store i32 %77, i32* %6
br label %61
78: ; preds = %61
%79 = load i32, i32* %8
%80 = load i32, i32* %9
%81 = icmp ne i32 %79, %80
br i1 %81, label %82, label %83
82: ; preds = %78
store i32 0, i32* %3
br label %107
83: ; preds = %78
store i32 0, i32* %8
store i32 0, i32* %6
br label %84
84: ; preds = %98, %83
%85 = load i32, i32* %6
%86 = load i32, i32* %4
%87 = icmp slt i32 %85, %86
br i1 %87, label %88, label %101
88: ; preds = %84
%89 = load i32*, i32** %5
%90 = load i32, i32* %6
%91 = sext i32 %90 to i64
%92 = mul nsw i64 %91, %11
%93 = getelementptr inbounds i32, i32* %89, i64 %92
%94 = getelementptr inbounds i32, i32* %93, i64 0
%95 = load i32, i32* %94
%96 = load i32, i32* %8
%97 = add nsw i32 %96, %95
store i32 %97, i32* %8
br label %98
98: ; preds = %88
%99 = load i32, i32* %6
%100 = add nsw i32 %99, 1
store i32 %100, i32* %6
br label %84
101: ; preds = %84
%102 = load i32, i32* %8
%103 = load i32, i32* %9
%104 = icmp ne i32 %102, %103
br i1 %104, label %105, label %106
105: ; preds = %101
store i32 0, i32* %3
br label %107
106: ; preds = %101
store i32 1, i32* %3
br label %107
107: ; preds = %106, %105, %82, %59
%108 = load i32, i32* %3
ret i32 %108
}

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