#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 n, i, j, k, row, col, val, move;
  scanf("%d", &n);
  for (j = 0; j < n; j++) {
    scanf("%d", &i);
    int arr[i][i];
    row = -1;
    col = 0;
    val = 0;
    move = i;
    while (move > 0) {
      for (k = 0; k < move; k++)
        arr[++row][col] = ++val;
      move--;
      for (k = 0; k < move; k++)
        arr[row][++col] = ++val;
      for (k = 0; k < move; k++)
        arr[--row][col] = ++val;
      move--;
      for (k = 0; k < move; k++)
        arr[row][--col] = ++val;
    }
    for (row = 0; row < i; row++) {
      for (col = 0; col < i; col++)
        printf("%d ", arr[row][col]);
      printf("\n\n");
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeca(%rip),%rdi
lea    -0x8(%rbp),%rsi
call   1040 <scanf@plt>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13aa <main+0x28a>
lea    0xea7(%rip),%rdi
lea    -0xc(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0xc(%rbp),%eax
mov    %eax,%ecx
mov    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,%rdx
imul   %rdx,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x48(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
movl   $0xffffffff,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jle    1319 <main+0x1f9>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1212 <main+0xf2>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rsi
mov    -0x20(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
mov    -0x18(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x18(%rbp)
movslq %ecx,%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11c9 <main+0xa9>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    126b <main+0x14b>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rsi
mov    -0x20(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq -0x18(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1222 <main+0x102>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12bb <main+0x19b>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rsi
mov    -0x20(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
mov    -0x18(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
movslq %ecx,%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1272 <main+0x152>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1314 <main+0x1f4>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rsi
mov    -0x20(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq -0x18(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12cb <main+0x1ab>
jmp    11b8 <main+0x98>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1395 <main+0x275>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1379 <main+0x259>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%rdx
movslq -0x18(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%esi
lea    0xc9f(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1333 <main+0x213>
lea    0xc87(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1320 <main+0x200>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1146 <main+0x26>
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    $0xc8,%rsp
lea    0xf05(%rip),%rdi
lea    -0x50(%rbp),%rsi
call   1050 <scanf@plt>
cmpl   $0x0,-0x50(%rbp)
jle    19bd <main+0x88d>
lea    0xeee(%rip),%r12
xor    %eax,%eax
jmp    1186 <main+0x56>
nopl   0x0(%rax)
mov    -0xa0(%rbp),%rsp
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
cmp    -0x50(%rbp),%eax
jge    19bd <main+0x88d>
mov    %eax,-0x7c(%rbp)
lea    0xec0(%rip),%rdi
lea    -0x34(%rbp),%rsi
call   1050 <scanf@plt>
mov    %rsp,-0xa0(%rbp)
mov    -0x34(%rbp),%ebx
mov    %rbx,%rax
imul   %rbx,%rax
mov    %rsp,%r15
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
mov    -0x34(%rbp),%eax
test   %eax,%eax
jle    1170 <main+0x40>
lea    -0x1(%rax),%r11d
lea    -0x3(%rax),%edx
lea    -0x2(%rax),%esi
lea    0x0(,%rbx,4),%r13
lea    0x10(%r15),%rcx
mov    %rcx,-0xc0(%rbp)
mov    %rbx,%rcx
shl    $0x6,%rcx
mov    %rcx,-0xb8(%rbp)
mov    %rbx,%rcx
shl    $0x4,%rcx
mov    %rcx,-0xd0(%rbp)
lea    0x34(%r15),%rdi
mov    %rdi,-0xb0(%rbp)
lea    0x4(%r15),%rdi
mov    %rdi,-0xe8(%rbp)
neg    %rcx
mov    %rcx,-0xd8(%rbp)
mov    %r13,%rcx
neg    %rcx
mov    %rcx,-0x90(%rbp)
lea    -0x10(%r15),%rcx
mov    %rcx,-0xa8(%rbp)
lea    -0x4(%r15),%rcx
mov    %rcx,-0xe0(%rbp)
mov    $0xffffffffffffffff,%rcx
xor    %edi,%edi
mov    %rdi,-0x78(%rbp)
mov    %edx,-0x80(%rbp)
mov    %edx,-0x4c(%rbp)
mov    %esi,-0x84(%rbp)
mov    %esi,-0x30(%rbp)
mov    %rax,-0x98(%rbp)
mov    %eax,%r10d
xor    %r14d,%r14d
xor    %eax,%eax
movdqa 0xd8a(%rip),%xmm8
pcmpeqd %xmm4,%xmm4
movdqa 0xd8e(%rip),%xmm5
movdqa 0xd96(%rip),%xmm6
movdqa 0xd9e(%rip),%xmm7
movdqa 0xda6(%rip),%xmm3
mov    %r13,-0x60(%rbp)
mov    %rbx,-0x48(%rbp)
mov    %r15,-0xc8(%rbp)
jmp    12de <main+0x1ae>
nopl   0x0(%rax,%rax,1)
lea    -0x2(%r10),%edx
add    $0xfffffffe,%r11d
mov    -0x78(%rbp),%rsi
add    $0x1,%esi
mov    %rsi,-0x78(%rbp)
add    $0xfffffffe,%ebx
mov    %ebx,-0x30(%rbp)
addl   $0xfffffffe,-0x4c(%rbp)
cmp    $0x2,%r10d
mov    %edx,%r10d
mov    -0x48(%rbp),%rbx
jle    1950 <main+0x820>
mov    %r11d,%edi
movslq %eax,%r9
movslq %ecx,%r8
lea    (%r15,%r9,4),%rcx
cmp    $0x7,%r11d
mov    %r11d,-0x2c(%rbp)
mov    %r10,-0x70(%rbp)
mov    %rdi,-0x40(%rbp)
jb     13f0 <main+0x2c0>
cmp    $0x1,%ebx
jne    13f0 <main+0x2c0>
lea    0x1(%rdi),%rsi
mov    %rsi,%rdx
movabs $0x1fffffff8,%rax
and    %rax,%rdx
mov    %rdx,-0x68(%rbp)
lea    -0x8(%rdx),%rax
mov    %rax,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  %xmm8,%xmm0
test   %rax,%rax
mov    %rsi,-0x58(%rbp)
je     13f4 <main+0x2c4>
mov    %rsi,%rbx
and    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffff8,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
lea    0x9(%r8),%rdi
imul   %r13,%rdi
mov    %r13,%rax
mov    %rdx,%rsi
mov    -0xc0(%rbp),%rdx
lea    (%rdx,%r9,4),%r13
mov    %rsi,%rdx
lea    0x1(%r8),%r11
imul   %rax,%r11
xor    %esi,%esi
mov    -0xb8(%rbp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
psubd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
movdqu %xmm1,-0x10(%r13,%r11,1)
movdqu %xmm2,0x0(%r13,%r11,1)
movdqa %xmm0,%xmm1
paddd  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm7,%xmm2
movdqu %xmm1,-0x10(%r13,%rdi,1)
movdqu %xmm2,0x0(%r13,%rdi,1)
add    $0x10,%rsi
paddd  %xmm3,%xmm0
add    %rax,%r13
add    $0xfffffffffffffffe,%rbx
jne    13a0 <main+0x270>
jmp    13f6 <main+0x2c6>
nop
xor    %esi,%esi
jmp    1442 <main+0x312>
xor    %esi,%esi
test   $0x1,%dl
mov    -0x48(%rbp),%rbx
je     1422 <main+0x2f2>
movdqa %xmm0,%xmm1
psubd  %xmm4,%xmm1
paddd  %xmm5,%xmm0
lea    (%r8,%rsi,1),%rax
add    $0x1,%rax
imul   %rbx,%rax
movdqu %xmm1,(%rcx,%rax,4)
movdqu %xmm0,0x10(%rcx,%rax,4)
mov    -0x68(%rbp),%rsi
add    %rsi,%r8
add    %esi,%r14d
cmp    %rsi,-0x58(%rbp)
mov    -0x60(%rbp),%r13
mov    -0x2c(%rbp),%r11d
mov    -0x40(%rbp),%rdi
je     1559 <main+0x429>
mov    %r10d,%eax
sub    %esi,%eax
mov    %r10,%rdx
mov    %r11d,%r10d
sub    %esi,%r10d
test   $0x3,%al
je     14ab <main+0x37b>
lea    0x1(%r8),%rax
imul   %rbx,%rax
add    %r9,%rax
lea    (%r15,%rax,4),%rdi
mov    %edx,%eax
mov    %rsi,%r11
sub    %sil,%al
movzbl %al,%eax
and    $0x3,%eax
neg    %eax
xor    %edx,%edx
mov    $0x1,%ebx
nopw   0x0(%rax,%rax,1)
lea    (%r14,%rbx,1),%esi
add    $0x1,%r8
mov    %esi,(%rdi)
add    %r13,%rdi
add    $0xffffffff,%edx
add    $0x1,%ebx
cmp    %edx,%eax
jne    1480 <main+0x350>
mov    %r11,%rsi
sub    %edx,%esi
sub    %edx,%r14d
mov    -0x2c(%rbp),%r11d
mov    -0x48(%rbp),%rbx
mov    -0x40(%rbp),%rdi
cmp    $0x3,%r10d
mov    -0x70(%rbp),%r10
jb     1559 <main+0x429>
lea    0x4(%r8),%r11
imul   %r13,%r11
mov    %r13,%rdx
lea    0x3(%r8),%r13
imul   %rdx,%r13
mov    %rsi,%rdi
mov    %r10,%rsi
lea    0x2(%r8),%r10
imul   %rdx,%r10
lea    0x1(%r8),%rax
imul   %rdx,%rax
mov    %esi,%edx
sub    %edi,%edx
mov    %r14d,%edi
xor    %esi,%esi
mov    -0xd0(%rbp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdi,%rsi,1),%r12d
add    $0x1,%r12d
mov    %r12d,(%rcx,%rax,1)
lea    0x2(%rdi,%rsi,1),%ebx
mov    %ebx,(%rcx,%r10,1)
lea    0x3(%rdi,%rsi,1),%ebx
mov    %ebx,(%rcx,%r13,1)
lea    (%rdi,%rsi,1),%ebx
add    $0x4,%ebx
mov    %ebx,(%rcx,%r11,1)
add    $0x4,%rsi
add    %r15,%rcx
cmp    %esi,%edx
jne    1500 <main+0x3d0>
add    %rsi,%r8
add    %esi,%r14d
lea    0xb15(%rip),%r12
mov    -0x60(%rbp),%r13
mov    -0x48(%rbp),%rbx
mov    -0x2c(%rbp),%r11d
mov    -0xc8(%rbp),%r15
mov    -0x70(%rbp),%r10
mov    -0x40(%rbp),%rdi
cmp    $0x2,%r10d
jl     1950 <main+0x820>
mov    -0x78(%rbp),%rax
lea    (%rax,%rax,1),%ecx
mov    -0x84(%rbp),%eax
sub    %ecx,%eax
movslq %r8d,%rsi
imul   %rbx,%rsi
cmp    $0x7,%eax
mov    %ecx,-0x68(%rbp)
jae    1590 <main+0x460>
xor    %ecx,%ecx
jmp    1681 <main+0x551>
nopl   0x0(%rax,%rax,1)
lea    0x1(%rax),%rcx
mov    %rcx,-0x58(%rbp)
movabs $0x1fffffff8,%rdx
and    %rdx,%rcx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  %xmm8,%xmm0
test   %rdx,%rdx
je     1928 <main+0x7f8>
mov    -0x30(%rbp),%r11d
add    $0x1,%r11
and    $0xfffffffffffffff8,%r11
add    $0xfffffffffffffff8,%r11
shr    $0x3,%r11
add    $0x1,%r11
and    $0xfffffffffffffffe,%r11
lea    (%rsi,%r9,1),%rdx
mov    -0xb0(%rbp),%rdi
lea    (%rdi,%rdx,4),%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
psubd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
movdqu %xmm1,-0x30(%rdx,%rdi,4)
movdqu %xmm2,-0x20(%rdx,%rdi,4)
movdqa %xmm0,%xmm1
paddd  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm7,%xmm2
movdqu %xmm1,-0x10(%rdx,%rdi,4)
movdqu %xmm2,(%rdx,%rdi,4)
add    $0x10,%rdi
paddd  %xmm3,%xmm0
add    $0xfffffffffffffffe,%r11
jne    1600 <main+0x4d0>
test   $0x1,%bl
je     1669 <main+0x539>
lea    (%r15,%rsi,4),%rdx
add    %r9,%rdi
movdqa %xmm0,%xmm1
psubd  %xmm4,%xmm1
paddd  %xmm5,%xmm0
movdqu %xmm1,0x4(%rdx,%rdi,4)
movdqu %xmm0,0x14(%rdx,%rdi,4)
add    %rcx,%r9
add    %ecx,%r14d
cmp    %rcx,-0x58(%rbp)
mov    -0x2c(%rbp),%r11d
mov    -0x48(%rbp),%rbx
mov    -0x40(%rbp),%rdi
je     16a4 <main+0x574>
mov    -0xe8(%rbp),%rdx
lea    (%rdx,%rsi,4),%rdx
nopl   0x0(%rax)
add    $0x1,%r14d
mov    %r14d,(%rdx,%r9,4)
add    $0x1,%r9
add    $0x1,%ecx
cmp    %ecx,%r11d
jne    1690 <main+0x560>
cmp    $0x2,%r10d
jl     1950 <main+0x820>
movslq %r9d,%rdx
movslq %r8d,%rcx
cmp    $0x3,%eax
mov    %rdx,-0x40(%rbp)
jae    16e0 <main+0x5b0>
mov    -0x90(%rbp),%rsi
test   $0x3,%r11b
jne    1779 <main+0x649>
jmp    17a3 <main+0x673>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
and    $0xfffffffc,%edi
lea    (%r15,%rdx,4),%rax
lea    -0x4(%rcx),%r8
imul   %r13,%r8
mov    %r13,%rsi
lea    -0x3(%rcx),%r13
imul   %rsi,%r13
lea    -0x2(%rcx),%r10
imul   %rsi,%r10
lea    -0x1(%rcx),%rdx
imul   %rsi,%rdx
mov    %r14d,%ebx
mov    %rdi,%r12
xor    %edi,%edi
mov    -0xd8(%rbp),%r11
nopl   0x0(%rax)
lea    (%rbx,%rdi,1),%esi
add    $0x1,%esi
mov    %esi,(%rax,%rdx,1)
lea    0x2(%rbx,%rdi,1),%esi
mov    %esi,(%rax,%r10,1)
lea    0x3(%rbx,%rdi,1),%esi
mov    %esi,(%rax,%r13,1)
lea    (%rbx,%rdi,1),%esi
add    $0x4,%esi
mov    %esi,(%rax,%r8,1)
add    $0x4,%rdi
add    %r11,%rax
cmp    %edi,%r12d
jne    1720 <main+0x5f0>
sub    %rdi,%rcx
add    %edi,%r14d
mov    -0x60(%rbp),%r13
mov    -0x48(%rbp),%rbx
mov    -0x2c(%rbp),%r11d
mov    -0x90(%rbp),%rsi
mov    -0x70(%rbp),%r10
lea    0x8e0(%rip),%r12
test   $0x3,%r11b
je     17a3 <main+0x673>
mov    %r11d,%eax
and    $0x3,%eax
lea    -0x1(%rcx),%rdx
imul   %rbx,%rdx
add    -0x40(%rbp),%rdx
lea    (%r15,%rdx,4),%rdx
nop
add    $0x1,%r14d
add    $0xffffffffffffffff,%rcx
mov    %r14d,(%rdx)
add    %rsi,%rdx
add    $0xffffffff,%eax
jne    1790 <main+0x660>
cmp    $0x3,%r10d
jl     1950 <main+0x820>
mov    -0x80(%rbp),%eax
mov    %eax,%r12d
sub    -0x68(%rbp),%r12d
movslq %ecx,%r8
imul   %rbx,%r8
movslq %r9d,%rax
xor    %edi,%edi
cmp    $0x7,%r12d
jae    17e0 <main+0x6b0>
lea    0x883(%rip),%r12
mov    -0x30(%rbp),%ebx
jmp    18fb <main+0x7cb>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
mov    %r12,%rdi
movabs $0x1fffffff8,%rdx
and    %rdx,%rdi
lea    -0x8(%rdi),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  %xmm8,%xmm0
test   %rdx,%rdx
je     1938 <main+0x808>
mov    -0x4c(%rbp),%esi
add    $0x1,%rsi
and    $0xfffffffffffffff8,%rsi
add    $0xfffffffffffffff8,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r8,%rax,1),%rdx
mov    -0xa8(%rbp),%rbx
lea    (%rbx,%rdx,4),%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
psubd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,(%rdx,%rbx,4)
pshufd $0x1b,%xmm2,%xmm1
movdqu %xmm1,-0x10(%rdx,%rbx,4)
movdqa %xmm0,%xmm1
paddd  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm7,%xmm2
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0x20(%rdx,%rbx,4)
pshufd $0x1b,%xmm2,%xmm1
movdqu %xmm1,-0x30(%rdx,%rbx,4)
paddd  %xmm3,%xmm0
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1850 <main+0x720>
neg    %rbx
test   $0x1,%r9b
je     18de <main+0x7ae>
lea    (%r15,%r8,4),%rdx
movdqa %xmm0,%xmm1
psubd  %xmm4,%xmm1
paddd  %xmm5,%xmm0
not    %rbx
add    %rax,%rbx
pshufd $0x1b,%xmm1,%xmm1
movdqu %xmm1,-0xc(%rdx,%rbx,4)
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm0,-0x1c(%rdx,%rbx,4)
sub    %rdi,%rax
add    %edi,%r14d
cmp    %rdi,%r12
lea    0x765(%rip),%r12
mov    -0x2c(%rbp),%r11d
mov    -0x30(%rbp),%ebx
je     12b0 <main+0x180>
mov    -0xe0(%rbp),%rdx
lea    (%rdx,%r8,4),%rdx
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%r14d
mov    %r14d,(%rdx,%rax,4)
add    $0xffffffffffffffff,%rax
add    $0x1,%edi
cmp    %edi,%ebx
jne    1910 <main+0x7e0>
jmp    12b0 <main+0x180>
xor    %edi,%edi
test   $0x1,%bl
jne    164a <main+0x51a>
jmp    1669 <main+0x539>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    18b2 <main+0x782>
jmp    18de <main+0x7ae>
cs nopw 0x0(%rax,%rax,1)
mov    -0x98(%rbp),%rax
test   %eax,%eax
jle    1170 <main+0x40>
xor    %r14d,%r14d
jmp    1990 <main+0x860>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x6e0(%rip),%rdi
call   1030 <puts@plt>
add    $0x1,%r14
movslq -0x34(%rbp),%rax
add    %r13,%r15
cmp    %rax,%r14
jge    1170 <main+0x40>
test   %eax,%eax
jle    1970 <main+0x840>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    (%r15,%rbx,4),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x1,%rbx
movslq -0x34(%rbp),%rax
cmp    %rax,%rbx
jl     19a0 <main+0x870>
jmp    1970 <main+0x840>
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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