#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  int row, sym, entn;
  int arr[999][999], sum[999], count, rcount;
  row = 0;
  scanf("%d", &entn);
  do {
    sym = 0;
    row++;
    do {
      sym++;
      scanf("%d", &arr[row][sym]);
    } while (sym < entn);
  } while (row < entn);
  row = 0;
  count = 0;
  do {
    row++;
    count++;
    sum[count] = 0;
    sym = 0;
    do {
      sym++;
      sum[count] = sum[count] + arr[row][sym];
    } while (sym < entn);
  } while (row < entn);
  count++;
  row = 0;
  sym = 0;
  sum[count] = 0;
  do {
    row++;
    sym++;
    sum[count] = sum[count] + arr[row][sym];
  } while (row < entn);
  sym = 0;
  count++;
  sum[count] = 0;
  do {
    sym++;
    sum[count] = sum[count] + arr[row][sym];
    row = row - 1;
  } while (row > 0);
  do {
    if (sum[1] == sum[count]) {
      rcount = rcount + 1;
    } else {
      rcount = rcount + 0;
    }
    count = count - 1;
  } while (count > 0);
  if (rcount == entn + 2) {
    printf("Magic\n");
  } else {
    printf("No magic\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3cf990,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
lea    0xec0(%rip),%rdi
lea    -0x10(%rbp),%rsi
call   1040 <scanf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
movslq -0x8(%rbp),%rax
lea    -0x3ce9e0(%rbp),%rsi
imul   $0xf9c,%rax,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xe77(%rip),%rdi
call   1040 <scanf@plt>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     1159 <main+0x39>
jmp    119f <main+0x7f>
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     1149 <main+0x29>
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0x3cf984(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x3cf984(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3cf984(%rbp)
movslq -0x3cf984(%rbp),%rax
movl   $0x0,-0x3cf980(%rbp,%rax,4)
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
movslq -0x3cf984(%rbp),%rax
mov    -0x3cf980(%rbp,%rax,4),%ecx
movslq -0x8(%rbp),%rdx
lea    -0x3ce9e0(%rbp),%rax
imul   $0xf9c,%rdx,%rdx
add    %rdx,%rax
movslq -0xc(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
movslq -0x3cf984(%rbp),%rax
mov    %ecx,-0x3cf980(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     11ed <main+0xcd>
jmp    123f <main+0x11f>
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     11bc <main+0x9c>
mov    -0x3cf984(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3cf984(%rbp)
movl   $0x0,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
movslq -0x3cf984(%rbp),%rax
movl   $0x0,-0x3cf980(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
movslq -0x3cf984(%rbp),%rax
mov    -0x3cf980(%rbp,%rax,4),%ecx
movslq -0x8(%rbp),%rdx
lea    -0x3ce9e0(%rbp),%rax
imul   $0xf9c,%rdx,%rdx
add    %rdx,%rax
movslq -0xc(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
movslq -0x3cf984(%rbp),%rax
mov    %ecx,-0x3cf980(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
cmp    -0x10(%rbp),%eax
jl     127a <main+0x15a>
movl   $0x0,-0xc(%rbp)
mov    -0x3cf984(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3cf984(%rbp)
movslq -0x3cf984(%rbp),%rax
movl   $0x0,-0x3cf980(%rbp,%rax,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
movslq -0x3cf984(%rbp),%rax
mov    -0x3cf980(%rbp,%rax,4),%ecx
movslq -0x8(%rbp),%rdx
lea    -0x3ce9e0(%rbp),%rax
imul   $0xf9c,%rdx,%rdx
add    %rdx,%rax
movslq -0xc(%rbp),%rdx
add    (%rax,%rdx,4),%ecx
movslq -0x3cf984(%rbp),%rax
mov    %ecx,-0x3cf980(%rbp,%rax,4)
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x8(%rbp)
cmpl   $0x0,-0x8(%rbp)
jg     12f8 <main+0x1d8>
jmp    1351 <main+0x231>
mov    -0x3cf97c(%rbp),%eax
movslq -0x3cf984(%rbp),%rcx
cmp    -0x3cf980(%rbp,%rcx,4),%eax
jne    137f <main+0x25f>
mov    -0x3cf988(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3cf988(%rbp)
jmp    138e <main+0x26e>
mov    -0x3cf988(%rbp),%eax
add    $0x0,%eax
mov    %eax,-0x3cf988(%rbp)
mov    -0x3cf984(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3cf984(%rbp)
cmpl   $0x0,-0x3cf984(%rbp)
jg     1351 <main+0x231>
mov    -0x3cf988(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jne    13cf <main+0x2af>
lea    0xc3e(%rip),%rdi
call   1030 <printf@plt>
jmp    13db <main+0x2bb>
lea    0xc34(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x3cf990,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x3cf980,%rsp
lea    0xeca(%rip),%r14
lea    0xc(%rsp),%rsi
mov    %r14,%rdi
call   1040 <scanf@plt>
lea    0x1f50(%rsp),%r12
xor    %r15d,%r15d
xchg   %ax,%ax
add    $0x1,%r15
mov    %r12,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
add    $0x1,%rbp
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <scanf@plt>
movslq 0xc(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     1160 <main+0x40>
add    $0xf9c,%r12
cmp    %rax,%r15
jl     1150 <main+0x30>
cmp    $0x2,%eax
mov    $0x1,%edx
cmovge %eax,%edx
mov    %edx,%r11d
and    $0x7ffffff8,%r11d
lea    -0x8(%r11),%r8
mov    %r8,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
lea    0x1f80(%rsp),%rbx
lea    0x1f50(%rsp),%rdi
mov    $0x2,%r15d
xor    %esi,%esi
jmp    11ef <main+0xcf>
xchg   %ax,%ax
mov    %ecx,0x10(%rsp,%rsi,4)
add    $0x1,%r15d
add    $0xf9c,%rbx
add    $0xf9c,%rdi
cmp    %rdx,%rsi
je     12df <main+0x1bf>
mov    %rsi,%r14
add    $0x1,%rsi
cmp    $0x8,%edx
jae    1210 <main+0xf0>
xor    %ebp,%ebp
xor    %ecx,%ecx
jmp    12c0 <main+0x1a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
pxor   %xmm0,%xmm0
test   %r8,%r8
je     12d1 <main+0x1b1>
mov    %r9,%rbp
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movdqu -0x30(%rbx,%rcx,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x20(%rbx,%rcx,4),%xmm3
paddd  %xmm1,%xmm3
movdqu -0x10(%rbx,%rcx,4),%xmm0
paddd  %xmm2,%xmm0
movdqu (%rbx,%rcx,4),%xmm1
paddd  %xmm3,%xmm1
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1230 <main+0x110>
test   $0x1,%r10b
je     1293 <main+0x173>
shl    $0x2,%rcx
imul   $0xf9c,%rsi,%rbp
add    %rsp,%rbp
add    $0xfb0,%rbp
or     $0x4,%rcx
movdqu (%rcx,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rcx,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
mov    %r11,%rbp
cmp    %rdx,%r11
je     11d0 <main+0xb0>
nopl   0x0(%rax)
add    (%rdi,%rbp,4),%ecx
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    12c0 <main+0x1a0>
jmp    11d0 <main+0xb0>
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
test   $0x1,%r10b
jne    1267 <main+0x147>
jmp    1293 <main+0x173>
lea    0x2(%r14),%r9d
movl   $0x0,0x10(%rsp,%r9,4)
lea    -0x1(%rdx),%r8
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    1301 <main+0x1e1>
xor    %edi,%edi
xor    %ebx,%ebx
jmp    1344 <main+0x224>
mov    %edx,%ebp
and    $0x7ffffffc,%ebp
lea    0x4e30(%rsp),%rsi
xor    %edi,%edi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
add    -0x2ee0(%rsi),%ebx
add    -0x1f40(%rsi),%ebx
add    -0xfa0(%rsi),%ebx
add    $0x4,%rdi
add    (%rsi),%ebx
add    $0x3e80,%rsi
cmp    %rdi,%rbp
jne    1320 <main+0x200>
test   %rcx,%rcx
je     137f <main+0x25f>
imul   $0xfa0,%rdi,%rsi
lea    0xfb0(%rsp),%rdi
add    %rdi,%rsi
add    $0xfa0,%rsi
imul   $0xfa0,%rcx,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
add    (%rsi,%rdi,1),%ebx
add    $0xfa0,%rdi
cmp    %rdi,%rcx
jne    1370 <main+0x250>
mov    %ebx,0x10(%rsp,%r9,4)
mov    %r14d,%r9d
movl   $0x0,0x1c(%rsp,%r9,4)
mov    %edx,%r10d
and    $0x3,%r10d
cmp    $0x3,%r8
jae    13a3 <main+0x283>
xor    %ecx,%ecx
xor    %edi,%edi
jmp    13f8 <main+0x2d8>
mov    %edx,%esi
and    $0x7ffffffc,%esi
imul   $0xf9c,%rdx,%rcx
lea    (%rsp,%rcx,1),%rbx
add    $0xfb4,%rbx
xor    %ecx,%ecx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    (%rbx),%edi
add    -0xf98(%rbx),%edi
add    -0x1f30(%rbx),%edi
add    -0x2ec8(%rbx),%edi
add    $0x4,%rcx
add    $0xfffffffffffffffc,%rdx
add    $0xffffffffffffc1a0,%rbx
cmp    %rcx,%rsi
jne    13d0 <main+0x2b0>
add    $0x3,%r9
test   %r10,%r10
je     1442 <main+0x322>
imul   $0xf9c,%rdx,%rdx
add    %rsp,%rdx
add    $0xfb0,%rdx
lea    (%rdx,%rcx,4),%rcx
add    $0x4,%rcx
imul   $0xf98,%r10,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    (%rcx,%rsi,1),%edi
add    $0xfffffffffffff068,%rsi
mov    %rbp,%rdx
add    %rsi,%rdx
jne    1430 <main+0x310>
mov    %edi,0x10(%rsp,%r9,4)
movslq %r9d,%rdx
test   %rdx,%rdx
mov    $0x1,%ecx
cmovle %rdx,%rcx
mov    0x14(%rsp),%esi
neg    %rcx
lea    (%rdx,%rcx,1),%r9
add    $0x1,%r9
cmp    $0x8,%r9
jae    1470 <main+0x350>
jmp    158b <main+0x46b>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rcx
mov    %rcx,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rcx,%rcx
je     15d4 <main+0x4b4>
movslq %r15d,%rcx
lea    (%rsp,%rcx,4),%rdi
add    $0x4,%rdi
test   %rcx,%rcx
mov    $0x1,%ebp
cmovle %rcx,%rbp
neg    %rbp
add    %rcx,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffff8,%rbp
add    $0xfffffffffffffff8,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
pxor   %xmm2,%xmm2
nopw   0x0(%rax,%rax,1)
movdqu -0x30(%rdi,%rcx,4),%xmm3
movdqu -0x20(%rdi,%rcx,4),%xmm4
movdqu -0x10(%rdi,%rcx,4),%xmm5
movdqu (%rdi,%rcx,4),%xmm6
pshufd $0x1b,%xmm6,%xmm6
pshufd $0x1b,%xmm5,%xmm5
pcmpeqd %xmm0,%xmm6
psubd  %xmm6,%xmm1
pcmpeqd %xmm0,%xmm5
psubd  %xmm5,%xmm2
pshufd $0x1b,%xmm4,%xmm4
pshufd $0x1b,%xmm3,%xmm3
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm1
pcmpeqd %xmm0,%xmm3
psubd  %xmm3,%xmm2
add    $0xfffffffffffffff0,%rcx
add    $0xfffffffffffffffe,%rbp
jne    14e0 <main+0x3c0>
neg    %rcx
test   $0x1,%bl
je     1569 <main+0x449>
mov    %rdx,%rdi
sub    %rcx,%rdi
movdqu -0xc(%rsp,%rdi,4),%xmm3
movdqu 0x4(%rsp,%rdi,4),%xmm4
pshufd $0x1b,%xmm4,%xmm4
pshufd $0x1b,%xmm3,%xmm3
pcmpeqd %xmm0,%xmm4
psubd  %xmm4,%xmm1
pcmpeqd %xmm0,%xmm3
psubd  %xmm3,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %r8,%r9
je     15a6 <main+0x486>
sub    %r8,%rdx
add    $0x1,%rdx
nop
xor    %edi,%edi
cmp    0xc(%rsp,%rdx,4),%esi
sete   %dil
add    %edi,%ecx
add    $0xffffffffffffffff,%rdx
cmp    $0x1,%rdx
jg     1590 <main+0x470>
add    $0x2,%eax
cmp    %eax,%ecx
lea    0xa5a(%rip),%rax
lea    0xa4a(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0x3cf980,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm1,%xmm1
xor    %ecx,%ecx
pxor   %xmm2,%xmm2
test   $0x1,%bl
jne    153d <main+0x41d>
jmp    1569 <main+0x449>

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@str = [9 x i8] c"No magic\00"
@str.3 = [6 x i8] c"Magic\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [999 x [999 x i32]]
%3 = alloca [999 x i32]
%4 = bitcast i32* %1 to i8*
%5 = bitcast [999 x [999 x i32]]* %2 to i8*
%6 = bitcast [999 x i32]* %3 to i8*
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
br label %8
8: ; preds = %19, %0
%9 = phi i64 [ %10, %19 ], [ 0, %0 ]
%10 = add nuw nsw i64 %9, 1
br label %11
11: ; preds = %11, %8
%12 = phi i64 [ %13, %11 ], [ 0, %8 ]
%13 = add nuw nsw i64 %12, 1
%14 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %10, i64 %13
%15 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %14)
%16 = load i32, i32* %1
%17 = sext i32 %16 to i64
%18 = icmp slt i64 %13, %17
br i1 %18, label %11, label %19
19: ; preds = %11
%20 = sext i32 %16 to i64
%21 = icmp slt i64 %10, %20
br i1 %21, label %8, label %22
22: ; preds = %19
%23 = call i32 @llvm.smax.i32(i32 %16, i32 1)
%24 = zext i32 %23 to i64
%25 = and i64 %24, 2147483640
%26 = add nsw i64 %25, -8
%27 = lshr exact i64 %26, 3
%28 = add nuw nsw i64 %27, 1
%29 = icmp ult i32 %23, 8
%30 = and i64 %24, 2147483640
%31 = and i64 %28, 1
%32 = icmp eq i64 %26, 0
%33 = and i64 %28, 4611686018427387902
%34 = icmp eq i64 %31, 0
%35 = icmp eq i64 %30, %24
br label %36
36: ; preds = %22, %99
%37 = phi i64 [ 0, %22 ], [ %38, %99 ]
%38 = add nuw nsw i64 %37, 1
%39 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 %38
br i1 %29, label %88, label %40
40: ; preds = %36
br i1 %32, label %67, label %41
41: ; preds = %40, %41
%42 = phi i64 [ %64, %41 ], [ 0, %40 ]
%43 = phi <4 x i32> [ %62, %41 ], [ zeroinitializer, %40 ]
%44 = phi <4 x i32> [ %63, %41 ], [ zeroinitializer, %40 ]
%45 = phi i64 [ %65, %41 ], [ 0, %40 ]
%46 = or i64 %42, 1
%47 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %38, i64 %46
%48 = bitcast i32* %47 to <4 x i32>*
%49 = load <4 x i32>, <4 x i32>* %48
%50 = getelementptr inbounds i32, i32* %47, i64 4
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = add <4 x i32> %49, %43
%54 = add <4 x i32> %52, %44
%55 = or i64 %42, 9
%56 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %38, i64 %55
%57 = bitcast i32* %56 to <4 x i32>*
%58 = load <4 x i32>, <4 x i32>* %57
%59 = getelementptr inbounds i32, i32* %56, i64 4
%60 = bitcast i32* %59 to <4 x i32>*
%61 = load <4 x i32>, <4 x i32>* %60
%62 = add <4 x i32> %58, %53
%63 = add <4 x i32> %61, %54
%64 = add nuw i64 %42, 16
%65 = add i64 %45, 2
%66 = icmp eq i64 %65, %33
br i1 %66, label %67, label %41
67: ; preds = %41, %40
%68 = phi <4 x i32> [ undef, %40 ], [ %62, %41 ]
%69 = phi <4 x i32> [ undef, %40 ], [ %63, %41 ]
%70 = phi i64 [ 0, %40 ], [ %64, %41 ]
%71 = phi <4 x i32> [ zeroinitializer, %40 ], [ %62, %41 ]
%72 = phi <4 x i32> [ zeroinitializer, %40 ], [ %63, %41 ]
br i1 %34, label %83, label %73
73: ; preds = %67
%74 = or i64 %70, 1
%75 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %38, i64 %74
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = getelementptr inbounds i32, i32* %75, i64 4
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = add <4 x i32> %77, %71
%82 = add <4 x i32> %80, %72
br label %83
83: ; preds = %67, %73
%84 = phi <4 x i32> [ %68, %67 ], [ %81, %73 ]
%85 = phi <4 x i32> [ %69, %67 ], [ %82, %73 ]
%86 = add <4 x i32> %85, %84
%87 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %86)
br i1 %35, label %99, label %88
88: ; preds = %36, %83
%89 = phi i64 [ 0, %36 ], [ %30, %83 ]
%90 = phi i32 [ 0, %36 ], [ %87, %83 ]
br label %91
91: ; preds = %88, %91
%92 = phi i64 [ %94, %91 ], [ %89, %88 ]
%93 = phi i32 [ %97, %91 ], [ %90, %88 ]
%94 = add nuw nsw i64 %92, 1
%95 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %38, i64 %94
%96 = load i32, i32* %95
%97 = add nsw i32 %96, %93
%98 = icmp eq i64 %94, %24
br i1 %98, label %99, label %91
99: ; preds = %91, %83
%100 = phi i32 [ %87, %83 ], [ %97, %91 ]
store i32 %100, i32* %39
%101 = icmp eq i64 %38, %24
br i1 %101, label %102, label %36
102: ; preds = %99
%103 = trunc i64 %37 to i32
%104 = add nuw i64 %37, 2
%105 = and i64 %104, 4294967295
%106 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 %105
store i32 0, i32* %106
%107 = add nsw i64 %24, -1
%108 = and i64 %24, 3
%109 = icmp ult i64 %107, 3
br i1 %109, label %134, label %110
110: ; preds = %102
%111 = and i64 %24, 2147483644
br label %112
112: ; preds = %112, %110
%113 = phi i64 [ 0, %110 ], [ %128, %112 ]
%114 = phi i32 [ 0, %110 ], [ %131, %112 ]
%115 = phi i64 [ 0, %110 ], [ %132, %112 ]
%116 = or i64 %113, 1
%117 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %116, i64 %116
%118 = load i32, i32* %117
%119 = add nsw i32 %118, %114
%120 = or i64 %113, 2
%121 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %120, i64 %120
%122 = load i32, i32* %121
%123 = add nsw i32 %122, %119
%124 = or i64 %113, 3
%125 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %124, i64 %124
%126 = load i32, i32* %125
%127 = add nsw i32 %126, %123
%128 = add nuw nsw i64 %113, 4
%129 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %128, i64 %128
%130 = load i32, i32* %129
%131 = add nsw i32 %130, %127
%132 = add i64 %115, 4
%133 = icmp eq i64 %132, %111
br i1 %133, label %134, label %112
134: ; preds = %112, %102
%135 = phi i32 [ undef, %102 ], [ %131, %112 ]
%136 = phi i64 [ 0, %102 ], [ %128, %112 ]
%137 = phi i32 [ 0, %102 ], [ %131, %112 ]
%138 = icmp eq i64 %108, 0
br i1 %138, label %149, label %139
139: ; preds = %134, %139
%140 = phi i64 [ %143, %139 ], [ %136, %134 ]
%141 = phi i32 [ %146, %139 ], [ %137, %134 ]
%142 = phi i64 [ %147, %139 ], [ 0, %134 ]
%143 = add nuw nsw i64 %140, 1
%144 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %143, i64 %143
%145 = load i32, i32* %144
%146 = add nsw i32 %145, %141
%147 = add i64 %142, 1
%148 = icmp eq i64 %147, %108
br i1 %148, label %149, label %139
149: ; preds = %139, %134
%150 = phi i32 [ %135, %134 ], [ %146, %139 ]
store i32 %150, i32* %106
%151 = add nuw nsw i32 %103, 3
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 %152
store i32 0, i32* %153
%154 = and i64 %24, 3
%155 = icmp ult i64 %107, 3
br i1 %155, label %185, label %156
156: ; preds = %149
%157 = and i64 %24, 2147483644
br label %158
158: ; preds = %158, %156
%159 = phi i64 [ 0, %156 ], [ %178, %158 ]
%160 = phi i64 [ %24, %156 ], [ %182, %158 ]
%161 = phi i32 [ 0, %156 ], [ %181, %158 ]
%162 = phi i64 [ 0, %156 ], [ %183, %158 ]
%163 = or i64 %159, 1
%164 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %160, i64 %163
%165 = load i32, i32* %164
%166 = add nsw i32 %165, %161
%167 = add nsw i64 %160, -1
%168 = or i64 %159, 2
%169 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %167, i64 %168
%170 = load i32, i32* %169
%171 = add nsw i32 %170, %166
%172 = add nsw i64 %160, -2
%173 = or i64 %159, 3
%174 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %172, i64 %173
%175 = load i32, i32* %174
%176 = add nsw i32 %175, %171
%177 = add nsw i64 %160, -3
%178 = add nuw nsw i64 %159, 4
%179 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %177, i64 %178
%180 = load i32, i32* %179
%181 = add nsw i32 %180, %176
%182 = add nsw i64 %160, -4
%183 = add i64 %162, 4
%184 = icmp eq i64 %183, %157
br i1 %184, label %185, label %158
185: ; preds = %158, %149
%186 = phi i32 [ undef, %149 ], [ %181, %158 ]
%187 = phi i64 [ 0, %149 ], [ %178, %158 ]
%188 = phi i64 [ %24, %149 ], [ %182, %158 ]
%189 = phi i32 [ 0, %149 ], [ %181, %158 ]
%190 = icmp eq i64 %154, 0
br i1 %190, label %203, label %191
191: ; preds = %185, %191
%192 = phi i64 [ %196, %191 ], [ %187, %185 ]
%193 = phi i64 [ %200, %191 ], [ %188, %185 ]
%194 = phi i32 [ %199, %191 ], [ %189, %185 ]
%195 = phi i64 [ %201, %191 ], [ 0, %185 ]
%196 = add nuw nsw i64 %192, 1
%197 = getelementptr inbounds [999 x [999 x i32]], [999 x [999 x i32]]* %2, i64 0, i64 %193, i64 %196
%198 = load i32, i32* %197
%199 = add nsw i32 %198, %194
%200 = add nsw i64 %193, -1
%201 = add i64 %195, 1
%202 = icmp eq i64 %201, %154
br i1 %202, label %203, label %191
203: ; preds = %191, %185
%204 = phi i32 [ %186, %185 ], [ %199, %191 ]
store i32 %204, i32* %153
%205 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 1
%206 = load i32, i32* %205
%207 = sext i32 %151 to i64
%208 = add nsw i64 %207, 1
%209 = call i64 @llvm.smin.i64(i64 %207, i64 1)
%210 = sub i64 %208, %209
%211 = icmp ult i64 %210, 8
br i1 %211, label %297, label %212
212: ; preds = %203
%213 = and i64 %210, -8
%214 = sub i64 %207, %213
%215 = insertelement <4 x i32> poison, i32 %206, i64 0
%216 = shufflevector <4 x i32> %215, <4 x i32> poison, <4 x i32> zeroinitializer
%217 = insertelement <4 x i32> poison, i32 %206, i64 0
%218 = shufflevector <4 x i32> %217, <4 x i32> poison, <4 x i32> zeroinitializer
%219 = add i64 %213, -8
%220 = lshr exact i64 %219, 3
%221 = add nuw nsw i64 %220, 1
%222 = and i64 %221, 1
%223 = icmp eq i64 %219, 0
br i1 %223, label %267, label %224
224: ; preds = %212
%225 = and i64 %221, 4611686018427387902
br label %226
226: ; preds = %226, %224
%227 = phi i64 [ 0, %224 ], [ %264, %226 ]
%228 = phi <4 x i32> [ <i32 undef, i32 0, i32 0, i32 0>, %224 ], [ %262, %226 ]
%229 = phi <4 x i32> [ zeroinitializer, %224 ], [ %263, %226 ]
%230 = phi i64 [ 0, %224 ], [ %265, %226 ]
%231 = sub i64 %207, %227
%232 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 %231
%233 = getelementptr inbounds i32, i32* %232, i64 -3
%234 = bitcast i32* %233 to <4 x i32>*
%235 = load <4 x i32>, <4 x i32>* %234
%236 = shufflevector <4 x i32> %235, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%237 = getelementptr inbounds i32, i32* %232, i64 -7
%238 = bitcast i32* %237 to <4 x i32>*
%239 = load <4 x i32>, <4 x i32>* %238
%240 = shufflevector <4 x i32> %239, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%241 = icmp eq <4 x i32> %216, %236
%242 = icmp eq <4 x i32> %218, %240
%243 = zext <4 x i1> %241 to <4 x i32>
%244 = zext <4 x i1> %242 to <4 x i32>
%245 = add <4 x i32> %228, %243
%246 = add <4 x i32> %229, %244
%247 = or i64 %227, 8
%248 = sub i64 %207, %247
%249 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 %248
%250 = getelementptr inbounds i32, i32* %249, i64 -3
%251 = bitcast i32* %250 to <4 x i32>*
%252 = load <4 x i32>, <4 x i32>* %251
%253 = shufflevector <4 x i32> %252, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%254 = getelementptr inbounds i32, i32* %249, i64 -7
%255 = bitcast i32* %254 to <4 x i32>*
%256 = load <4 x i32>, <4 x i32>* %255
%257 = shufflevector <4 x i32> %256, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%258 = icmp eq <4 x i32> %216, %253
%259 = icmp eq <4 x i32> %218, %257
%260 = zext <4 x i1> %258 to <4 x i32>
%261 = zext <4 x i1> %259 to <4 x i32>
%262 = add <4 x i32> %245, %260
%263 = add <4 x i32> %246, %261
%264 = add nuw i64 %227, 16
%265 = add i64 %230, 2
%266 = icmp eq i64 %265, %225
br i1 %266, label %267, label %226
267: ; preds = %226, %212
%268 = phi <4 x i32> [ undef, %212 ], [ %262, %226 ]
%269 = phi <4 x i32> [ undef, %212 ], [ %263, %226 ]
%270 = phi i64 [ 0, %212 ], [ %264, %226 ]
%271 = phi <4 x i32> [ <i32 undef, i32 0, i32 0, i32 0>, %212 ], [ %262, %226 ]
%272 = phi <4 x i32> [ zeroinitializer, %212 ], [ %263, %226 ]
%273 = icmp eq i64 %222, 0
br i1 %273, label %291, label %274
274: ; preds = %267
%275 = sub i64 %207, %270
%276 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 %275
%277 = getelementptr inbounds i32, i32* %276, i64 -3
%278 = bitcast i32* %277 to <4 x i32>*
%279 = load <4 x i32>, <4 x i32>* %278
%280 = shufflevector <4 x i32> %279, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%281 = getelementptr inbounds i32, i32* %276, i64 -7
%282 = bitcast i32* %281 to <4 x i32>*
%283 = load <4 x i32>, <4 x i32>* %282
%284 = shufflevector <4 x i32> %283, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%285 = icmp eq <4 x i32> %216, %280
%286 = icmp eq <4 x i32> %218, %284
%287 = zext <4 x i1> %285 to <4 x i32>
%288 = zext <4 x i1> %286 to <4 x i32>
%289 = add <4 x i32> %271, %287
%290 = add <4 x i32> %272, %288
br label %291
291: ; preds = %267, %274
%292 = phi <4 x i32> [ %268, %267 ], [ %289, %274 ]
%293 = phi <4 x i32> [ %269, %267 ], [ %290, %274 ]
%294 = add <4 x i32> %293, %292
%295 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %294)
%296 = icmp eq i64 %210, %213
br i1 %296, label %310, label %297
297: ; preds = %203, %291
%298 = phi i64 [ %207, %203 ], [ %214, %291 ]
%299 = phi i32 [ undef, %203 ], [ %295, %291 ]
br label %300
300: ; preds = %297, %300
%301 = phi i64 [ %308, %300 ], [ %298, %297 ]
%302 = phi i32 [ %307, %300 ], [ %299, %297 ]
%303 = getelementptr inbounds [999 x i32], [999 x i32]* %3, i64 0, i64 %301
%304 = load i32, i32* %303
%305 = icmp eq i32 %206, %304
%306 = zext i1 %305 to i32
%307 = add nsw i32 %302, %306
%308 = add nsw i64 %301, -1
%309 = icmp sgt i64 %301, 1
br i1 %309, label %300, label %310
310: ; preds = %300, %291
%311 = phi i32 [ %295, %291 ], [ %307, %300 ]
%312 = add nsw i32 %16, 2
%313 = icmp eq i32 %311, %312
%314 = select i1 %313, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @str.3, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @str, i64 0, i64 0)
%315 = call i32 @puts(i8* dereferenceable(1) %314)
ret i32 0
}