#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 arr[50][50], check[100];
  int m, a, i, n, a1;
  int check1 = 0, check2 = 0, check3 = 0, check4 = 0;
  n = 0;
  while ((n < 1) || (n > 49)) {
    scanf("%d", &n);
  }
  for (i = 0; i < n; i++) {
    printf("\n");
    for (a = 0; a < n; a++) {
      scanf("%d", &arr[i][a]);
    }
  }
  a1 = 0;
  for (i = 0; i < n; i++) {
    m = 0;
    for (a = 0; a < n; a++) {
      m = m + arr[i][a];
    }
    check[i] = m;
    if (i > 0) {
      if (check[i - 1] != check[i]) {
        a1 = 1;
      }
    }
  }
  if (a1 == 1) {
    goto goodbye;
  }
  check1 = check[i];
  for (a = 0; a < n; a++) {
    m = 0;
    for (i = 0; i < n; i++) {
      m = m + arr[i][a];
    }
    check[a] = m;
    if (a > 0) {
      if (check[a - 1] != check[a]) {
        a1 = 1;
      }
    }
  }
  if (a1 == 1) {
    goto goodbye;
  }
  check2 = check[a];
  m = 0;
  for (i = 0; i < n; i++) {
    m = m + arr[i][i];
  }
  check[i] = m;
  check3 = check[i];
  m = 0;
  i = n - 1;
  a = 0;
  while (a < n) {
    m = m + arr[i][a];
    i--;
    a++;
  }
  check[i] = m;
  check4 = check[i];
  if (check1 != check2) {
    a1 = 1;
  }
  if (check1 != check3) {
    a1 = 1;
  }
  if (check1 != check4) {
    a1 = 1;
  }
goodbye:
  if (a1 == 0) {
    printf("MAGIC");
  }
  if (a1 == 1) {
    printf("NO MAGIC");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x28e0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x0,-0x28c8(%rbp)
movl   $0x0,-0x28cc(%rbp)
movl   $0x0,-0x28d0(%rbp)
movl   $0x0,-0x28d4(%rbp)
movl   $0x0,-0x28c0(%rbp)
mov    $0x1,%al
cmpl   $0x1,-0x28c0(%rbp)
mov    %al,-0x28d5(%rbp)
jl     1189 <main+0x69>
cmpl   $0x31,-0x28c0(%rbp)
setg   %al
mov    %al,-0x28d5(%rbp)
mov    -0x28d5(%rbp),%al
test   $0x1,%al
jne    119c <main+0x7c>
jmp    11b4 <main+0x94>
lea    0xe5d(%rip),%rdi
lea    -0x28c0(%rbp),%rsi
call   1040 <scanf@plt>
jmp    1164 <main+0x44>
movl   $0x0,-0x28bc(%rbp)
mov    -0x28bc(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    1257 <main+0x137>
lea    0xe2c(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x28b8(%rbp)
mov    -0x28b8(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    123e <main+0x11e>
movslq -0x28bc(%rbp),%rax
lea    -0x2720(%rbp),%rsi
imul   $0xc8,%rax,%rax
add    %rax,%rsi
movslq -0x28b8(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rsi
lea    0xddb(%rip),%rdi
call   1040 <scanf@plt>
mov    -0x28b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28b8(%rbp)
jmp    11e6 <main+0xc6>
jmp    1243 <main+0x123>
mov    -0x28bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28bc(%rbp)
jmp    11be <main+0x9e>
movl   $0x0,-0x28c4(%rbp)
movl   $0x0,-0x28bc(%rbp)
mov    -0x28bc(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    1354 <main+0x234>
movl   $0x0,-0x28b4(%rbp)
movl   $0x0,-0x28b8(%rbp)
mov    -0x28b8(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    12e5 <main+0x1c5>
mov    -0x28b4(%rbp),%eax
movslq -0x28bc(%rbp),%rdx
lea    -0x2720(%rbp),%rcx
imul   $0xc8,%rdx,%rdx
add    %rdx,%rcx
movslq -0x28b8(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28b4(%rbp)
mov    -0x28b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28b8(%rbp)
jmp    1291 <main+0x171>
mov    -0x28b4(%rbp),%ecx
movslq -0x28bc(%rbp),%rax
mov    %ecx,-0x28b0(%rbp,%rax,4)
cmpl   $0x0,-0x28bc(%rbp)
jle    133b <main+0x21b>
mov    -0x28bc(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x28b0(%rbp,%rax,4),%eax
movslq -0x28bc(%rbp),%rcx
cmp    -0x28b0(%rbp,%rcx,4),%eax
je     1336 <main+0x216>
movl   $0x1,-0x28c4(%rbp)
jmp    133b <main+0x21b>
jmp    1340 <main+0x220>
mov    -0x28bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28bc(%rbp)
jmp    126b <main+0x14b>
cmpl   $0x1,-0x28c4(%rbp)
jne    1366 <main+0x246>
jmp    162a <main+0x50a>
movslq -0x28bc(%rbp),%rax
mov    -0x28b0(%rbp,%rax,4),%eax
mov    %eax,-0x28c8(%rbp)
movl   $0x0,-0x28b8(%rbp)
mov    -0x28b8(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    146d <main+0x34d>
movl   $0x0,-0x28b4(%rbp)
movl   $0x0,-0x28bc(%rbp)
mov    -0x28bc(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    13fe <main+0x2de>
mov    -0x28b4(%rbp),%eax
movslq -0x28bc(%rbp),%rdx
lea    -0x2720(%rbp),%rcx
imul   $0xc8,%rdx,%rdx
add    %rdx,%rcx
movslq -0x28b8(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28b4(%rbp)
mov    -0x28bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28bc(%rbp)
jmp    13aa <main+0x28a>
mov    -0x28b4(%rbp),%ecx
movslq -0x28b8(%rbp),%rax
mov    %ecx,-0x28b0(%rbp,%rax,4)
cmpl   $0x0,-0x28b8(%rbp)
jle    1454 <main+0x334>
mov    -0x28b8(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x28b0(%rbp,%rax,4),%eax
movslq -0x28b8(%rbp),%rcx
cmp    -0x28b0(%rbp,%rcx,4),%eax
je     144f <main+0x32f>
movl   $0x1,-0x28c4(%rbp)
jmp    1454 <main+0x334>
jmp    1459 <main+0x339>
mov    -0x28b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28b8(%rbp)
jmp    1384 <main+0x264>
cmpl   $0x1,-0x28c4(%rbp)
jne    147f <main+0x35f>
jmp    162a <main+0x50a>
movslq -0x28b8(%rbp),%rax
mov    -0x28b0(%rbp,%rax,4),%eax
mov    %eax,-0x28cc(%rbp)
movl   $0x0,-0x28b4(%rbp)
movl   $0x0,-0x28bc(%rbp)
mov    -0x28bc(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    14fb <main+0x3db>
mov    -0x28b4(%rbp),%eax
movslq -0x28bc(%rbp),%rdx
lea    -0x2720(%rbp),%rcx
imul   $0xc8,%rdx,%rdx
add    %rdx,%rcx
movslq -0x28bc(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28b4(%rbp)
mov    -0x28bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28bc(%rbp)
jmp    14a7 <main+0x387>
mov    -0x28b4(%rbp),%ecx
movslq -0x28bc(%rbp),%rax
mov    %ecx,-0x28b0(%rbp,%rax,4)
movslq -0x28bc(%rbp),%rax
mov    -0x28b0(%rbp,%rax,4),%eax
mov    %eax,-0x28d0(%rbp)
movl   $0x0,-0x28b4(%rbp)
mov    -0x28c0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28bc(%rbp)
movl   $0x0,-0x28b8(%rbp)
mov    -0x28b8(%rbp),%eax
cmp    -0x28c0(%rbp),%eax
jge    15a9 <main+0x489>
mov    -0x28b4(%rbp),%eax
movslq -0x28bc(%rbp),%rdx
lea    -0x2720(%rbp),%rcx
imul   $0xc8,%rdx,%rdx
add    %rdx,%rcx
movslq -0x28b8(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x28b4(%rbp)
mov    -0x28bc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28bc(%rbp)
mov    -0x28b8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28b8(%rbp)
jmp    1546 <main+0x426>
mov    -0x28b4(%rbp),%ecx
movslq -0x28bc(%rbp),%rax
mov    %ecx,-0x28b0(%rbp,%rax,4)
movslq -0x28bc(%rbp),%rax
mov    -0x28b0(%rbp,%rax,4),%eax
mov    %eax,-0x28d4(%rbp)
mov    -0x28c8(%rbp),%eax
cmp    -0x28cc(%rbp),%eax
je     15ed <main+0x4cd>
movl   $0x1,-0x28c4(%rbp)
mov    -0x28c8(%rbp),%eax
cmp    -0x28d0(%rbp),%eax
je     1609 <main+0x4e9>
movl   $0x1,-0x28c4(%rbp)
mov    -0x28c8(%rbp),%eax
cmp    -0x28d4(%rbp),%eax
je     1625 <main+0x505>
movl   $0x1,-0x28c4(%rbp)
jmp    162a <main+0x50a>
cmpl   $0x0,-0x28c4(%rbp)
jne    1643 <main+0x523>
lea    0x9ca(%rip),%rdi
call   1030 <printf@plt>
cmpl   $0x1,-0x28c4(%rbp)
jne    165c <main+0x53c>
lea    0x9ae(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x28e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28b8,%rsp
movl   $0x0,0x4(%rsp)
lea    0xeb0(%rip),%r14
lea    0x4(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,%rdi
mov    %rbx,%rsi
call   1050 <scanf@plt>
mov    0x4(%rsp),%eax
add    $0xffffffce,%eax
cmp    $0xffffffcf,%eax
jb     1160 <main+0x30>
lea    0x1a0(%rsp),%r15
xor    %r12d,%r12d
lea    0xe77(%rip),%r14
jmp    11a3 <main+0x73>
nopl   0x0(%rax,%rax,1)
movslq %eax,%rcx
add    $0x1,%r12
add    $0xc8,%r15
cmp    %rcx,%r12
jge    11df <main+0xaf>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x4(%rsp),%eax
test   %eax,%eax
jle    1190 <main+0x60>
mov    %r15,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %rbx,%rsi
call   1050 <scanf@plt>
add    $0x1,%rbp
movslq 0x4(%rsp),%rax
add    $0x4,%rbx
cmp    %rax,%rbp
jl     11c0 <main+0x90>
jmp    1190 <main+0x60>
test   %eax,%eax
jle    14ed <main+0x3bd>
mov    $0xffffffff,%r8d
mov    %eax,%r14d
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%r10
mov    %r10,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9d,%r11d
and    $0x3,%r11d
and    $0xfffffffffffffffc,%r9
lea    0x210(%rsp),%rsi
mov    %r11,%rbx
shl    $0x5,%rbx
xor    %r13d,%r13d
lea    0x1a0(%rsp),%rdx
mov    $0x1,%r15d
xor    %r12d,%r12d
jmp    125b <main+0x12b>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r13
add    $0xc8,%rsi
add    $0xc8,%rdx
cmp    %r14,%r13
je     137b <main+0x24b>
cmp    $0x8,%eax
jae    1270 <main+0x140>
xor    %ebp,%ebp
xor    %edi,%edi
jmp    1350 <main+0x220>
nopl   0x0(%rax)
pxor   %xmm0,%xmm0
cmp    $0x18,%r10
jae    1290 <main+0x160>
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    12f9 <main+0x1c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r9,%rdi
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu -0x70(%rsi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu -0x60(%rsi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu -0x50(%rsi,%rbp,4),%xmm1
movdqu -0x40(%rsi,%rbp,4),%xmm3
movdqu -0x30(%rsi,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu -0x20(%rsi,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu -0x10(%rsi,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu (%rsi,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    12a0 <main+0x170>
test   %r11,%r11
je     132c <main+0x1fc>
lea    (%rdx,%rbp,4),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu (%rdi,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x10(%rdi,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    1310 <main+0x1e0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edi
mov    %rcx,%rbp
cmp    %r14,%rcx
je     135c <main+0x22c>
xchg   %ax,%ax
add    (%rdx,%rbp,4),%edi
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1350 <main+0x220>
mov    %edi,0x10(%rsp,%r13,4)
test   %r13,%r13
je     1240 <main+0x110>
lea    (%r8,%r13,1),%ebp
cmp    %edi,0x10(%rsp,%rbp,4)
cmovne %r15d,%r12d
jmp    1240 <main+0x110>
cmp    $0x1,%r12d
je     1522 <main+0x3f2>
mov    0x10(%rsp,%r14,4),%r10d
test   %eax,%eax
jle    14f2 <main+0x3c2>
mov    %r14d,%r9d
and    $0xfffffff8,%r9d
lea    0x718(%rsp),%rbp
mov    %r14,%rcx
shr    $0x3,%rcx
mov    %rcx,0x8(%rsp)
imul   $0x640,%rcx,%rbx
xor    %edi,%edi
lea    0x1a0(%rsp),%r12
mov    $0x1,%r11d
xor    %r15d,%r15d
jmp    13e5 <main+0x2b5>
nopl   0x0(%rax)
add    $0x1,%rdi
add    $0x4,%rbp
add    $0x4,%r12
cmp    %r14,%rdi
je     151c <main+0x3ec>
cmp    $0x8,%eax
jae    1400 <main+0x2d0>
xor    %r13d,%r13d
xor    %esi,%esi
jmp    14a3 <main+0x373>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movd   -0x320(%rbp,%rsi,1),%xmm2
ff ff
movd   -0x3e8(%rbp,%rsi,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x4b0(%rbp,%rsi,1),%xmm2
ff ff
movd   -0x578(%rbp,%rsi,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm0
movd   0x0(%rbp,%rsi,1),%xmm2
movd   -0xc8(%rbp,%rsi,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x190(%rbp,%rsi,1),%xmm2
ff ff
movd   -0x258(%rbp,%rsi,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0x640,%rsi
cmp    %rsi,%rbx
jne    1410 <main+0x2e0>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
mov    %r9,%r13
cmp    %r14,%r9
je     14cf <main+0x39f>
imul   $0xc8,%r13,%rdx
add    %r12,%rdx
mov    %r14,%rcx
sub    %r13,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    (%rdx),%esi
add    $0xc8,%rdx
add    $0xffffffffffffffff,%rcx
jne    14c0 <main+0x390>
mov    %esi,0x10(%rsp,%rdi,4)
test   %rdi,%rdi
je     13d0 <main+0x2a0>
lea    (%rdi,%r8,1),%ecx
cmp    %esi,0x10(%rsp,%rcx,4)
cmovne %r11d,%r15d
jmp    13d0 <main+0x2a0>
mov    0x10(%rsp),%r10d
mov    0x10(%rsp),%r9d
add    $0xffffffff,%eax
xor    %edi,%edi
xor    %edx,%edx
cltq
mov    %edx,0x10(%rsp,%rax,4)
cmp    %edx,%r10d
jne    1522 <main+0x3f2>
cmp    %edi,%r10d
jne    1522 <main+0x3f2>
cmp    %r9d,%r10d
jne    1522 <main+0x3f2>
lea    0xaec(%rip),%rdi
jmp    1529 <main+0x3f9>
cmp    $0x1,%r15d
jne    1542 <main+0x412>
lea    0xada(%rip),%rdi
call   1040 <printf@plt>
xor    %eax,%eax
add    $0x28b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x10(%rsp,%r14,4),%r9d
test   %eax,%eax
jle    14f7 <main+0x3c7>
cmp    $0x8,%eax
jae    1559 <main+0x429>
xor    %edx,%edx
xor    %edi,%edi
jmp    1613 <main+0x4e3>
mov    %r14d,%edx
and    $0xfffffff8,%edx
imul   $0x660,0x8(%rsp),%rdi
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movd   0x404(%rsp,%rbp,1),%xmm2
movd   0x338(%rsp,%rbp,1),%xmm3
punpckldq %xmm2,%xmm3
movd   0x26c(%rsp,%rbp,1),%xmm2
movd   0x1a0(%rsp,%rbp,1),%xmm4
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm0
movd   0x734(%rsp,%rbp,1),%xmm2
movd   0x668(%rsp,%rbp,1),%xmm3
punpckldq %xmm2,%xmm3
movd   0x59c(%rsp,%rbp,1),%xmm2
movd   0x4d0(%rsp,%rbp,1),%xmm4
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0x660,%rbp
cmp    %rbp,%rdi
jne    1580 <main+0x450>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edi
cmp    %r14,%rdx
je     1640 <main+0x510>
imul   $0xcc,%rdx,%rcx
lea    (%rsp,%rcx,1),%rbp
add    $0x1a0,%rbp
mov    %r14,%rcx
sub    %rdx,%rcx
nopl   0x0(%rax,%rax,1)
add    0x0(%rbp),%edi
add    $0xcc,%rbp
add    $0xffffffffffffffff,%rcx
jne    1630 <main+0x500>
mov    %edi,0x10(%rsp,%r14,4)
test   %eax,%eax
jle    1660 <main+0x530>
lea    -0x1(%r14),%rax
mov    %r14d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1668 <main+0x538>
xor    %ebx,%ebx
xor    %edx,%edx
jmp    16b9 <main+0x589>
add    $0xffffffff,%eax
jmp    14fc <main+0x3cc>
imul   $0xc8,%r14,%rax
add    %rsp,%rax
add    $0xd8,%rax
mov    %r14d,%ebp
and    $0xfffffffc,%ebp
neg    %rbp
xor    %ebx,%ebx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
add    (%rax),%edx
add    -0xc4(%rax),%edx
add    -0x188(%rax),%edx
add    -0x24c(%rax),%edx
add    $0xfffffffffffffcf0,%rax
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%rbp
jne    1690 <main+0x560>
add    %rbx,%r14
neg    %rbx
mov    $0xffffffff,%eax
test   %r8,%r8
je     14fe <main+0x3ce>
imul   $0xc8,%r14,%rcx
lea    0x1a0(%rsp),%rbp
add    %rbp,%rcx
lea    (%rcx,%rbx,4),%rcx
add    $0xffffffffffffff38,%rcx
imul   $0xc4,%r8,%rsi
xor    %ebx,%ebx
nopl   (%rax)
add    (%rcx,%rbx,1),%edx
add    $0xffffffffffffff3c,%rbx
mov    %rsi,%rbp
add    %rbx,%rbp
jne    16f0 <main+0x5c0>
jmp    14fe <main+0x3ce>

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [2 x i8] c"\0A\00"
@.str.2 = [6 x i8] c"MAGIC\00"
@.str.3 = [9 x i8] c"NO MAGIC\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [50 x [50 x i32]]
%3 = alloca [100 x i32]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
store i32 0, i32* %1
store i32 0, i32* %9
store i32 0, i32* %10
store i32 0, i32* %11
store i32 0, i32* %12
store i32 0, i32* %7
br label %13
13: ; preds = %21, %0
%14 = load i32, i32* %7
%15 = icmp slt i32 %14, 1
br i1 %15, label %19, label %16
16: ; preds = %13
%17 = load i32, i32* %7
%18 = icmp sgt i32 %17, 49
br label %19
19: ; preds = %16, %13
%20 = phi i1 [ true, %13 ], [ %18, %16 ]
br i1 %20, label %21, label %23
21: ; preds = %19
%22 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %7)
br label %13
23: ; preds = %19
store i32 0, i32* %6
br label %24
24: ; preds = %46, %23
%25 = load i32, i32* %6
%26 = load i32, i32* %7
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %49
28: ; preds = %24
%29 = call i32 @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
store i32 0, i32* %5
br label %30
30: ; preds = %42, %28
%31 = load i32, i32* %5
%32 = load i32, i32* %7
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %45
34: ; preds = %30
%35 = load i32, i32* %6
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %2, i64 0, i64 %36
%38 = load i32, i32* %5
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [50 x i32], [50 x i32]* %37, i64 0, i64 %39
%41 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %40)
br label %42
42: ; preds = %34
%43 = load i32, i32* %5
%44 = add nsw i32 %43, 1
store i32 %44, i32* %5
br label %30
45: ; preds = %30
br label %46
46: ; preds = %45
%47 = load i32, i32* %6
%48 = add nsw i32 %47, 1
store i32 %48, i32* %6
br label %24
49: ; preds = %24
store i32 0, i32* %8
store i32 0, i32* %6
br label %50
50: ; preds = %93, %49
%51 = load i32, i32* %6
%52 = load i32, i32* %7
%53 = icmp slt i32 %51, %52
br i1 %53, label %54, label %96
54: ; preds = %50
store i32 0, i32* %4
store i32 0, i32* %5
br label %55
55: ; preds = %69, %54
%56 = load i32, i32* %5
%57 = load i32, i32* %7
%58 = icmp slt i32 %56, %57
br i1 %58, label %59, label %72
59: ; preds = %55
%60 = load i32, i32* %4
%61 = load i32, i32* %6
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %2, i64 0, i64 %62
%64 = load i32, i32* %5
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [50 x i32], [50 x i32]* %63, i64 0, i64 %65
%67 = load i32, i32* %66
%68 = add nsw i32 %60, %67
store i32 %68, i32* %4
br label %69
69: ; preds = %59
%70 = load i32, i32* %5
%71 = add nsw i32 %70, 1
store i32 %71, i32* %5
br label %55
72: ; preds = %55
%73 = load i32, i32* %4
%74 = load i32, i32* %6
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %75
store i32 %73, i32* %76
%77 = load i32, i32* %6
%78 = icmp sgt i32 %77, 0
br i1 %78, label %79, label %92
79: ; preds = %72
%80 = load i32, i32* %6
%81 = sub nsw i32 %80, 1
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %82
%84 = load i32, i32* %83
%85 = load i32, i32* %6
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %86
%88 = load i32, i32* %87
%89 = icmp ne i32 %84, %88
br i1 %89, label %90, label %91
90: ; preds = %79
store i32 1, i32* %8
br label %91
91: ; preds = %90, %79
br label %92
92: ; preds = %91, %72
br label %93
93: ; preds = %92
%94 = load i32, i32* %6
%95 = add nsw i32 %94, 1
store i32 %95, i32* %6
br label %50
96: ; preds = %50
%97 = load i32, i32* %8
%98 = icmp eq i32 %97, 1
br i1 %98, label %99, label %100
99: ; preds = %96
br label %230
100: ; preds = %96
%101 = load i32, i32* %6
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %102
%104 = load i32, i32* %103
store i32 %104, i32* %9
store i32 0, i32* %5
br label %105
105: ; preds = %148, %100
%106 = load i32, i32* %5
%107 = load i32, i32* %7
%108 = icmp slt i32 %106, %107
br i1 %108, label %109, label %151
109: ; preds = %105
store i32 0, i32* %4
store i32 0, i32* %6
br label %110
110: ; preds = %124, %109
%111 = load i32, i32* %6
%112 = load i32, i32* %7
%113 = icmp slt i32 %111, %112
br i1 %113, label %114, label %127
114: ; preds = %110
%115 = load i32, i32* %4
%116 = load i32, i32* %6
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %2, i64 0, i64 %117
%119 = load i32, i32* %5
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [50 x i32], [50 x i32]* %118, i64 0, i64 %120
%122 = load i32, i32* %121
%123 = add nsw i32 %115, %122
store i32 %123, i32* %4
br label %124
124: ; preds = %114
%125 = load i32, i32* %6
%126 = add nsw i32 %125, 1
store i32 %126, i32* %6
br label %110
127: ; preds = %110
%128 = load i32, i32* %4
%129 = load i32, i32* %5
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %130
store i32 %128, i32* %131
%132 = load i32, i32* %5
%133 = icmp sgt i32 %132, 0
br i1 %133, label %134, label %147
134: ; preds = %127
%135 = load i32, i32* %5
%136 = sub nsw i32 %135, 1
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %137
%139 = load i32, i32* %138
%140 = load i32, i32* %5
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %141
%143 = load i32, i32* %142
%144 = icmp ne i32 %139, %143
br i1 %144, label %145, label %146
145: ; preds = %134
store i32 1, i32* %8
br label %146
146: ; preds = %145, %134
br label %147
147: ; preds = %146, %127
br label %148
148: ; preds = %147
%149 = load i32, i32* %5
%150 = add nsw i32 %149, 1
store i32 %150, i32* %5
br label %105
151: ; preds = %105
%152 = load i32, i32* %8
%153 = icmp eq i32 %152, 1
br i1 %153, label %154, label %155
154: ; preds = %151
br label %230
155: ; preds = %151
%156 = load i32, i32* %5
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %157
%159 = load i32, i32* %158
store i32 %159, i32* %10
store i32 0, i32* %4
store i32 0, i32* %6
br label %160
160: ; preds = %174, %155
%161 = load i32, i32* %6
%162 = load i32, i32* %7
%163 = icmp slt i32 %161, %162
br i1 %163, label %164, label %177
164: ; preds = %160
%165 = load i32, i32* %4
%166 = load i32, i32* %6
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %2, i64 0, i64 %167
%169 = load i32, i32* %6
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [50 x i32], [50 x i32]* %168, i64 0, i64 %170
%172 = load i32, i32* %171
%173 = add nsw i32 %165, %172
store i32 %173, i32* %4
br label %174
174: ; preds = %164
%175 = load i32, i32* %6
%176 = add nsw i32 %175, 1
store i32 %176, i32* %6
br label %160
177: ; preds = %160
%178 = load i32, i32* %4
%179 = load i32, i32* %6
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %180
store i32 %178, i32* %181
%182 = load i32, i32* %6
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %183
%185 = load i32, i32* %184
store i32 %185, i32* %11
store i32 0, i32* %4
%186 = load i32, i32* %7
%187 = sub nsw i32 %186, 1
store i32 %187, i32* %6
store i32 0, i32* %5
br label %188
188: ; preds = %192, %177
%189 = load i32, i32* %5
%190 = load i32, i32* %7
%191 = icmp slt i32 %189, %190
br i1 %191, label %192, label %206
192: ; preds = %188
%193 = load i32, i32* %4
%194 = load i32, i32* %6
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds [50 x [50 x i32]], [50 x [50 x i32]]* %2, i64 0, i64 %195
%197 = load i32, i32* %5
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [50 x i32], [50 x i32]* %196, i64 0, i64 %198
%200 = load i32, i32* %199
%201 = add nsw i32 %193, %200
store i32 %201, i32* %4
%202 = load i32, i32* %6
%203 = add nsw i32 %202, -1
store i32 %203, i32* %6
%204 = load i32, i32* %5
%205 = add nsw i32 %204, 1
store i32 %205, i32* %5
br label %188
206: ; preds = %188
%207 = load i32, i32* %4
%208 = load i32, i32* %6
%209 = sext i32 %208 to i64
%210 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %209
store i32 %207, i32* %210
%211 = load i32, i32* %6
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds [100 x i32], [100 x i32]* %3, i64 0, i64 %212
%214 = load i32, i32* %213
store i32 %214, i32* %12
%215 = load i32, i32* %9
%216 = load i32, i32* %10
%217 = icmp ne i32 %215, %216
br i1 %217, label %218, label %219
218: ; preds = %206
store i32 1, i32* %8
br label %219
219: ; preds = %218, %206
%220 = load i32, i32* %9
%221 = load i32, i32* %11
%222 = icmp ne i32 %220, %221
br i1 %222, label %223, label %224
223: ; preds = %219
store i32 1, i32* %8
br label %224
224: ; preds = %223, %219
%225 = load i32, i32* %9
%226 = load i32, i32* %12
%227 = icmp ne i32 %225, %226
br i1 %227, label %228, label %229
228: ; preds = %224
store i32 1, i32* %8
br label %229
229: ; preds = %228, %224
br label %230
230: ; preds = %229, %154, %99
%231 = load i32, i32* %8
%232 = icmp eq i32 %231, 0
br i1 %232, label %233, label %235
233: ; preds = %230
%234 = call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
br label %235
235: ; preds = %233, %230
%236 = load i32, i32* %8
%237 = icmp eq i32 %236, 1
br i1 %237, label %238, label %240
238: ; preds = %235
%239 = call i32 @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.3, i64 0, i64 0))
br label %240
240: ; preds = %238, %235
ret i32 0
}

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