#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);
int /*<<< orphan*/ scanf(char *, int *, ...);
int main() {
  int t, m, n, x, y, i, j, k, M[8][2] = {{1, 2}, {1, -2}, {-1, 2}, {-1, -2},
                                         {2, 1}, {2, -1}, {-2, 1}, {-2, -1}};
  scanf("%d", &t);
  while (t--) {
    scanf("%d%d", &n, &m);
    int b[n][n];
    for (i = 0; i < n; ++i)
      for (j = 0; j < n; ++j)
        b[i][j] = b[i][j] = 0;
    for (i = 0; i < m; ++i) {
      scanf("%d%d", &x, &y);
      for (j = 0; j < n; ++j)
        b[x - 1][j] = b[j][y - 1] |= 1 << 31;
      for (j = x - 1, k = y - 1; j < n && k < n; ++j, ++k)
        b[j][k] |= 1 << 31;
      for (j = x - 1, k = y - 1; j >= 0 && k < n; --j, ++k)
        b[j][k] |= 1 << 31;
      for (j = x - 1, k = y - 1; j < n && k >= 0; ++j, --k)
        b[j][k] |= 1 << 31;
      for (j = x - 1, k = y - 1; j >= 0 && k >= 0; --j, --k)
        b[j][k] |= 1 << 31;
      for (j = 0; j < 8; ++j)
        if (x - 1 + M[j][0] >= 0 && x - 1 + M[j][0] < n &&
            y - 1 + M[j][1] >= 0 && y - 1 + M[j][1] < n)
          b[x - 1 + M[j][0]][y - 1 + M[j][1]]++;
    }
    for (i = k = 0; i < n; ++i)
      for (j = 0; j < n; ++j)
        if ((!(b[i][j] & (1 << 31))) && ((b[i][j] & 0XFFFFF) > 1))
          k++;
    printf("%d\n", k);
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0x70(%rbp),%rdi
lea    0xeb3(%rip),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
lea    0xee4(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1050 <scanf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x8(%rbp)
cmp    $0x0,%eax
je     16d7 <main+0x5a7>
lea    0xebc(%rip),%rdi
xor    %eax,%eax
lea    -0x10(%rbp),%rsi
lea    -0xc(%rbp),%rdx
call   1050 <scanf@plt>
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,%rax
mov    %rax,-0x98(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x78(%rbp)
mov    %rcx,%rdx
imul   %rdx,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x90(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x80(%rbp)
mov    %rax,-0x88(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1263 <main+0x133>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1250 <main+0x120>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x1c(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x20(%rbp),%rsi
movl   $0x0,(%rcx,%rsi,4)
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11f1 <main+0xc1>
jmp    1255 <main+0x125>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11de <main+0xae>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15fc <main+0x4cc>
lea    0xdc3(%rip),%rdi
lea    -0x14(%rbp),%rsi
lea    -0x18(%rbp),%rdx
mov    $0x0,%al
call   1050 <scanf@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12fd <main+0x1cd>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rsi
movslq -0x20(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdi
mov    (%rcx,%rdi,4),%edx
or     $0x80000000,%edx
mov    %edx,(%rcx,%rdi,4)
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1293 <main+0x163>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0x99(%rbp)
jge    1332 <main+0x202>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
setl   %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    1345 <main+0x215>
jmp    1389 <main+0x259>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x80000000,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    130f <main+0x1df>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x20(%rbp)
mov    %al,-0x9a(%rbp)
jl     13bc <main+0x28c>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
setl   %al
mov    %al,-0x9a(%rbp)
mov    -0x9a(%rbp),%al
test   $0x1,%al
jne    13cf <main+0x29f>
jmp    1413 <main+0x2e3>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x80000000,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    139b <main+0x26b>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0x9b(%rbp)
jge    1446 <main+0x316>
cmpl   $0x0,-0x24(%rbp)
setge  %al
mov    %al,-0x9b(%rbp)
mov    -0x9b(%rbp),%al
test   $0x1,%al
jne    1459 <main+0x329>
jmp    149d <main+0x36d>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x80000000,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    1425 <main+0x2f5>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x20(%rbp)
mov    %al,-0x9c(%rbp)
jl     14ce <main+0x39e>
cmpl   $0x0,-0x24(%rbp)
setge  %al
mov    %al,-0x9c(%rbp)
mov    -0x9c(%rbp),%al
test   $0x1,%al
jne    14e1 <main+0x3b1>
jmp    1525 <main+0x3f5>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x20(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x80000000,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    14af <main+0x37f>
movl   $0x0,-0x20(%rbp)
cmpl   $0x8,-0x20(%rbp)
jge    15e9 <main+0x4b9>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
movslq -0x20(%rbp),%rcx
add    -0x70(%rbp,%rcx,8),%eax
cmp    $0x0,%eax
jl     15d6 <main+0x4a6>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
movslq -0x20(%rbp),%rcx
add    -0x70(%rbp,%rcx,8),%eax
cmp    -0x10(%rbp),%eax
jge    15d6 <main+0x4a6>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
movslq -0x20(%rbp),%rcx
add    -0x6c(%rbp,%rcx,8),%eax
cmp    $0x0,%eax
jl     15d6 <main+0x4a6>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
movslq -0x20(%rbp),%rcx
add    -0x6c(%rbp,%rcx,8),%eax
cmp    -0x10(%rbp),%eax
jge    15d6 <main+0x4a6>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x20(%rbp),%rsi
add    -0x70(%rbp,%rsi,8),%ecx
movslq %ecx,%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq -0x20(%rbp),%rdx
add    -0x6c(%rbp,%rdx,8),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    15db <main+0x4ab>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    152c <main+0x3fc>
jmp    15ee <main+0x4be>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    126a <main+0x13a>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16bc <main+0x58c>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16a9 <main+0x579>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x80000000,%eax
cmp    $0x0,%eax
jne    1696 <main+0x566>
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rdx
movslq -0x1c(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0xfffff,%eax
cmp    $0x1,%eax
jle    1696 <main+0x566>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    169b <main+0x56b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    161d <main+0x4ed>
jmp    16ae <main+0x57e>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    160a <main+0x4da>
mov    -0x24(%rbp),%esi
lea    0x97f(%rip),%rdi
call   1030 <printf@plt>
mov    -0x78(%rbp),%rax
mov    %rax,%rsp
jmp    1169 <main+0x39>
xor    %eax,%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
lea    0xed7(%rip),%rdi
lea    -0x70(%rbp),%rsi
xor    %eax,%eax
call   1050 <scanf@plt>
jmp    1178 <main+0x48>
nopl   0x0(%rax,%rax,1)
xor    %esi,%esi
mov    -0x88(%rbp),%r12
lea    0xeb5(%rip),%rdi
call   1030 <printf@plt>
mov    %r12,%rsp
subl   $0x1,-0x70(%rbp)
jb     19e7 <main+0x8b7>
lea    0xe97(%rip),%rdi
lea    -0x44(%rbp),%rsi
lea    -0x6c(%rbp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
mov    %rsp,-0x88(%rbp)
mov    -0x44(%rbp),%eax
mov    %rax,-0x78(%rbp)
imul   %rax,%rax
mov    %rsp,%r14
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r14
mov    %r14,%rsp
mov    -0x44(%rbp),%r15d
test   %r15d,%r15d
jle    1307 <main+0x1d7>
lea    0x0(,%r15,4),%rbx
lea    -0x1(%r15),%rax
mov    %r15d,%edx
and    $0x7,%edx
cmp    $0x7,%rax
mov    %rdx,-0x50(%rbp)
jae    11f0 <main+0xc0>
xor    %esi,%esi
jmp    12c9 <main+0x199>
nop
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x38(%rbp)
mov    -0x78(%rbp),%rdx
mov    %rdx,%rax
shl    $0x5,%rax
mov    %rax,-0x58(%rbp)
lea    0x0(,%rdx,4),%rax
mov    %rax,-0x60(%rbp)
mov    %r14,%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    %rax,-0x30(%rbp)
mov    %rsi,-0x40(%rbp)
mov    -0x30(%rbp),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    -0x60(%rbp),%r13
mov    -0x30(%rbp),%rax
lea    (%rax,%r13,1),%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    %r13,%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    %r13,%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    %r13,%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    %r13,%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    %r13,%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
add    %r13,%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1040 <memset@plt>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rsi
add    $0x8,%rsi
add    -0x58(%rbp),%rax
cmp    %rsi,-0x38(%rbp)
jne    1220 <main+0xf0>
mov    -0x50(%rbp),%r12
test   %r12,%r12
je     1307 <main+0x1d7>
mov    %rbx,%r13
mov    -0x78(%rbp),%rcx
imul   %rcx,%rsi
lea    (%r14,%rsi,4),%rbx
lea    0x0(,%rcx,4),%rcx
mov    %rcx,-0x30(%rbp)
nopl   (%rax)
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r13,%rdx
call   1040 <memset@plt>
add    -0x30(%rbp),%rbx
add    $0xffffffffffffffff,%r12
jne    12f0 <main+0x1c0>
cmpl   $0x0,-0x6c(%rbp)
movdqa 0xcfd(%rip),%xmm6
pxor   %xmm7,%xmm7
mov    -0x78(%rbp),%r13
jle    18e0 <main+0x7b0>
mov    %r13,%rsi
shl    $0x5,%rsi
lea    0x10(%r14),%rax
mov    %rax,-0xa0(%rbp)
mov    %r13,%rbx
shl    $0x6,%rbx
lea    0x30(%r14),%rax
mov    %rax,-0x90(%rbp)
lea    0x4(%r14),%rax
mov    %rax,-0xb0(%rbp)
lea    0x0(,%r13,4),%r12
lea    0x0(,%r13,8),%r10
lea    0x4(,%r13,4),%r8
xor    %r9d,%r9d
mov    %rbx,-0x98(%rbp)
mov    %rsi,-0xa8(%rbp)
mov    %r10,-0x80(%rbp)
mov    %r8,-0x50(%rbp)
jmp    139e <main+0x26e>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r9d
cmp    -0x6c(%rbp),%r9d
jge    18e0 <main+0x7b0>
mov    %r9d,-0x58(%rbp)
lea    0xc77(%rip),%rdi
lea    -0x68(%rbp),%rsi
lea    -0x64(%rbp),%rdx
xor    %eax,%eax
call   1050 <scanf@plt>
movslq -0x44(%rbp),%r15
test   %r15,%r15
jle    1450 <main+0x320>
mov    %r15d,%r8d
mov    -0x64(%rbp),%eax
mov    %rax,-0x30(%rbp)
add    $0xffffffff,%eax
mov    %rax,-0x40(%rbp)
movslq %eax,%rcx
mov    -0x68(%rbp),%edx
lea    -0x1(%rdx),%edi
movslq %edi,%rsi
mov    %rsi,%rbx
imul   %r13,%rbx
lea    (%r14,%rbx,4),%r11
lea    (%r14,%rcx,4),%rax
cmp    $0x8,%r15d
mov    %rdx,-0x60(%rbp)
jb     1479 <main+0x349>
mov    $0x0,%edx
cmp    $0x1,%r13d
movdqa 0xbf4(%rip),%xmm2
mov    $0x80000000,%r9d
movdqa 0xbf6(%rip),%xmm6
pxor   %xmm7,%xmm7
mov    -0x80(%rbp),%r10
jne    15d0 <main+0x4a0>
lea    (%rsi,%r8,1),%rdx
lea    (%r14,%rdx,4),%rdx
cmp    %rdx,%rax
jae    1496 <main+0x366>
lea    (%rcx,%r8,1),%rdx
lea    (%r14,%rdx,4),%rdx
lea    (%r14,%rsi,4),%rsi
cmp    %rdx,%rsi
jae    1496 <main+0x366>
xor    %edx,%edx
jmp    15d0 <main+0x4a0>
nopl   (%rax)
mov    -0x68(%rbp),%eax
mov    -0x64(%rbp),%ebx
lea    -0x1(%rax),%edi
lea    -0x1(%rbx),%ecx
mov    %rcx,-0x40(%rbp)
movdqa 0xba8(%rip),%xmm6
pxor   %xmm7,%xmm7
mov    -0x50(%rbp),%r8
mov    -0x58(%rbp),%r9d
jmp    1669 <main+0x539>
xor    %edx,%edx
mov    $0x80000000,%r9d
movdqa 0xb87(%rip),%xmm6
pxor   %xmm7,%xmm7
mov    -0x80(%rbp),%r10
jmp    15d0 <main+0x4a0>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
mov    %rdi,-0x38(%rbp)
mov    %rbx,-0xc8(%rbp)
mov    %r11,-0xc0(%rbp)
mov    %r9,-0xb8(%rbp)
je     1562 <main+0x432>
and    $0xfffffffffffffffe,%r9
mov    -0xa0(%rbp),%rsi
lea    (%rsi,%rcx,4),%rcx
mov    -0x90(%rbp),%rsi
lea    (%rsi,%rbx,4),%r11
xor    %r10d,%r10d
mov    -0xa8(%rbp),%rsi
mov    -0x98(%rbp),%rbx
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rcx),%xmm0
movdqu (%rcx),%xmm1
por    %xmm2,%xmm0
por    %xmm2,%xmm1
movdqu %xmm0,-0x10(%rcx)
movdqu %xmm1,(%rcx)
movdqu %xmm0,-0x30(%r11,%r10,4)
movdqu %xmm1,-0x20(%r11,%r10,4)
movdqu -0x10(%rcx,%rsi,1),%xmm0
movdqu (%rcx,%rsi,1),%xmm1
por    %xmm2,%xmm0
por    %xmm2,%xmm1
movdqu %xmm0,-0x10(%rcx,%rsi,1)
movdqu %xmm1,(%rcx,%rsi,1)
movdqu %xmm0,-0x10(%r11,%r10,4)
movdqu %xmm1,(%r11,%r10,4)
add    $0x10,%r10
add    %rbx,%rcx
add    $0xfffffffffffffffe,%r9
jne    1500 <main+0x3d0>
jmp    1565 <main+0x435>
xor    %r10d,%r10d
testb  $0x1,-0xb8(%rbp)
mov    -0xc0(%rbp),%r11
je     15a7 <main+0x477>
mov    %r10,%rcx
imul   %r13,%rcx
movdqu (%rax,%rcx,4),%xmm0
movdqu 0x10(%rax,%rcx,4),%xmm1
por    %xmm2,%xmm0
por    %xmm2,%xmm1
movdqu %xmm0,(%rax,%rcx,4)
movdqu %xmm1,0x10(%rax,%rcx,4)
movdqu %xmm0,(%r11,%r10,4)
movdqu %xmm1,0x10(%r11,%r10,4)
cmp    %r8,%rdx
mov    $0x80000000,%r9d
mov    -0x80(%rbp),%r10
mov    -0x38(%rbp),%rdi
mov    -0xc8(%rbp),%rbx
je     15fc <main+0x4cc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdx,%rcx
test   $0x1,%r8b
je     15f4 <main+0x4c4>
mov    %rdx,%rcx
imul   %r13,%rcx
mov    (%rax,%rcx,4),%esi
or     %r9d,%esi
mov    %esi,(%rax,%rcx,4)
mov    %esi,(%r11,%rdx,4)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
add    %r8,%rdx
jne    1610 <main+0x4e0>
mov    -0x50(%rbp),%r8
mov    -0x58(%rbp),%r9d
jmp    1661 <main+0x531>
cs nopw 0x0(%rax,%rax,1)
mov    %rdi,-0x38(%rbp)
mov    -0xb0(%rbp),%rdx
lea    (%rdx,%rbx,4),%rdx
mov    %r12,%rsi
imul   %rcx,%rsi
lea    0x1(%rcx),%rbx
imul   %r12,%rbx
xchg   %ax,%ax
mov    (%rax,%rsi,1),%edi
or     %r9d,%edi
mov    %edi,(%rax,%rsi,1)
mov    %edi,-0x4(%rdx,%rcx,4)
mov    (%rax,%rbx,1),%edi
or     %r9d,%edi
mov    %edi,(%rax,%rbx,1)
mov    %edi,(%rdx,%rcx,4)
add    $0x2,%rcx
add    %r10,%rax
cmp    %rcx,%r8
jne    1630 <main+0x500>
mov    -0x50(%rbp),%r8
mov    -0x58(%rbp),%r9d
mov    -0x38(%rbp),%rdi
mov    -0x30(%rbp),%rbx
mov    -0x60(%rbp),%rax
mov    %rax,%r11
cmp    %r15d,%eax
jg     16bc <main+0x58c>
cmp    %r15d,%ebx
jg     16bc <main+0x58c>
movslq %edi,%rax
movslq -0x40(%rbp),%rcx
mov    %r13,%rdx
imul   %rax,%rdx
add    %rcx,%rdx
lea    (%r14,%rdx,4),%rdx
add    $0x1,%rcx
add    $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
orb    $0x80,0x3(%rdx)
cmp    %r15,%rax
jge    16bc <main+0x58c>
add    %r8,%rdx
lea    0x1(%rcx),%rsi
add    $0x1,%rax
cmp    %r15,%rcx
mov    %rsi,%rcx
jl     16a0 <main+0x570>
mov    %rdi,-0x38(%rbp)
test   %r11d,%r11d
jle    1708 <main+0x5d8>
cmp    %r15d,%ebx
jg     1708 <main+0x5d8>
mov    %r11,%rsi
mov    %esi,%eax
movslq -0x40(%rbp),%rcx
lea    (%r14,%rcx,4),%rdx
lea    -0x1(%r11),%edi
add    $0x1,%rcx
nop
mov    %edi,%esi
imul   %r13,%rsi
orb    $0x80,0x3(%rdx,%rsi,4)
cmp    $0x2,%rax
jb     1708 <main+0x5d8>
add    $0xffffffffffffffff,%rax
add    $0x4,%rdx
add    $0xffffffff,%edi
lea    0x1(%rcx),%rsi
cmp    %r15,%rcx
mov    %rsi,%rcx
jl     16e0 <main+0x5b0>
cmp    %r15d,%r11d
jg     1753 <main+0x623>
test   %ebx,%ebx
jle    1753 <main+0x623>
mov    %ebx,%ecx
movslq -0x38(%rbp),%rax
mov    %r13,%rdx
imul   %rax,%rdx
lea    (%r14,%rdx,4),%rdx
lea    -0x1(%rbx),%edi
add    $0x1,%rax
nopl   0x0(%rax)
mov    %edi,%esi
orb    $0x80,0x3(%rdx,%rsi,4)
cmp    %r15,%rax
jge    1753 <main+0x623>
lea    -0x1(%rcx),%rsi
add    %r12,%rdx
add    $0xffffffff,%edi
add    $0x1,%rax
cmp    $0x1,%rcx
mov    %rsi,%rcx
ja     1730 <main+0x600>
mov    %rbx,-0x30(%rbp)
test   %r11d,%r11d
jle    179b <main+0x66b>
cmpl   $0x0,-0x30(%rbp)
jle    179b <main+0x66b>
mov    -0x30(%rbp),%eax
mov    %r11d,%ecx
nopl   0x0(%rax,%rax,1)
mov    %rcx,%rsi
add    $0xffffffffffffffff,%rcx
lea    -0x1(%rax),%rdx
mov    %ecx,%edi
imul   %r13,%rdi
lea    (%r14,%rdi,4),%rdi
mov    %edx,%ebx
orb    $0x80,0x3(%rdi,%rbx,4)
cmp    $0x2,%rsi
jb     179b <main+0x66b>
cmp    $0x1,%rax
mov    %rdx,%rax
ja     1770 <main+0x640>
test   %r11d,%r11d
mov    -0x38(%rbp),%rdi
mov    -0x40(%rbp),%rdx
js     17e9 <main+0x6b9>
cmp    %r15d,%r11d
jge    17e9 <main+0x6b9>
cmp    $0xfffffffe,%edx
jl     17cb <main+0x69b>
lea    0x2(%rdx),%eax
cmp    %r15d,%eax
jge    17cb <main+0x69b>
mov    %r11d,%ecx
imul   %r13,%rcx
lea    (%r14,%rcx,4),%rcx
mov    %eax,%eax
addl   $0x1,(%rcx,%rax,4)
cmp    $0x2,%edx
jl     17e9 <main+0x6b9>
lea    -0x2(%rdx),%eax
cmp    %r15d,%eax
jge    17e9 <main+0x6b9>
mov    %r11d,%ecx
imul   %r13,%rcx
lea    (%r14,%rcx,4),%rcx
mov    %eax,%eax
addl   $0x1,(%rcx,%rax,4)
test   %edi,%edi
jle    1833 <main+0x703>
cmp    %r15d,%edi
jg     1833 <main+0x703>
lea    -0x1(%rdi),%eax
cmp    $0xfffffffe,%edx
jl     1816 <main+0x6e6>
lea    0x2(%rdx),%ecx
cmp    %r15d,%ecx
jge    1816 <main+0x6e6>
mov    %eax,%edx
imul   %r13,%rdx
lea    (%r14,%rdx,4),%rdx
mov    %ecx,%ecx
addl   $0x1,(%rdx,%rcx,4)
mov    -0x40(%rbp),%rdx
cmp    $0x2,%edx
jl     1833 <main+0x703>
lea    -0x2(%rdx),%ecx
cmp    %r15d,%ecx
jge    1833 <main+0x703>
mov    %eax,%eax
imul   %r13,%rax
lea    (%r14,%rax,4),%rax
mov    %ecx,%ecx
addl   $0x1,(%rax,%rcx,4)
cmp    $0xfffffffe,%edi
jl     187b <main+0x74b>
lea    0x2(%rdi),%eax
cmp    %r15d,%eax
jge    187b <main+0x74b>
mov    -0x30(%rbp),%rdx
test   %edx,%edx
js     185d <main+0x72d>
cmp    %r15d,%edx
jge    185d <main+0x72d>
mov    %eax,%ecx
imul   %r13,%rcx
lea    (%r14,%rcx,4),%rcx
mov    %edx,%edx
addl   $0x1,(%rcx,%rdx,4)
mov    -0x40(%rbp),%rdx
test   %edx,%edx
jle    187b <main+0x74b>
cmp    %r15d,%edx
jg     187b <main+0x74b>
lea    -0x1(%rdx),%ecx
mov    %eax,%eax
imul   %r13,%rax
lea    (%r14,%rax,4),%rax
addl   $0x1,(%rax,%rcx,4)
cmp    $0x2,%edi
jl     1390 <main+0x260>
add    $0xfffffffe,%edi
cmp    %r15d,%edi
jge    1390 <main+0x260>
mov    -0x30(%rbp),%rcx
test   %ecx,%ecx
js     18ad <main+0x77d>
cmp    %r15d,%ecx
jge    18ad <main+0x77d>
mov    %edi,%eax
imul   %r13,%rax
lea    (%r14,%rax,4),%rax
mov    %ecx,%ecx
addl   $0x1,(%rax,%rcx,4)
test   %edx,%edx
jle    1390 <main+0x260>
cmp    %r15d,%edx
jg     1390 <main+0x260>
add    $0xffffffff,%edx
mov    %edi,%eax
imul   %r13,%rax
lea    (%r14,%rax,4),%rax
addl   $0x1,(%rax,%rdx,4)
jmp    1390 <main+0x260>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r15d,%r15d
jle    1160 <main+0x30>
mov    %r15d,%edi
mov    %edi,%r8d
and    $0xfffffff8,%r8d
lea    0x10(%r14),%rdx
shl    $0x2,%r13
lea    0x0(,%rdi,4),%r10
and    $0xffffffffffffffe0,%r10
xor    %r9d,%r9d
xor    %esi,%esi
mov    -0x88(%rbp),%r12
jmp    1933 <main+0x803>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r9
add    %r13,%rdx
add    %r13,%r14
cmp    %rdi,%r9
je     1169 <main+0x39>
cmp    $0x8,%r15d
jae    1940 <main+0x810>
xor    %ecx,%ecx
jmp    19c0 <main+0x890>
movd   %esi,%xmm1
pxor   %xmm0,%xmm0
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rsi,1),%xmm2
movdqu (%rdx,%rsi,1),%xmm3
movdqa %xmm2,%xmm4
pand   %xmm6,%xmm4
movdqa %xmm3,%xmm5
pand   %xmm6,%xmm5
pcmpgtd %xmm7,%xmm4
pcmpgtd %xmm7,%xmm5
psrad  $0x1f,%xmm2
pandn  %xmm4,%xmm2
psubd  %xmm2,%xmm1
psrad  $0x1f,%xmm3
pandn  %xmm5,%xmm3
psubd  %xmm3,%xmm0
add    $0x20,%rsi
cmp    %rsi,%r10
jne    1950 <main+0x820>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
mov    %r8,%rcx
cmp    %rdi,%r8
je     1920 <main+0x7f0>
nopl   0x0(%rax)
mov    (%r14,%rcx,4),%ebx
test   %ebx,%ebx
setns  %al
test   $0xffffe,%ebx
setne  %bl
and    %al,%bl
movzbl %bl,%eax
add    %eax,%esi
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    19c0 <main+0x890>
jmp    1920 <main+0x7f0>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [5 x i8] c"%d%d\00"
@.str.2 = [4 x i8] c"%d\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca i32
%6 = bitcast i32* %1 to i8*
%7 = bitcast i32* %2 to i8*
%8 = bitcast i32* %3 to i8*
%9 = bitcast i32* %4 to i8*
%10 = bitcast i32* %5 to i8*
%11 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %1)
%12 = load i32, i32* %1
%13 = add nsw i32 %12, -1
store i32 %13, i32* %1
%14 = icmp eq i32 %12, 0
br i1 %14, label %496, label %15
15: ; preds = %0, %490
%16 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32* %3, i32* %2)
%17 = load i32, i32* %3
%18 = zext i32 %17 to i64
%19 = call i8* @llvm.stacksave()
%20 = mul nuw i64 %18, %18
%21 = alloca i32, i64 %20
%22 = load i32, i32* %3
%23 = icmp sgt i32 %22, 0
br i1 %23, label %24, label %44
24: ; preds = %15
%25 = zext i32 %22 to i64
%26 = shl nuw nsw i64 %25, 2
%27 = add nsw i64 %25, -1
%28 = and i64 %25, 7
%29 = icmp ult i64 %27, 7
br i1 %29, label %32, label %30
30: ; preds = %24
%31 = and i64 %25, 4294967288
br label %49
32: ; preds = %49, %24
%33 = phi i64 [ 0, %24 ], [ %83, %49 ]
%34 = icmp eq i64 %28, 0
br i1 %34, label %44, label %35
35: ; preds = %32, %35
%36 = phi i64 [ %41, %35 ], [ %33, %32 ]
%37 = phi i64 [ %42, %35 ], [ 0, %32 ]
%38 = mul nuw nsw i64 %36, %18
%39 = getelementptr i32, i32* %21, i64 %38
%40 = bitcast i32* %39 to i8*
%41 = add nuw nsw i64 %36, 1
%42 = add i64 %37, 1
%43 = icmp eq i64 %42, %28
br i1 %43, label %44, label %35
44: ; preds = %32, %35, %15
%45 = load i32, i32* %2
%46 = icmp sgt i32 %45, 0
br i1 %46, label %47, label %86
47: ; preds = %44
%48 = icmp eq i32 %17, 1
br label %94
49: ; preds = %49, %30
%50 = phi i64 [ 0, %30 ], [ %83, %49 ]
%51 = phi i64 [ 0, %30 ], [ %84, %49 ]
%52 = mul nuw nsw i64 %50, %18
%53 = getelementptr i32, i32* %21, i64 %52
%54 = bitcast i32* %53 to i8*
%55 = or i64 %50, 1
%56 = mul nuw nsw i64 %55, %18
%57 = getelementptr i32, i32* %21, i64 %56
%58 = bitcast i32* %57 to i8*
%59 = or i64 %50, 2
%60 = mul nuw nsw i64 %59, %18
%61 = getelementptr i32, i32* %21, i64 %60
%62 = bitcast i32* %61 to i8*
%63 = or i64 %50, 3
%64 = mul nuw nsw i64 %63, %18
%65 = getelementptr i32, i32* %21, i64 %64
%66 = bitcast i32* %65 to i8*
%67 = or i64 %50, 4
%68 = mul nuw nsw i64 %67, %18
%69 = getelementptr i32, i32* %21, i64 %68
%70 = bitcast i32* %69 to i8*
%71 = or i64 %50, 5
%72 = mul nuw nsw i64 %71, %18
%73 = getelementptr i32, i32* %21, i64 %72
%74 = bitcast i32* %73 to i8*
%75 = or i64 %50, 6
%76 = mul nuw nsw i64 %75, %18
%77 = getelementptr i32, i32* %21, i64 %76
%78 = bitcast i32* %77 to i8*
%79 = or i64 %50, 7
%80 = mul nuw nsw i64 %79, %18
%81 = getelementptr i32, i32* %21, i64 %80
%82 = bitcast i32* %81 to i8*
%83 = add nuw nsw i64 %50, 8
%84 = add i64 %51, 8
%85 = icmp eq i64 %84, %31
br i1 %85, label %32, label %49
86: ; preds = %432, %44
%87 = phi i32 [ %22, %44 ], [ %97, %432 ]
%88 = icmp sgt i32 %87, 0
br i1 %88, label %89, label %490
89: ; preds = %86
%90 = zext i32 %87 to i64
%91 = icmp ult i32 %87, 8
%92 = and i64 %90, 4294967288
%93 = icmp eq i64 %92, %90
br label %436
94: ; preds = %47, %432
%95 = phi i32 [ %433, %432 ], [ 0, %47 ]
%96 = call i32 (i8*, i32*, ...) @scanf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i32* %4, i32* %5)
%97 = load i32, i32* %3
%98 = icmp sgt i32 %97, 0
br i1 %98, label %104, label %99
99: ; preds = %94
%100 = load i32, i32* %4
%101 = load i32, i32* %5
%102 = add i32 %100, -1
%103 = add i32 %101, -1
br label %224
104: ; preds = %94
%105 = load i32, i32* %5
%106 = add i32 %105, -1
%107 = sext i32 %106 to i64
%108 = load i32, i32* %4
%109 = add i32 %108, -1
%110 = sext i32 %109 to i64
%111 = mul nsw i64 %110, %18
%112 = getelementptr inbounds i32, i32* %21, i64 %111
%113 = zext i32 %97 to i64
%114 = getelementptr inbounds i32, i32* %21, i64 %107
%115 = icmp ugt i32 %97, 7
%116 = select i1 %115, i1 %48, i1 false
br i1 %116, label %117, label %193
117: ; preds = %104
%118 = add nsw i64 %107, %113
%119 = getelementptr i32, i32* %21, i64 %118
%120 = getelementptr i32, i32* %21, i64 %110
%121 = add nsw i64 %110, %113
%122 = getelementptr i32, i32* %21, i64 %121
%123 = icmp ult i32* %114, %122
%124 = icmp ult i32* %120, %119
%125 = and i1 %123, %124
br i1 %125, label %193, label %126
126: ; preds = %117
%127 = and i64 %113, 4294967288
%128 = add nsw i64 %127, -8
%129 = lshr exact i64 %128, 3
%130 = add nuw nsw i64 %129, 1
%131 = and i64 %130, 1
%132 = icmp eq i64 %128, 0
br i1 %132, label %172, label %133
133: ; preds = %126
%134 = and i64 %130, 4611686018427387902
br label %135
135: ; preds = %135, %133
%136 = phi i64 [ 0, %133 ], [ %169, %135 ]
%137 = phi i64 [ 0, %133 ], [ %170, %135 ]
%138 = mul nuw nsw i64 %136, %18
%139 = getelementptr inbounds i32, i32* %114, i64 %138
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = getelementptr inbounds i32, i32* %139, i64 4
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = or <4 x i32> %141, <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>
%146 = or <4 x i32> %144, <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>
%147 = bitcast i32* %139 to <4 x i32>*
store <4 x i32> %145, <4 x i32>* %147
%148 = bitcast i32* %142 to <4 x i32>*
store <4 x i32> %146, <4 x i32>* %148
%149 = getelementptr inbounds i32, i32* %112, i64 %136
%150 = bitcast i32* %149 to <4 x i32>*
store <4 x i32> %145, <4 x i32>* %150
%151 = getelementptr inbounds i32, i32* %149, i64 4
%152 = bitcast i32* %151 to <4 x i32>*
store <4 x i32> %146, <4 x i32>* %152
%153 = or i64 %136, 8
%154 = mul nuw nsw i64 %153, %18
%155 = getelementptr inbounds i32, i32* %114, i64 %154
%156 = bitcast i32* %155 to <4 x i32>*
%157 = load <4 x i32>, <4 x i32>* %156
%158 = getelementptr inbounds i32, i32* %155, i64 4
%159 = bitcast i32* %158 to <4 x i32>*
%160 = load <4 x i32>, <4 x i32>* %159
%161 = or <4 x i32> %157, <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>
%162 = or <4 x i32> %160, <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>
%163 = bitcast i32* %155 to <4 x i32>*
store <4 x i32> %161, <4 x i32>* %163
%164 = bitcast i32* %158 to <4 x i32>*
store <4 x i32> %162, <4 x i32>* %164
%165 = getelementptr inbounds i32, i32* %112, i64 %153
%166 = bitcast i32* %165 to <4 x i32>*
store <4 x i32> %161, <4 x i32>* %166
%167 = getelementptr inbounds i32, i32* %165, i64 4
%168 = bitcast i32* %167 to <4 x i32>*
store <4 x i32> %162, <4 x i32>* %168
%169 = add nuw i64 %136, 16
%170 = add i64 %137, 2
%171 = icmp eq i64 %170, %134
br i1 %171, label %172, label %135
172: ; preds = %135, %126
%173 = phi i64 [ 0, %126 ], [ %169, %135 ]
%174 = icmp eq i64 %131, 0
br i1 %174, label %191, label %175
175: ; preds = %172
%176 = mul nuw nsw i64 %173, %18
%177 = getelementptr inbounds i32, i32* %114, i64 %176
%178 = bitcast i32* %177 to <4 x i32>*
%179 = load <4 x i32>, <4 x i32>* %178
%180 = getelementptr inbounds i32, i32* %177, i64 4
%181 = bitcast i32* %180 to <4 x i32>*
%182 = load <4 x i32>, <4 x i32>* %181
%183 = or <4 x i32> %179, <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>
%184 = or <4 x i32> %182, <i32 -2147483648, i32 -2147483648, i32 -2147483648, i32 -2147483648>
%185 = bitcast i32* %177 to <4 x i32>*
store <4 x i32> %183, <4 x i32>* %185
%186 = bitcast i32* %180 to <4 x i32>*
store <4 x i32> %184, <4 x i32>* %186
%187 = getelementptr inbounds i32, i32* %112, i64 %173
%188 = bitcast i32* %187 to <4 x i32>*
store <4 x i32> %183, <4 x i32>* %188
%189 = getelementptr inbounds i32, i32* %187, i64 4
%190 = bitcast i32* %189 to <4 x i32>*
store <4 x i32> %184, <4 x i32>* %190
br label %191
191: ; preds = %172, %175
%192 = icmp eq i64 %127, %113
br i1 %192, label %224, label %193
193: ; preds = %117, %104, %191
%194 = phi i64 [ 0, %117 ], [ 0, %104 ], [ %127, %191 ]
%195 = xor i64 %194, -1
%196 = and i64 %113, 1
%197 = icmp eq i64 %196, 0
br i1 %197, label %205, label %198
198: ; preds = %193
%199 = mul nuw nsw i64 %194, %18
%200 = getelementptr inbounds i32, i32* %114, i64 %199
%201 = load i32, i32* %200
%202 = or i32 %201, -2147483648
store i32 %202, i32* %200
%203 = getelementptr inbounds i32, i32* %112, i64 %194
store i32 %202, i32* %203
%204 = or i64 %194, 1
br label %205
205: ; preds = %198, %193
%206 = phi i64 [ %194, %193 ], [ %204, %198 ]
%207 = sub nsw i64 0, %113
%208 = icmp eq i64 %195, %207
br i1 %208, label %224, label %209
209: ; preds = %205, %209
%210 = phi i64 [ %222, %209 ], [ %206, %205 ]
%211 = mul nuw nsw i64 %210, %18
%212 = getelementptr inbounds i32, i32* %114, i64 %211
%213 = load i32, i32* %212
%214 = or i32 %213, -2147483648
store i32 %214, i32* %212
%215 = getelementptr inbounds i32, i32* %112, i64 %210
store i32 %214, i32* %215
%216 = add nuw nsw i64 %210, 1
%217 = mul nuw nsw i64 %216, %18
%218 = getelementptr inbounds i32, i32* %114, i64 %217
%219 = load i32, i32* %218
%220 = or i32 %219, -2147483648
store i32 %220, i32* %218
%221 = getelementptr inbounds i32, i32* %112, i64 %216
store i32 %220, i32* %221
%222 = add nuw nsw i64 %210, 2
%223 = icmp eq i64 %222, %113
br i1 %223, label %224, label %209
224: ; preds = %205, %209, %191, %99
%225 = phi i32 [ %103, %99 ], [ %106, %191 ], [ %106, %209 ], [ %106, %205 ]
%226 = phi i32 [ %102, %99 ], [ %109, %191 ], [ %109, %209 ], [ %109, %205 ]
%227 = phi i32 [ %101, %99 ], [ %105, %191 ], [ %105, %209 ], [ %105, %205 ]
%228 = phi i32 [ %100, %99 ], [ %108, %191 ], [ %108, %209 ], [ %108, %205 ]
%229 = icmp sle i32 %228, %97
%230 = icmp sle i32 %227, %97
%231 = select i1 %229, i1 %230, i1 false
br i1 %231, label %232, label %236
232: ; preds = %224
%233 = sext i32 %226 to i64
%234 = sext i32 %97 to i64
%235 = sext i32 %225 to i64
br label %243
236: ; preds = %243, %224
%237 = icmp sgt i32 %228, 0
%238 = select i1 %237, i1 %230, i1 false
br i1 %238, label %239, label %256
239: ; preds = %236
%240 = zext i32 %228 to i64
%241 = sext i32 %225 to i64
%242 = sext i32 %97 to i64
br label %263
243: ; preds = %232, %243
%244 = phi i64 [ %235, %232 ], [ %252, %243 ]
%245 = phi i64 [ %233, %232 ], [ %251, %243 ]
%246 = mul nsw i64 %245, %18
%247 = getelementptr inbounds i32, i32* %21, i64 %246
%248 = getelementptr inbounds i32, i32* %247, i64 %244
%249 = load i32, i32* %248
%250 = or i32 %249, -2147483648
store i32 %250, i32* %248
%251 = add nsw i64 %245, 1
%252 = add nsw i64 %244, 1
%253 = icmp slt i64 %251, %234
%254 = icmp slt i64 %252, %234
%255 = select i1 %253, i1 %254, i1 false
br i1 %255, label %243, label %236
256: ; preds = %263, %236
%257 = icmp sgt i32 %227, 0
%258 = select i1 %229, i1 %257, i1 false
br i1 %258, label %259, label %277
259: ; preds = %256
%260 = zext i32 %227 to i64
%261 = sext i32 %226 to i64
%262 = sext i32 %97 to i64
br label %282
263: ; preds = %239, %263
%264 = phi i64 [ %241, %239 ], [ %273, %263 ]
%265 = phi i64 [ %240, %239 ], [ %266, %263 ]
%266 = add nsw i64 %265, -1
%267 = and i64 %266, 4294967295
%268 = mul nuw nsw i64 %267, %18
%269 = getelementptr inbounds i32, i32* %21, i64 %268
%270 = getelementptr inbounds i32, i32* %269, i64 %264
%271 = load i32, i32* %270
%272 = or i32 %271, -2147483648
store i32 %272, i32* %270
%273 = add nsw i64 %264, 1
%274 = icmp ugt i64 %265, 1
%275 = icmp slt i64 %273, %242
%276 = select i1 %274, i1 %275, i1 false
br i1 %276, label %263, label %256
277: ; preds = %282, %256
%278 = select i1 %237, i1 %257, i1 false
br i1 %278, label %279, label %296
279: ; preds = %277
%280 = zext i32 %227 to i64
%281 = zext i32 %228 to i64
br label %300
282: ; preds = %259, %282
%283 = phi i64 [ %261, %259 ], [ %292, %282 ]
%284 = phi i64 [ %260, %259 ], [ %285, %282 ]
%285 = add nsw i64 %284, -1
%286 = mul nsw i64 %283, %18
%287 = getelementptr inbounds i32, i32* %21, i64 %286
%288 = and i64 %285, 4294967295
%289 = getelementptr inbounds i32, i32* %287, i64 %288
%290 = load i32, i32* %289
%291 = or i32 %290, -2147483648
store i32 %291, i32* %289
%292 = add nsw i64 %283, 1
%293 = icmp slt i64 %292, %262
%294 = icmp ugt i64 %284, 1
%295 = select i1 %293, i1 %294, i1 false
br i1 %295, label %282, label %277
296: ; preds = %300, %277
%297 = icmp sgt i32 %228, -1
%298 = icmp slt i32 %228, %97
%299 = select i1 %297, i1 %298, i1 false
br i1 %299, label %315, label %341
300: ; preds = %279, %300
%301 = phi i64 [ %281, %279 ], [ %303, %300 ]
%302 = phi i64 [ %280, %279 ], [ %304, %300 ]
%303 = add nsw i64 %301, -1
%304 = add nsw i64 %302, -1
%305 = and i64 %303, 4294967295
%306 = mul nuw nsw i64 %305, %18
%307 = getelementptr inbounds i32, i32* %21, i64 %306
%308 = and i64 %304, 4294967295
%309 = getelementptr inbounds i32, i32* %307, i64 %308
%310 = load i32, i32* %309
%311 = or i32 %310, -2147483648
store i32 %311, i32* %309
%312 = icmp ugt i64 %301, 1
%313 = icmp ugt i64 %302, 1
%314 = select i1 %312, i1 %313, i1 false
br i1 %314, label %300, label %296
315: ; preds = %296
%316 = add nsw i32 %225, 2
%317 = icmp sgt i32 %225, -3
%318 = icmp slt i32 %316, %97
%319 = select i1 %317, i1 %318, i1 false
br i1 %319, label %320, label %328
320: ; preds = %315
%321 = zext i32 %228 to i64
%322 = mul nuw nsw i64 %321, %18
%323 = getelementptr inbounds i32, i32* %21, i64 %322
%324 = zext i32 %316 to i64
%325 = getelementptr inbounds i32, i32* %323, i64 %324
%326 = load i32, i32* %325
%327 = add nsw i32 %326, 1
store i32 %327, i32* %325
br label %328
328: ; preds = %315, %320
%329 = add nsw i32 %225, -2
%330 = icmp sgt i32 %225, 1
%331 = icmp slt i32 %329, %97
%332 = select i1 %330, i1 %331, i1 false
br i1 %332, label %333, label %341
333: ; preds = %328
%334 = zext i32 %228 to i64
%335 = mul nuw nsw i64 %334, %18
%336 = getelementptr inbounds i32, i32* %21, i64 %335
%337 = zext i32 %329 to i64
%338 = getelementptr inbounds i32, i32* %336, i64 %337
%339 = load i32, i32* %338
%340 = add nsw i32 %339, 1
store i32 %340, i32* %338
br label %341
341: ; preds = %296, %333, %328
%342 = add nsw i32 %226, -1
%343 = icmp sgt i32 %226, 0
%344 = icmp sle i32 %226, %97
%345 = select i1 %343, i1 %344, i1 false
br i1 %345, label %346, label %372
346: ; preds = %341
%347 = add nsw i32 %225, 2
%348 = icmp sgt i32 %225, -3
%349 = icmp slt i32 %347, %97
%350 = select i1 %348, i1 %349, i1 false
br i1 %350, label %351, label %359
351: ; preds = %346
%352 = zext i32 %342 to i64
%353 = mul nuw nsw i64 %352, %18
%354 = getelementptr inbounds i32, i32* %21, i64 %353
%355 = zext i32 %347 to i64
%356 = getelementptr inbounds i32, i32* %354, i64 %355
%357 = load i32, i32* %356
%358 = add nsw i32 %357, 1
store i32 %358, i32* %356
br label %359
359: ; preds = %351, %346
%360 = add nsw i32 %225, -2
%361 = icmp sgt i32 %225, 1
%362 = icmp slt i32 %360, %97
%363 = select i1 %361, i1 %362, i1 false
br i1 %363, label %364, label %372
364: ; preds = %359
%365 = zext i32 %342 to i64
%366 = mul nuw nsw i64 %365, %18
%367 = getelementptr inbounds i32, i32* %21, i64 %366
%368 = zext i32 %360 to i64
%369 = getelementptr inbounds i32, i32* %367, i64 %368
%370 = load i32, i32* %369
%371 = add nsw i32 %370, 1
store i32 %371, i32* %369
br label %372
372: ; preds = %341, %364, %359
%373 = add nsw i32 %226, 2
%374 = icmp sgt i32 %226, -3
%375 = icmp slt i32 %373, %97
%376 = select i1 %374, i1 %375, i1 false
br i1 %376, label %377, label %402
377: ; preds = %372
%378 = icmp sgt i32 %227, -1
%379 = icmp slt i32 %227, %97
%380 = select i1 %378, i1 %379, i1 false
br i1 %380, label %381, label %389
381: ; preds = %377
%382 = zext i32 %373 to i64
%383 = mul nuw nsw i64 %382, %18
%384 = getelementptr inbounds i32, i32* %21, i64 %383
%385 = zext i32 %227 to i64
%386 = getelementptr inbounds i32, i32* %384, i64 %385
%387 = load i32, i32* %386
%388 = add nsw i32 %387, 1
store i32 %388, i32* %386
br label %389
389: ; preds = %381, %377
%390 = icmp sgt i32 %225, 0
%391 = icmp sle i32 %225, %97
%392 = select i1 %390, i1 %391, i1 false
br i1 %392, label %393, label %402
393: ; preds = %389
%394 = add nsw i32 %225, -1
%395 = zext i32 %373 to i64
%396 = mul nuw nsw i64 %395, %18
%397 = getelementptr inbounds i32, i32* %21, i64 %396
%398 = zext i32 %394 to i64
%399 = getelementptr inbounds i32, i32* %397, i64 %398
%400 = load i32, i32* %399
%401 = add nsw i32 %400, 1
store i32 %401, i32* %399
br label %402
402: ; preds = %372, %393, %389
%403 = add nsw i32 %226, -2
%404 = icmp sgt i32 %226, 1
%405 = icmp slt i32 %403, %97
%406 = select i1 %404, i1 %405, i1 false
br i1 %406, label %407, label %432
407: ; preds = %402
%408 = icmp sgt i32 %227, -1
%409 = icmp slt i32 %227, %97
%410 = select i1 %408, i1 %409, i1 false
br i1 %410, label %411, label %419
411: ; preds = %407
%412 = zext i32 %403 to i64
%413 = mul nuw nsw i64 %412, %18
%414 = getelementptr inbounds i32, i32* %21, i64 %413
%415 = zext i32 %227 to i64
%416 = getelementptr inbounds i32, i32* %414, i64 %415
%417 = load i32, i32* %416
%418 = add nsw i32 %417, 1
store i32 %418, i32* %416
br label %419
419: ; preds = %411, %407
%420 = icmp sgt i32 %225, 0
%421 = icmp sle i32 %225, %97
%422 = select i1 %420, i1 %421, i1 false
br i1 %422, label %423, label %432
423: ; preds = %419
%424 = add nsw i32 %225, -1
%425 = zext i32 %403 to i64
%426 = mul nuw nsw i64 %425, %18
%427 = getelementptr inbounds i32, i32* %21, i64 %426
%428 = zext i32 %424 to i64
%429 = getelementptr inbounds i32, i32* %427, i64 %428
%430 = load i32, i32* %429
%431 = add nsw i32 %430, 1
store i32 %431, i32* %429
br label %432
432: ; preds = %402, %423, %419
%433 = add nuw nsw i32 %95, 1
%434 = load i32, i32* %2
%435 = icmp slt i32 %433, %434
br i1 %435, label %94, label %86
436: ; preds = %486, %89
%437 = phi i64 [ 0, %89 ], [ %488, %486 ]
%438 = phi i32 [ 0, %89 ], [ %487, %486 ]
%439 = mul nuw nsw i64 %437, %18
%440 = getelementptr inbounds i32, i32* %21, i64 %439
br i1 %91, label %470, label %441
441: ; preds = %436
%442 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %438, i64 0
br label %443
443: ; preds = %443, %441
%444 = phi i64 [ 0, %441 ], [ %465, %443 ]
%445 = phi <4 x i32> [ %442, %441 ], [ %463, %443 ]
%446 = phi <4 x i32> [ zeroinitializer, %441 ], [ %464, %443 ]
%447 = getelementptr inbounds i32, i32* %440, i64 %444
%448 = bitcast i32* %447 to <4 x i32>*
%449 = load <4 x i32>, <4 x i32>* %448
%450 = getelementptr inbounds i32, i32* %447, i64 4
%451 = bitcast i32* %450 to <4 x i32>*
%452 = load <4 x i32>, <4 x i32>* %451
%453 = icmp sgt <4 x i32> %449, <i32 -1, i32 -1, i32 -1, i32 -1>
%454 = icmp sgt <4 x i32> %452, <i32 -1, i32 -1, i32 -1, i32 -1>
%455 = and <4 x i32> %449, <i32 1048574, i32 1048574, i32 1048574, i32 1048574>
%456 = and <4 x i32> %452, <i32 1048574, i32 1048574, i32 1048574, i32 1048574>
%457 = icmp ne <4 x i32> %455, zeroinitializer
%458 = icmp ne <4 x i32> %456, zeroinitializer
%459 = and <4 x i1> %453, %457
%460 = and <4 x i1> %454, %458
%461 = zext <4 x i1> %459 to <4 x i32>
%462 = zext <4 x i1> %460 to <4 x i32>
%463 = add <4 x i32> %445, %461
%464 = add <4 x i32> %446, %462
%465 = add nuw i64 %444, 8
%466 = icmp eq i64 %465, %92
br i1 %466, label %467, label %443
467: ; preds = %443
%468 = add <4 x i32> %464, %463
%469 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %468)
br i1 %93, label %486, label %470
470: ; preds = %436, %467
%471 = phi i64 [ 0, %436 ], [ %92, %467 ]
%472 = phi i32 [ %438, %436 ], [ %469, %467 ]
br label %473
473: ; preds = %470, %473
%474 = phi i64 [ %484, %473 ], [ %471, %470 ]
%475 = phi i32 [ %483, %473 ], [ %472, %470 ]
%476 = getelementptr inbounds i32, i32* %440, i64 %474
%477 = load i32, i32* %476
%478 = icmp sgt i32 %477, -1
%479 = and i32 %477, 1048574
%480 = icmp ne i32 %479, 0
%481 = and i1 %478, %480
%482 = zext i1 %481 to i32
%483 = add nsw i32 %475, %482
%484 = add nuw nsw i64 %474, 1
%485 = icmp eq i64 %484, %90
br i1 %485, label %486, label %473
486: ; preds = %473, %467
%487 = phi i32 [ %469, %467 ], [ %483, %473 ]
%488 = add nuw nsw i64 %437, 1
%489 = icmp eq i64 %488, %90
br i1 %489, label %490, label %436
490: ; preds = %486, %86
%491 = phi i32 [ 0, %86 ], [ %487, %486 ]
%492 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %491)
%493 = load i32, i32* %1
%494 = add nsw i32 %493, -1
store i32 %494, i32* %1
%495 = icmp eq i32 %493, 0
br i1 %495, label %496, label %15
496: ; preds = %490, %0
ret i32 0
}