int mag(int (*m)[100][100], int a) {
  int sum = 0, z, k = 1, i;
  for (i = 0; i < a; i++)
    sum += (*m)[0][i];
  while (k < a) {
    for (i = 0, z = 0; i < a; i++)
      z += (*m)[k][i];
    k++;
    if (z != sum)
      return 0;
  }
  k = 0;
  while (k < a) {
    for (i = 0, z = 0; i < a; i++)
      z += (*m)[i][k];
    k++;
    if (z != sum)
      return 0;
  }
  for (k = 0, i = 0, z = 0; i < a; i++, k++)
    z += (*m)[i][k];
  if (z != sum)
    return 0;
  for (k = a - 1, i = 0, z = 0; i < a; i++, k--)
    z += (*m)[i][k];
  if (z != sum)
    return 0;
  return 1;
}


x86 assembly (clang, -O0):
<mag>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x1,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    114b <mag+0x4b>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1120 <mag+0x20>
jmp    1150 <mag+0x50>
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c9 <mag+0xc9>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11a3 <mag+0xa3>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    116a <mag+0x6a>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     11c4 <mag+0xc4>
movl   $0x0,-0x4(%rbp)
jmp    1330 <mag+0x230>
jmp    1150 <mag+0x50>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1249 <mag+0x149>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1223 <mag+0x123>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11ea <mag+0xea>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1244 <mag+0x144>
movl   $0x0,-0x4(%rbp)
jmp    1330 <mag+0x230>
jmp    11d0 <mag+0xd0>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a0 <mag+0x1a0>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    125e <mag+0x15e>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     12b8 <mag+0x1b8>
movl   $0x0,-0x4(%rbp)
jmp    1330 <mag+0x230>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1311 <mag+0x211>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
imul   $0x190,%rcx,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    12cf <mag+0x1cf>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
je     1329 <mag+0x229>
movl   $0x0,-0x4(%rbp)
jmp    1330 <mag+0x230>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<mag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
mov    %esi,%r12d
test   %esi,%esi
jle    112a <mag+0x2a>
cmp    $0x8,%esi
jae    1132 <mag+0x32>
xor    %ecx,%ecx
xor    %r15d,%r15d
jmp    1220 <mag+0x120>
xor    %r15d,%r15d
jmp    122d <mag+0x12d>
mov    %r12d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rbp
mov    %rbp,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ebx
and    $0x3,%ebx
cmp    $0x18,%rbp
jae    115e <mag+0x5e>
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
jmp    11c9 <mag+0xc9>
and    %rax,%rdx
pxor   %xmm0,%xmm0
xor    %ebp,%ebp
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rbp,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rdi,%rbp,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rdi,%rbp,4),%xmm1
movdqu 0x30(%rdi,%rbp,4),%xmm3
movdqu 0x40(%rdi,%rbp,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rdi,%rbp,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rdi,%rbp,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rdi,%rbp,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdx
jne    1170 <mag+0x70>
test   %rbx,%rbx
je     11fc <mag+0xfc>
lea    (%rdi,%rbp,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax)
movdqu -0x10(%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    11e0 <mag+0xe0>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%r15d
cmp    %r12,%rcx
je     122d <mag+0x12d>
nopl   0x0(%rax)
add    (%rdi,%rcx,4),%r15d
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1220 <mag+0x120>
cmp    $0x2,%esi
mov    $0x1,%r8d
cmovge %esi,%r8d
mov    %r12d,%r9d
and    $0xfffffff8,%r9d
lea    -0x8(%r9),%r10
mov    %r10,-0x10(%rsp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r13d
and    $0x3,%r13d
and    %rax,%r10
lea    0x200(%rdi),%rbx
mov    %r13,-0x8(%rsp)
shl    $0x5,%r13
mov    $0x1,%r14d
mov    %rdi,%rcx
xor    %eax,%eax
jmp    129b <mag+0x19b>
nopl   0x0(%rax)
add    $0x1,%r14
add    $0x190,%rbx
add    $0x190,%rcx
cmp    %r15d,%edx
jne    16c7 <mag+0x5c7>
cmp    %r8,%r14
je     13c5 <mag+0x2c5>
mov    $0x0,%edx
test   %esi,%esi
jle    1280 <mag+0x180>
cmp    $0x8,%esi
jae    12c0 <mag+0x1c0>
xor    %ebp,%ebp
xor    %edx,%edx
jmp    13b0 <mag+0x2b0>
nopl   0x0(%rax,%rax,1)
cmpq   $0x18,-0x10(%rsp)
jae    12d4 <mag+0x1d4>
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
jmp    1349 <mag+0x249>
pxor   %xmm0,%xmm0
mov    %r10,%r11
xor    %edx,%edx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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,%r11
jne    12f0 <mag+0x1f0>
cmpq   $0x0,-0x8(%rsp)
je     1383 <mag+0x283>
lea    (%rcx,%rdx,4),%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu 0x190(%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm0
movdqu 0x1a0(%rdx,%rbp,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rbp
cmp    %rbp,%r13
jne    1360 <mag+0x260>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
mov    %r9,%rbp
cmp    %r12,%r9
je     1280 <mag+0x180>
nopl   0x0(%rax)
add    0x190(%rcx,%rbp,4),%edx
add    $0x1,%rbp
cmp    %rbp,%r12
jne    13b0 <mag+0x2b0>
jmp    1280 <mag+0x180>
xor    %r11d,%r11d
test   %esi,%esi
mov    $0x0,%r10d
cmovg  %esi,%r10d
mov    %r12d,%r8d
and    $0xfffffff8,%r8d
lea    0xaf0(%rdi),%rcx
mov    %r12,%rax
shr    $0x3,%rax
mov    %rax,-0x10(%rsp)
imul   $0xc80,%rax,%r13
mov    %rdi,%r14
xor    %eax,%eax
jmp    1415 <mag+0x315>
nopl   0x0(%rax)
add    $0x1,%r11
add    $0x4,%rcx
add    $0x4,%r14
cmp    %r15d,%edx
jne    16c7 <mag+0x5c7>
cmp    %r10,%r11
je     1515 <mag+0x415>
mov    $0x0,%edx
test   %esi,%esi
jle    1400 <mag+0x300>
cmp    $0x8,%esi
jae    1440 <mag+0x340>
xor    %r9d,%r9d
xor    %edx,%edx
jmp    14e6 <mag+0x3e6>
cs nopw 0x0(%rax,%rax,1)
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
nopw   0x0(%rax,%rax,1)
movd   -0x640(%rcx,%rdx,1),%xmm2
ff ff
movd   -0x7d0(%rcx,%rdx,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x960(%rcx,%rdx,1),%xmm2
ff ff
movd   -0xaf0(%rcx,%rdx,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm0
movd   (%rcx,%rdx,1),%xmm2
movd   -0x190(%rcx,%rdx,1),%xmm3
ff ff
punpckldq %xmm2,%xmm3
movd   -0x320(%rcx,%rdx,1),%xmm2
ff ff
movd   -0x4b0(%rcx,%rdx,1),%xmm4
ff ff
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0xc80,%rdx
cmp    %rdx,%r13
jne    1450 <mag+0x350>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%edx
mov    %r8,%r9
cmp    %r12,%r8
je     1400 <mag+0x300>
imul   $0x190,%r9,%rbp
add    %r14,%rbp
mov    %r12,%rbx
sub    %r9,%rbx
cs nopw 0x0(%rax,%rax,1)
add    0x0(%rbp),%edx
add    $0x190,%rbp
add    $0xffffffffffffffff,%rbx
jne    1500 <mag+0x400>
jmp    1400 <mag+0x300>
test   %esi,%esi
jle    1527 <mag+0x427>
cmp    $0x8,%esi
jae    153c <mag+0x43c>
xor    %eax,%eax
xor    %ecx,%ecx
jmp    15ef <mag+0x4ef>
xor    %ecx,%ecx
mov    $0x0,%eax
test   %r15d,%r15d
jne    16c7 <mag+0x5c7>
jmp    16bf <mag+0x5bf>
mov    %r12d,%eax
and    $0xfffffff8,%eax
imul   $0xca0,-0x10(%rsp),%rcx
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
nop
movd   0x4bc(%rdi,%rdx,1),%xmm2
movd   0x328(%rdi,%rdx,1),%xmm3
punpckldq %xmm2,%xmm3
movd   0x194(%rdi,%rdx,1),%xmm2
movd   (%rdi,%rdx,1),%xmm4
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm0
movd   0xb0c(%rdi,%rdx,1),%xmm2
movd   0x978(%rdi,%rdx,1),%xmm3
punpckldq %xmm2,%xmm3
movd   0x7e4(%rdi,%rdx,1),%xmm2
movd   0x650(%rdi,%rdx,1),%xmm4
punpckldq %xmm2,%xmm4
punpcklqdq %xmm3,%xmm4
paddd  %xmm4,%xmm1
add    $0xca0,%rdx
cmp    %rdx,%rcx
jne    1560 <mag+0x460>
paddd  %xmm0,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ecx
cmp    %r12,%rax
je     160f <mag+0x50f>
imul   $0x194,%rax,%rdx
add    %rdi,%rdx
mov    %r12,%rbp
sub    %rax,%rbp
nop
add    (%rdx),%ecx
add    $0x194,%rdx
add    $0xffffffffffffffff,%rbp
jne    1600 <mag+0x500>
xor    %eax,%eax
cmp    %r15d,%ecx
jne    16c7 <mag+0x5c7>
test   %esi,%esi
jle    1635 <mag+0x535>
lea    -0x1(%r12),%rcx
mov    %r12d,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    163c <mag+0x53c>
xor    %edx,%edx
xor    %ecx,%ecx
jmp    168a <mag+0x58a>
xor    %ecx,%ecx
jmp    16bf <mag+0x5bf>
lea    (%rdi,%r12,4),%rsi
add    $0x4a0,%rsi
mov    %r12d,%ebp
and    $0xfffffffc,%ebp
neg    %rbp
xor    %edx,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    -0x4a4(%rsi),%ecx
add    -0x318(%rsi),%ecx
add    -0x18c(%rsi),%ecx
add    (%rsi),%ecx
add    $0x630,%rsi
add    $0xfffffffffffffffc,%rdx
cmp    %rdx,%rbp
jne    1660 <mag+0x560>
add    %rdx,%r12
neg    %rdx
test   %rax,%rax
je     16bf <mag+0x5bf>
imul   $0x190,%rdx,%rdx
add    %rdx,%rdi
lea    (%rdi,%r12,4),%rdx
add    $0xfffffffffffffffc,%rdx
imul   $0x18c,%rax,%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
add    (%rdx,%rsi,1),%ecx
add    $0x18c,%rsi
cmp    %rsi,%rax
jne    16b0 <mag+0x5b0>
xor    %eax,%eax
cmp    %r15d,%ecx
sete   %al
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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