int isMagic(int n, int squere[n][n]) {
  int currSum = 0;
  int sum = 0;
  int i = 0;
  for (i = 0; i < n; i++) {
    int j;
    for (j = 0; j < n; j++) {
      currSum += squere[i][j];
    }
    if (i == 0) {
      sum = currSum;
    }
    if (currSum != sum) {
      return 0;
    }
    currSum = 0;
  }
  currSum = 0;
  for (i = 0; i < n; i++) {
    currSum += squere[i][i];
  }
  if (currSum != sum) {
    return 0;
  }
  currSum = 0;
  int j;
  for (i = 0, j = n - 1; i < n; i++, j--) {
    currSum += squere[i][j];
  }
  if (currSum != sum) {
    return 0;
  }
  return 1;
}


x86 assembly (clang, -O0):
<isMagic>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11bc <isMagic+0xbc>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    117f <isMagic+0x7f>
mov    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1141 <isMagic+0x41>
cmpl   $0x0,-0x1c(%rbp)
jne    118f <isMagic+0x8f>
mov    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     11a7 <isMagic+0xa7>
movl   $0x0,-0x4(%rbp)
jmp    129d <isMagic+0x19d>
movl   $0x0,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112e <isMagic+0x2e>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1208 <isMagic+0x108>
mov    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ca <isMagic+0xca>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1220 <isMagic+0x120>
movl   $0x0,-0x4(%rbp)
jmp    129d <isMagic+0x19d>
movl   $0x0,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    127e <isMagic+0x17e>
mov    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1237 <isMagic+0x137>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1296 <isMagic+0x196>
movl   $0x0,-0x4(%rbp)
jmp    129d <isMagic+0x19d>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<isMagic>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %edi,%edi
jle    12a5 <isMagic+0x1a5>
mov    %edi,%ecx
mov    %ecx,%r14d
and    $0xfffffff8,%r14d
lea    -0x8(%r14),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r11d
and    $0x3,%r11d
and    $0xfffffffffffffffc,%r10
lea    0x70(%rsi),%rbx
lea    0x0(,%rcx,4),%r8
mov    %r11,%r12
shl    $0x5,%r12
xor    %r15d,%r15d
mov    %rsi,%rax
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
cmp    $0x8,%edi
jae    1170 <isMagic+0x70>
xor    %ebp,%ebp
xor    %edx,%edx
jmp    1250 <isMagic+0x150>
xchg   %ax,%ax
pxor   %xmm0,%xmm0
cmp    $0x18,%r9
jae    1190 <isMagic+0x90>
xor    %edx,%edx
pxor   %xmm1,%xmm1
jmp    11f9 <isMagic+0xf9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r10,%rbp
xor    %edx,%edx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu -0x70(%rbx,%rdx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rbx,%rdx,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rbx,%rdx,4),%xmm1
movdqu -0x40(%rbx,%rdx,4),%xmm3
movdqu -0x30(%rbx,%rdx,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rbx,%rdx,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rbx,%rdx,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rbx,%rdx,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rbp
jne    11a0 <isMagic+0xa0>
test   %r11,%r11
je     122c <isMagic+0x12c>
lea    (%rax,%rdx,4),%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%r12
jne    1210 <isMagic+0x110>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
mov    %r14,%rbp
cmp    %rcx,%r14
je     125c <isMagic+0x15c>
xchg   %ax,%ax
add    (%rax,%rbp,4),%edx
add    $0x1,%rbp
cmp    %rbp,%rcx
jne    1250 <isMagic+0x150>
test   %r15,%r15
cmove  %edx,%r13d
cmp    %r13d,%edx
jne    12b5 <isMagic+0x1b5>
add    $0x1,%r15
add    %r8,%rbx
add    %r8,%rax
mov    %edx,%r13d
cmp    %rcx,%r15
jne    1160 <isMagic+0x60>
test   %edi,%edi
jle    12bc <isMagic+0x1bc>
lea    -0x1(%rcx),%r9
mov    %ecx,%r15d
and    $0x3,%r15d
cmp    $0x3,%r9
jae    12d2 <isMagic+0x1d2>
xor    %ebp,%ebp
xor    %ebx,%ebx
test   %r15,%r15
jne    132d <isMagic+0x22d>
jmp    134c <isMagic+0x24c>
xor    %edx,%edx
xor    %edi,%edi
xor    %eax,%eax
cmp    %edx,%edi
sete   %al
jmp    136e <isMagic+0x26e>
xor    %eax,%eax
jmp    136e <isMagic+0x26e>
xor    %edi,%edi
mov    $0x0,%eax
test   %edx,%edx
mov    $0x0,%edx
jne    136e <isMagic+0x26e>
jmp    12a9 <isMagic+0x1a9>
mov    %rcx,%r10
shl    $0x4,%r10
add    $0x10,%r10
lea    (%r8,%r8,2),%r11
mov    %ecx,%r14d
and    $0xfffffffc,%r14d
neg    %r14
xor    %ebx,%ebx
mov    $0x1,%ebp
mov    %rsi,%rax
cs nopw 0x0(%rax,%rax,1)
nop
add    (%rax),%ebx
add    0x4(%rax,%rcx,4),%ebx
add    0x8(%rax,%rcx,8),%ebx
add    0xc(%rax,%r11,1),%ebx
add    %r10,%rax
lea    (%r14,%rbp,1),%r12
add    $0x4,%r12
add    $0x4,%rbp
cmp    $0x1,%r12
jne    1300 <isMagic+0x200>
add    $0xffffffffffffffff,%rbp
test   %r15,%r15
je     134c <isMagic+0x24c>
lea    0x4(,%rcx,4),%rax
imul   %rax,%rbp
add    %rsi,%rbp
nopl   0x0(%rax)
add    0x0(%rbp),%ebx
add    %rax,%rbp
add    $0xffffffffffffffff,%r15
jne    1340 <isMagic+0x240>
xor    %eax,%eax
cmp    %edx,%ebx
jne    136e <isMagic+0x26e>
test   %edi,%edi
jle    12a7 <isMagic+0x1a7>
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%r9
jae    1379 <isMagic+0x279>
xor    %ebp,%ebp
mov    %rcx,%rbx
xor    %edi,%edi
jmp    13c4 <isMagic+0x2c4>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    (%r8,%r8,2),%r8
mov    %rcx,%r10
shl    $0x4,%r10
add    $0xfffffffffffffff0,%r10
mov    %ecx,%r9d
and    $0xfffffffc,%r9d
neg    %r9
xor    %ebp,%ebp
mov    %rsi,%rbx
xor    %edi,%edi
nopl   0x0(%rax)
add    -0x4(%rbx,%rcx,4),%edi
add    -0x8(%rbx,%rcx,8),%edi
add    -0xc(%rbx,%r8,1),%edi
add    (%rbx,%r10,1),%edi
add    %r10,%rbx
add    $0xfffffffffffffffc,%rbp
cmp    %rbp,%r9
jne    13a0 <isMagic+0x2a0>
lea    (%rcx,%rbp,1),%rbx
neg    %rbp
test   %rax,%rax
je     12a9 <isMagic+0x1a9>
imul   %rcx,%rbp
add    %rbp,%rbx
lea    (%rsi,%rbx,4),%rsi
add    $0xfffffffffffffffc,%rsi
lea    -0x4(,%rcx,4),%rcx
ff
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    (%rsi),%edi
add    %rcx,%rsi
add    $0xffffffffffffffff,%rax
jne    13f0 <isMagic+0x2f0>
jmp    12a9 <isMagic+0x1a9>

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

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