#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 */
scalar_t__ malloc(int);
int *spiralOrder(int **matrix, int matrixRowSize, int matrixColSize) {
  int size = matrixRowSize * matrixColSize;
  int *ret = (int *)malloc(size * sizeof(int));
  if (matrixRowSize == 1) {
    for (int i = 0; i < matrixColSize; i++)
      ret[i] = matrix[0][i];
    return ret;
  }
  if (matrixColSize == 1) {
    for (int i = 0; i < matrixRowSize; i++)
      ret[i] = matrix[i][0];
    return ret;
  }
  int round = 0;
  int i = 0;
  while (i < size - 1) {
    for (int j = round; j < matrixColSize - 1 - round; j++, i++)
      ret[i] = matrix[round][j];
    for (int j = round; j < matrixRowSize - 1 - round; j++, i++)
      ret[i] = matrix[j][matrixColSize - 1 - round];
    for (int j = round; j < matrixColSize - 1 - round; j++, i++)
      ret[i] = matrix[matrixRowSize - 1 - round][matrixColSize - 1 - j];
    for (int j = round; j < matrixRowSize - 1 - round; j++, i++)
      ret[i] = matrix[matrixRowSize - 1 - j][round];
    round++;
  }
  if (matrixRowSize == matrixColSize)
    ret[i] = matrix[matrixRowSize / 2][matrixColSize / 2];
  return ret;
}


x86 assembly (clang, -O0):
<spiralOrder>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpl   $0x1,-0x14(%rbp)
jne    1190 <spiralOrder+0x80>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1183 <spiralOrder+0x73>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1150 <spiralOrder+0x40>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    13c4 <spiralOrder+0x2b4>
cmpl   $0x1,-0x18(%rbp)
jne    11e1 <spiralOrder+0xd1>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d4 <spiralOrder+0xc4>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%edx
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11a1 <spiralOrder+0x91>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    13c4 <spiralOrder+0x2b4>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    136a <spiralOrder+0x25a>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    124f <spiralOrder+0x13f>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1206 <spiralOrder+0xf6>
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    12a6 <spiralOrder+0x196>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1255 <spiralOrder+0x145>
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    1305 <spiralOrder+0x1f5>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12ac <spiralOrder+0x19c>
mov    -0x34(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
cmp    %ecx,%eax
jge    135c <spiralOrder+0x24c>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    130b <spiralOrder+0x1fb>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ef <spiralOrder+0xdf>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    13bc <spiralOrder+0x2ac>
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spiralOrder>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %edx,%r14d
mov    %esi,%ebp
mov    %rdi,%rbx
mov    %edx,%eax
imul   %esi,%eax
mov    %rax,0x28(%rsp)
lea    0x0(,%rax,4),%edi
call   1030 <malloc@plt>
cmp    $0x1,%ebp
jne    11dc <spiralOrder+0xcc>
test   %r14d,%r14d
jle    1a68 <spiralOrder+0x958>
mov    (%rbx),%rcx
mov    %r14d,%r9d
cmp    $0x8,%r14d
jb     1177 <spiralOrder+0x67>
lea    (%rcx,%r9,4),%rdx
cmp    %rdx,%rax
jae    1917 <spiralOrder+0x807>
lea    (%rax,%r9,4),%rdx
cmp    %rdx,%rcx
jae    1917 <spiralOrder+0x807>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r9,%rdi
mov    %r9,%rdx
and    $0x3,%rdx
je     11a0 <spiralOrder+0x90>
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,4),%ebx
mov    %ebx,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1190 <spiralOrder+0x80>
cmp    $0x3,%rdi
jb     1a68 <spiralOrder+0x958>
nopw   0x0(%rax,%rax,1)
mov    (%rcx,%rsi,4),%edx
mov    %edx,(%rax,%rsi,4)
mov    0x4(%rcx,%rsi,4),%edx
mov    %edx,0x4(%rax,%rsi,4)
mov    0x8(%rcx,%rsi,4),%edx
mov    %edx,0x8(%rax,%rsi,4)
mov    0xc(%rcx,%rsi,4),%edx
mov    %edx,0xc(%rax,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    11b0 <spiralOrder+0xa0>
jmp    1a68 <spiralOrder+0x958>
cmp    $0x1,%r14d
jne    1206 <spiralOrder+0xf6>
test   %ebp,%ebp
jle    1a68 <spiralOrder+0x958>
mov    %ebp,%edx
lea    -0x1(%rdx),%rsi
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x3,%rsi
jae    1940 <spiralOrder+0x830>
xor    %esi,%esi
jmp    1983 <spiralOrder+0x873>
mov    %rbp,0x68(%rsp)
mov    %r14,0x70(%rsp)
mov    %rbx,0x18(%rsp)
xor    %r13d,%r13d
cmpl   $0x2,0x28(%rsp)
jl     18e5 <spiralOrder+0x7d5>
mov    0x28(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,0x28(%rsp)
mov    0x70(%rsp),%rcx
lea    -0x1(%rcx),%esi
mov    0x68(%rsp),%rcx
lea    -0x1(%rcx),%r9d
movslq %esi,%rdx
movslq %r9d,%rbx
lea    0x4(%rax),%rdi
mov    %rdi,0x40(%rsp)
lea    0x1(%rdx),%rdi
lea    0x30(%rax),%rbp
mov    %rbp,0x60(%rsp)
lea    0xc(%rax),%rbp
mov    %rbp,0x48(%rsp)
lea    0x3(%rcx),%r12d
mov    0x18(%rsp),%r10
lea    0x18(%r10),%rcx
mov    %rcx,0xa8(%rsp)
mov    %rdx,%rcx
mov    %rdx,0x30(%rsp)
lea    -0x3(%rdx),%rcx
mov    %rcx,0x80(%rsp)
mov    %rbx,0xb0(%rsp)
lea    (%r10,%rbx,8),%rcx
mov    %rcx,0xa0(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x98(%rsp)
mov    $0xc,%ecx
mov    %rcx,0x78(%rsp)
mov    $0xfffffffffffffff8,%rbx
xor    %r11d,%r11d
xor    %r13d,%r13d
mov    %rdi,0x10(%rsp)
jmp    1313 <spiralOrder+0x203>
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rbx
add    $0x1,%r11
add    $0xffffffff,%r14d
add    $0xffffffff,%r9d
addq   $0x1,0x78(%rsp)
add    $0xffffffffffffffff,%rbx
addq   $0xffffffffffffffff,0x98(%rsp)
add    $0x8,%r10
add    $0x2,%r12b
addq   $0xffffffffffffffff,0x80(%rsp)
mov    %r14d,%esi
cmp    0x28(%rsp),%r13d
jge    18e5 <spiralOrder+0x7d5>
mov    %esi,%r14d
lea    (%rbx,%r14,1),%r15
shr    $0x3,%r15
add    $0x1,%r15
and    $0xfffffffffffffffe,%r15
movzbl %r12b,%r12d
and    $0x3,%r12d
mov    %r11,%rcx
not    %rcx
mov    %rcx,0x38(%rsp)
mov    %r14,%rdx
sub    %r11,%rdx
lea    -0x8(%rdx),%rcx
mov    %rcx,0x88(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rcx,0x90(%rsp)
mov    0x30(%rsp),%rbp
sub    %r11,%rbp
cmp    %rbp,%r11
mov    %rdx,0x8(%rsp)
mov    %rbx,0x58(%rsp)
mov    %esi,0x24(%rsp)
jge    1505 <spiralOrder+0x3f5>
mov    0x18(%rsp),%rcx
mov    (%rcx,%r11,8),%r8
movslq %r13d,%r13
cmp    $0x8,%rdx
jb     13be <spiralOrder+0x2ae>
lea    (%rax,%r13,4),%rcx
lea    (%r8,%r14,4),%rdx
cmp    %rdx,%rcx
jae    1454 <spiralOrder+0x344>
mov    0x38(%rsp),%rcx
add    %r13,%rcx
add    %r14,%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
lea    (%r8,%r11,4),%rdx
cmp    %rcx,%rdx
jae    1454 <spiralOrder+0x344>
mov    %r11,%rcx
mov    %r14d,%edx
sub    %ecx,%edx
mov    %rcx,%rbx
not    %rbx
add    %r14,%rbx
test   $0x3,%dl
je     13f6 <spiralOrder+0x2e6>
mov    0x24(%rsp),%edx
sub    %cl,%dl
movzbl %dl,%esi
and    $0x3,%esi
mov    (%r8,%rcx,4),%edx
mov    %edx,(%rax,%r13,4)
add    $0x1,%rcx
add    $0x1,%r13
add    $0xffffffffffffffff,%rsi
jne    13e0 <spiralOrder+0x2d0>
cmp    $0x3,%rbx
jb     1500 <spiralOrder+0x3f0>
mov    0x48(%rsp),%rdx
lea    (%rdx,%r13,4),%rsi
mov    %r14,%rbx
sub    %rcx,%rbx
lea    (%r8,%rcx,4),%rdx
add    $0xc,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
mov    -0xc(%rdx,%rcx,4),%edi
mov    %edi,-0xc(%rsi,%rcx,4)
mov    -0x8(%rdx,%rcx,4),%edi
mov    %edi,-0x8(%rsi,%rcx,4)
mov    -0x4(%rdx,%rcx,4),%edi
mov    %edi,-0x4(%rsi,%rcx,4)
mov    (%rdx,%rcx,4),%edi
mov    %edi,(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1420 <spiralOrder+0x310>
add    %rcx,%r13
mov    0x10(%rsp),%rdi
jmp    1500 <spiralOrder+0x3f0>
cmpq   $0x8,0x88(%rsp)
jae    1463 <spiralOrder+0x353>
xor    %ebx,%ebx
jmp    14b4 <spiralOrder+0x3a4>
mov    0x60(%rsp),%rcx
lea    (%rcx,%r13,4),%rcx
mov    0x78(%rsp),%rdx
lea    (%r8,%rdx,4),%rsi
mov    %r15,%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rbx,4),%xmm0
movups -0x20(%rsi,%rbx,4),%xmm1
movups %xmm0,-0x30(%rcx,%rbx,4)
movups %xmm1,-0x20(%rcx,%rbx,4)
movdqu -0x10(%rsi,%rbx,4),%xmm0
movdqu (%rsi,%rbx,4),%xmm1
movdqu %xmm0,-0x10(%rcx,%rbx,4)
movdqu %xmm1,(%rcx,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rdx
jne    1480 <spiralOrder+0x370>
mov    0x8(%rsp),%rdx
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
testb  $0x1,0x90(%rsp)
01
je     14ee <spiralOrder+0x3de>
lea    (%r11,%rbx,1),%rdx
add    %r13,%rbx
movdqu (%r8,%rdx,4),%xmm0
movdqu 0x10(%r8,%rdx,4),%xmm1
mov    0x8(%rsp),%rdx
movdqu %xmm0,(%rax,%rbx,4)
movdqu %xmm1,0x10(%rax,%rbx,4)
add    %rcx,%r13
cmp    %rcx,%rdx
jne    17e5 <spiralOrder+0x6d5>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdx
mov    %r9d,%r9d
mov    %r9,%rbx
sub    %r11,%rbx
mov    0xb0(%rsp),%r8
sub    %r11,%r8
cmp    %r8,%r11
jge    15d9 <spiralOrder+0x4c9>
mov    0x38(%rsp),%rcx
lea    (%rcx,%r9,1),%rdx
movslq %r13d,%r13
test   $0x3,%bl
mov    %rbx,0x50(%rsp)
je     1566 <spiralOrder+0x456>
lea    (%rax,%r13,4),%rcx
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%r10,%rbx,8),%rsi
mov    (%rsi,%rbp,4),%esi
mov    %esi,(%rcx,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1540 <spiralOrder+0x430>
add    %rbx,%r13
sub    0x98(%rsp),%rbx
cmp    $0x3,%rdx
jae    156f <spiralOrder+0x45f>
jmp    15cf <spiralOrder+0x4bf>
mov    %r11,%rbx
cmp    $0x3,%rdx
jb     15cf <spiralOrder+0x4bf>
mov    0x48(%rsp),%rcx
lea    (%rcx,%r13,4),%rcx
mov    %r9,%rdx
sub    %rbx,%rdx
mov    0xa8(%rsp),%rsi
lea    (%rsi,%rbx,8),%rbx
xor    %esi,%esi
nopl   0x0(%rax)
mov    -0x18(%rbx,%rsi,8),%rdi
mov    (%rdi,%rbp,4),%edi
mov    %edi,-0xc(%rcx,%rsi,4)
mov    -0x10(%rbx,%rsi,8),%rdi
mov    (%rdi,%rbp,4),%edi
mov    %edi,-0x8(%rcx,%rsi,4)
mov    -0x8(%rbx,%rsi,8),%rdi
mov    (%rdi,%rbp,4),%edi
mov    %edi,-0x4(%rcx,%rsi,4)
mov    (%rbx,%rsi,8),%rdi
mov    (%rdi,%rbp,4),%edi
mov    %edi,(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1590 <spiralOrder+0x480>
add    %rsi,%r13
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rdx
mov    0x50(%rsp),%rbx
cmp    %rbp,%r11
jge    1732 <spiralOrder+0x622>
mov    0x18(%rsp),%rcx
mov    (%rcx,%r8,8),%rbp
movslq %r13d,%r13
cmp    $0x8,%rdx
jb     1640 <spiralOrder+0x530>
mov    %rdi,%rcx
sub    %r11,%rcx
lea    (%rax,%r13,4),%rdx
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
cmp    %rcx,%rdx
jae    17d0 <spiralOrder+0x6c0>
mov    %rdi,%rcx
sub    %r14,%rcx
mov    0x38(%rsp),%rdx
add    %r13,%rdx
add    %r14,%rdx
mov    0x40(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
cmp    %rdx,%rcx
jae    17d0 <spiralOrder+0x6c0>
mov    %r11,%rdx
mov    %r14d,%ecx
sub    %edx,%ecx
mov    %rdx,%r15
not    %r15
add    %r14,%r15
test   $0x3,%cl
je     16c7 <spiralOrder+0x5b7>
mov    %rbx,0x50(%rsp)
lea    (%rax,%r13,4),%rbx
mov    0x30(%rsp),%rcx
mov    %rbp,0x8(%rsp)
lea    0x0(,%rcx,4),%rcx
add    %rbp,%rcx
lea    0x0(,%rdx,4),%rsi
sub    %rsi,%rcx
mov    0x24(%rsp),%esi
sub    %dl,%sil
movzbl %sil,%esi
and    $0x3,%esi
neg    %rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rcx,%rbp,4),%edi
mov    %edi,(%rbx)
add    $0xffffffffffffffff,%rbp
add    $0x4,%rbx
cmp    %rbp,%rsi
jne    16a0 <spiralOrder+0x590>
sub    %rbp,%r13
sub    %rbp,%rdx
mov    0x10(%rsp),%rdi
mov    0x50(%rsp),%rbx
mov    0x8(%rsp),%rbp
cmp    $0x3,%r15
jb     1732 <spiralOrder+0x622>
mov    %rbp,%rdi
mov    %rbx,%rbp
mov    0x48(%rsp),%rcx
lea    (%rcx,%r13,4),%rcx
mov    0x30(%rsp),%rsi
lea    (%rdi,%rsi,4),%rbx
lea    0x0(,%rdx,4),%rsi
sub    %rsi,%rbx
sub    %r14,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rsi,4),%edi
mov    %edi,-0xc(%rcx)
mov    -0x4(%rbx,%rsi,4),%edi
mov    %edi,-0x8(%rcx)
mov    -0x8(%rbx,%rsi,4),%edi
mov    %edi,-0x4(%rcx)
mov    -0xc(%rbx,%rsi,4),%edi
mov    %edi,(%rcx)
add    $0xfffffffffffffffc,%rsi
add    $0x10,%rcx
cmp    %rsi,%rdx
jne    1700 <spiralOrder+0x5f0>
sub    %rsi,%r13
mov    0x10(%rsp),%rdi
mov    %rbp,%rbx
cmp    %r8,%r11
jge    12d0 <spiralOrder+0x1c0>
movslq %r13d,%r13
test   $0x1,%bl
jne    1750 <spiralOrder+0x640>
mov    %r11,%rcx
jmp    1769 <spiralOrder+0x659>
nopl   0x0(%rax,%rax,1)
mov    0x18(%rsp),%rcx
mov    (%rcx,%r8,8),%rcx
mov    (%rcx,%r11,4),%ecx
mov    %ecx,(%rax,%r13,4)
lea    0x1(%r11),%rcx
add    $0x1,%r13
mov    0x58(%rsp),%rbx
add    %r9,0x38(%rsp)
je     12d5 <spiralOrder+0x1c5>
mov    0x40(%rsp),%rdx
lea    (%rdx,%r13,4),%rdx
lea    0x0(,%rcx,8),%rdi
mov    0xa0(%rsp),%rsi
sub    %rdi,%rsi
sub    %r9,%rcx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rbp,8),%rdi
mov    (%rdi,%r11,4),%edi
mov    %edi,-0x4(%rdx)
mov    -0x8(%rsi,%rbp,8),%rdi
mov    (%rdi,%r11,4),%edi
mov    %edi,(%rdx)
add    $0xfffffffffffffffe,%rbp
add    $0x8,%rdx
cmp    %rbp,%rcx
jne    17a0 <spiralOrder+0x690>
sub    %rbp,%r13
mov    0x10(%rsp),%rdi
jmp    12d5 <spiralOrder+0x1c5>
cmpq   $0x8,0x88(%rsp)
jae    17ed <spiralOrder+0x6dd>
mov    %rbp,%rdi
xor    %ebp,%ebp
jmp    1872 <spiralOrder+0x762>
add    %r11,%rcx
jmp    13c1 <spiralOrder+0x2b1>
mov    %rbx,%rsi
mov    0x60(%rsp),%rcx
lea    (%rcx,%r13,4),%rdx
mov    0x80(%rsp),%rcx
mov    %rbp,%rdi
lea    0x0(,%rcx,4),%rbx
add    %rbp,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rbx,%rbp,4),%xmm0
movdqu (%rbx,%rbp,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x30(%rdx)
movdqu %xmm0,-0x20(%rdx)
movdqu -0x30(%rbx,%rbp,4),%xmm0
movdqu -0x20(%rbx,%rbp,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x10(%rdx)
movdqu %xmm0,(%rdx)
add    $0x40,%rdx
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffffe,%r15
jne    1820 <spiralOrder+0x710>
neg    %rbp
mov    %rsi,%rbx
mov    0x8(%rsp),%rdx
and    $0xfffffffffffffff8,%rdx
testb  $0x1,0x90(%rsp)
01
je     18b8 <spiralOrder+0x7a8>
lea    (%r11,%rbp,1),%rcx
add    %r13,%rbp
mov    0x30(%rsp),%rsi
sub    %rcx,%rsi
mov    %rdi,%rcx
movdqu -0x1c(%rdi,%rsi,4),%xmm0
movdqu -0xc(%rdi,%rsi,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%rax,%rbp,4)
movdqu %xmm0,0x10(%rax,%rbp,4)
add    %rdx,%r13
cmp    %rdx,0x8(%rsp)
jne    18d5 <spiralOrder+0x7c5>
mov    0x10(%rsp),%rdi
cmp    %r8,%r11
jge    12d0 <spiralOrder+0x1c0>
jmp    173b <spiralOrder+0x62b>
add    %r11,%rdx
mov    %rdi,%rbp
mov    0x10(%rsp),%rdi
jmp    1643 <spiralOrder+0x533>
mov    0x70(%rsp),%rsi
cmp    %esi,0x68(%rsp)
mov    0x18(%rsp),%rdx
jne    1a68 <spiralOrder+0x958>
mov    %esi,%ecx
shr    $0x1f,%ecx
add    %esi,%ecx
sar    %ecx
movslq %ecx,%rcx
mov    (%rdx,%rcx,8),%rdx
mov    (%rdx,%rcx,4),%ecx
movslq %r13d,%rdx
mov    %ecx,(%rax,%rdx,4)
jmp    1a68 <spiralOrder+0x958>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdx
jae    19b8 <spiralOrder+0x8a8>
xor    %ebx,%ebx
jmp    1a1c <spiralOrder+0x90c>
and    $0xfffffffc,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rsi,8),%rdi
mov    (%rdi),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x8(%rbx,%rsi,8),%rdi
mov    (%rdi),%edi
mov    %edi,0x4(%rax,%rsi,4)
mov    0x10(%rbx,%rsi,8),%rdi
mov    (%rdi),%edi
mov    %edi,0x8(%rax,%rsi,4)
mov    0x18(%rbx,%rsi,8),%rdi
mov    (%rdi),%edi
mov    %edi,0xc(%rax,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1950 <spiralOrder+0x840>
test   %rcx,%rcx
je     1a68 <spiralOrder+0x958>
lea    (%rax,%rsi,4),%rdx
lea    (%rbx,%rsi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rdi,8),%rbp
mov    0x0(%rbp),%ebp
mov    %ebp,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    19a0 <spiralOrder+0x890>
jmp    1a68 <spiralOrder+0x958>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
xchg   %ax,%ax
movups (%rcx,%rbx,4),%xmm0
movups 0x10(%rcx,%rbx,4),%xmm1
movups %xmm0,(%rax,%rbx,4)
movups %xmm1,0x10(%rax,%rbx,4)
movups 0x20(%rcx,%rbx,4),%xmm0
movups 0x30(%rcx,%rbx,4),%xmm1
movups %xmm0,0x20(%rax,%rbx,4)
movups %xmm1,0x30(%rax,%rbx,4)
movups 0x40(%rcx,%rbx,4),%xmm0
movups 0x50(%rcx,%rbx,4),%xmm1
movups %xmm0,0x40(%rax,%rbx,4)
movups %xmm1,0x50(%rax,%rbx,4)
movdqu 0x60(%rcx,%rbx,4),%xmm0
movdqu 0x70(%rcx,%rbx,4),%xmm1
movdqu %xmm0,0x60(%rax,%rbx,4)
movdqu %xmm1,0x70(%rax,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    19c0 <spiralOrder+0x8b0>
test   %r8,%r8
je     1a5f <spiralOrder+0x94f>
lea    (%rax,%rbx,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r8
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rbx,%rdx,1),%xmm0
movdqu (%rbx,%rdx,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rdx,1)
movdqu %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1a40 <spiralOrder+0x930>
cmp    %r9,%rsi
jne    1179 <spiralOrder+0x69>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32* @spiralOrder(i32** nocapture %0, i32 %1, i32 %2) {
%4 = mul nsw i32 %2, %1
%5 = shl i32 %4, 2
%6 = tail call i64 @malloc(i32 %5)
%7 = inttoptr i64 %6 to i32*
%8 = inttoptr i64 %6 to i8*
%9 = icmp eq i32 %1, 1
br i1 %9, label %10, label %139
10: ; preds = %3
%11 = icmp sgt i32 %2, 0
br i1 %11, label %12, label %631
12: ; preds = %10
%13 = load i32*, i32** %0
%14 = zext i32 %2 to i64
%15 = icmp ult i32 %2, 8
br i1 %15, label %102, label %16
16: ; preds = %12
%17 = getelementptr i32, i32* %7, i64 %14
%18 = getelementptr i32, i32* %13, i64 %14
%19 = bitcast i32* %18 to i8*
%20 = icmp ult i8* %8, %19
%21 = icmp ult i32* %13, %17
%22 = and i1 %20, %21
br i1 %22, label %102, label %23
23: ; preds = %16
%24 = and i64 %14, 4294967288
%25 = add nsw i64 %24, -8
%26 = lshr exact i64 %25, 3
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 3
%29 = icmp ult i64 %25, 24
br i1 %29, label %81, label %30
30: ; preds = %23
%31 = and i64 %27, 4611686018427387900
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %78, %32 ]
%34 = phi i64 [ 0, %30 ], [ %79, %32 ]
%35 = getelementptr inbounds i32, i32* %13, i64 %33
%36 = bitcast i32* %35 to <4 x i32>*
%37 = load <4 x i32>, <4 x i32>* %36
%38 = getelementptr inbounds i32, i32* %35, i64 4
%39 = bitcast i32* %38 to <4 x i32>*
%40 = load <4 x i32>, <4 x i32>* %39
%41 = getelementptr inbounds i32, i32* %7, i64 %33
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> %37, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %44
%45 = or i64 %33, 8
%46 = getelementptr inbounds i32, i32* %13, i64 %45
%47 = bitcast i32* %46 to <4 x i32>*
%48 = load <4 x i32>, <4 x i32>* %47
%49 = getelementptr inbounds i32, i32* %46, i64 4
%50 = bitcast i32* %49 to <4 x i32>*
%51 = load <4 x i32>, <4 x i32>* %50
%52 = getelementptr inbounds i32, i32* %7, i64 %45
%53 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> %48, <4 x i32>* %53
%54 = getelementptr inbounds i32, i32* %52, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %51, <4 x i32>* %55
%56 = or i64 %33, 16
%57 = getelementptr inbounds i32, i32* %13, i64 %56
%58 = bitcast i32* %57 to <4 x i32>*
%59 = load <4 x i32>, <4 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = getelementptr inbounds i32, i32* %7, i64 %56
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> %59, <4 x i32>* %64
%65 = getelementptr inbounds i32, i32* %63, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %66
%67 = or i64 %33, 24
%68 = getelementptr inbounds i32, i32* %13, i64 %67
%69 = bitcast i32* %68 to <4 x i32>*
%70 = load <4 x i32>, <4 x i32>* %69
%71 = getelementptr inbounds i32, i32* %68, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
%73 = load <4 x i32>, <4 x i32>* %72
%74 = getelementptr inbounds i32, i32* %7, i64 %67
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> %70, <4 x i32>* %75
%76 = getelementptr inbounds i32, i32* %74, i64 4
%77 = bitcast i32* %76 to <4 x i32>*
store <4 x i32> %73, <4 x i32>* %77
%78 = add nuw i64 %33, 32
%79 = add i64 %34, 4
%80 = icmp eq i64 %79, %31
br i1 %80, label %81, label %32
81: ; preds = %32, %23
%82 = phi i64 [ 0, %23 ], [ %78, %32 ]
%83 = icmp eq i64 %28, 0
br i1 %83, label %100, label %84
84: ; preds = %81, %84
%85 = phi i64 [ %97, %84 ], [ %82, %81 ]
%86 = phi i64 [ %98, %84 ], [ 0, %81 ]
%87 = getelementptr inbounds i32, i32* %13, i64 %85
%88 = bitcast i32* %87 to <4 x i32>*
%89 = load <4 x i32>, <4 x i32>* %88
%90 = getelementptr inbounds i32, i32* %87, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = getelementptr inbounds i32, i32* %7, i64 %85
%94 = bitcast i32* %93 to <4 x i32>*
store <4 x i32> %89, <4 x i32>* %94
%95 = getelementptr inbounds i32, i32* %93, i64 4
%96 = bitcast i32* %95 to <4 x i32>*
store <4 x i32> %92, <4 x i32>* %96
%97 = add nuw i64 %85, 8
%98 = add i64 %86, 1
%99 = icmp eq i64 %98, %28
br i1 %99, label %100, label %84
100: ; preds = %84, %81
%101 = icmp eq i64 %24, %14
br i1 %101, label %631, label %102
102: ; preds = %16, %12, %100
%103 = phi i64 [ 0, %16 ], [ 0, %12 ], [ %24, %100 ]
%104 = xor i64 %103, -1
%105 = add nsw i64 %104, %14
%106 = and i64 %14, 3
%107 = icmp eq i64 %106, 0
br i1 %107, label %117, label %108
108: ; preds = %102, %108
%109 = phi i64 [ %114, %108 ], [ %103, %102 ]
%110 = phi i64 [ %115, %108 ], [ 0, %102 ]
%111 = getelementptr inbounds i32, i32* %13, i64 %109
%112 = load i32, i32* %111
%113 = getelementptr inbounds i32, i32* %7, i64 %109
store i32 %112, i32* %113
%114 = add nuw nsw i64 %109, 1
%115 = add i64 %110, 1
%116 = icmp eq i64 %115, %106
br i1 %116, label %117, label %108
117: ; preds = %108, %102
%118 = phi i64 [ %103, %102 ], [ %114, %108 ]
%119 = icmp ult i64 %105, 3
br i1 %119, label %631, label %120
120: ; preds = %117, %120
%121 = phi i64 [ %137, %120 ], [ %118, %117 ]
%122 = getelementptr inbounds i32, i32* %13, i64 %121
%123 = load i32, i32* %122
%124 = getelementptr inbounds i32, i32* %7, i64 %121
store i32 %123, i32* %124
%125 = add nuw nsw i64 %121, 1
%126 = getelementptr inbounds i32, i32* %13, i64 %125
%127 = load i32, i32* %126
%128 = getelementptr inbounds i32, i32* %7, i64 %125
store i32 %127, i32* %128
%129 = add nuw nsw i64 %121, 2
%130 = getelementptr inbounds i32, i32* %13, i64 %129
%131 = load i32, i32* %130
%132 = getelementptr inbounds i32, i32* %7, i64 %129
store i32 %131, i32* %132
%133 = add nuw nsw i64 %121, 3
%134 = getelementptr inbounds i32, i32* %13, i64 %133
%135 = load i32, i32* %134
%136 = getelementptr inbounds i32, i32* %7, i64 %133
store i32 %135, i32* %136
%137 = add nuw nsw i64 %121, 4
%138 = icmp eq i64 %137, %14
br i1 %138, label %631, label %120
139: ; preds = %3
%140 = icmp eq i32 %2, 1
br i1 %140, label %153, label %141
141: ; preds = %139
%142 = add nsw i32 %4, -1
%143 = icmp sgt i32 %4, 1
br i1 %143, label %144, label %606
144: ; preds = %141
%145 = add i32 %2, -1
%146 = add i32 %1, -1
%147 = sext i32 %145 to i64
%148 = sext i32 %146 to i64
%149 = getelementptr i32, i32* %7, i64 1
%150 = add nsw i64 %147, 1
%151 = add nsw i64 %147, 1
%152 = getelementptr i32, i32* %7, i64 1
br label %187
153: ; preds = %139
%154 = icmp sgt i32 %1, 0
br i1 %154, label %155, label %631
155: ; preds = %153
%156 = zext i32 %1 to i64
%157 = add nsw i64 %156, -1
%158 = and i64 %156, 3
%159 = icmp ult i64 %157, 3
br i1 %159, label %618, label %160
160: ; preds = %155
%161 = and i64 %156, 4294967292
br label %162
162: ; preds = %162, %160
%163 = phi i64 [ 0, %160 ], [ %184, %162 ]
%164 = phi i64 [ 0, %160 ], [ %185, %162 ]
%165 = getelementptr inbounds i32*, i32** %0, i64 %163
%166 = load i32*, i32** %165
%167 = load i32, i32* %166
%168 = getelementptr inbounds i32, i32* %7, i64 %163
store i32 %167, i32* %168
%169 = or i64 %163, 1
%170 = getelementptr inbounds i32*, i32** %0, i64 %169
%171 = load i32*, i32** %170
%172 = load i32, i32* %171
%173 = getelementptr inbounds i32, i32* %7, i64 %169
store i32 %172, i32* %173
%174 = or i64 %163, 2
%175 = getelementptr inbounds i32*, i32** %0, i64 %174
%176 = load i32*, i32** %175
%177 = load i32, i32* %176
%178 = getelementptr inbounds i32, i32* %7, i64 %174
store i32 %177, i32* %178
%179 = or i64 %163, 3
%180 = getelementptr inbounds i32*, i32** %0, i64 %179
%181 = load i32*, i32** %180
%182 = load i32, i32* %181
%183 = getelementptr inbounds i32, i32* %7, i64 %179
store i32 %182, i32* %183
%184 = add nuw nsw i64 %163, 4
%185 = add i64 %164, 4
%186 = icmp eq i64 %185, %161
br i1 %186, label %618, label %162
187: ; preds = %144, %580
%188 = phi i32 [ %146, %144 ], [ %585, %580 ]
%189 = phi i32 [ %145, %144 ], [ %584, %580 ]
%190 = phi i64 [ 0, %144 ], [ %582, %580 ]
%191 = phi i32 [ 0, %144 ], [ %581, %580 ]
%192 = zext i32 %188 to i64
%193 = sub i64 %192, %190
%194 = xor i64 %190, -1
%195 = zext i32 %189 to i64
%196 = zext i32 %189 to i64
%197 = sub i64 %196, %190
%198 = add i64 %197, -8
%199 = lshr i64 %198, 3
%200 = add nuw nsw i64 %199, 1
%201 = zext i32 %188 to i64
%202 = sub i64 %201, %190
%203 = xor i64 %190, -1
%204 = add i64 %203, %201
%205 = zext i32 %189 to i64
%206 = zext i32 %189 to i64
%207 = sub i64 %206, %190
%208 = add i64 %207, -8
%209 = lshr i64 %208, 3
%210 = add nuw nsw i64 %209, 1
%211 = zext i32 %189 to i64
%212 = sub i64 %211, %190
%213 = xor i64 %190, -1
%214 = zext i32 %189 to i64
%215 = zext i32 %189 to i64
%216 = sub i64 %215, %190
%217 = xor i64 %190, -1
%218 = zext i32 %189 to i64
%219 = sub nsw i64 %150, %218
%220 = sub i64 %151, %190
%221 = sub nsw i64 %147, %190
%222 = icmp slt i64 %190, %221
br i1 %222, label %223, label %323
223: ; preds = %187
%224 = getelementptr inbounds i32*, i32** %0, i64 %190
%225 = load i32*, i32** %224
%226 = sext i32 %191 to i64
%227 = zext i32 %189 to i64
%228 = icmp ult i64 %212, 8
br i1 %228, label %296, label %229
229: ; preds = %223
%230 = getelementptr i32, i32* %7, i64 %226
%231 = add i64 %213, %226
%232 = add i64 %231, %214
%233 = getelementptr i32, i32* %152, i64 %232
%234 = getelementptr i32, i32* %225, i64 %190
%235 = getelementptr i32, i32* %225, i64 %214
%236 = icmp ult i32* %230, %235
%237 = icmp ult i32* %234, %233
%238 = and i1 %236, %237
br i1 %238, label %296, label %239
239: ; preds = %229
%240 = and i64 %212, -8
%241 = add i64 %240, %226
%242 = add i64 %190, %240
%243 = and i64 %210, 1
%244 = icmp ult i64 %208, 8
br i1 %244, label %278, label %245
245: ; preds = %239
%246 = and i64 %210, 4611686018427387902
br label %247
247: ; preds = %247, %245
%248 = phi i64 [ 0, %245 ], [ %275, %247 ]
%249 = phi i64 [ 0, %245 ], [ %276, %247 ]
%250 = add i64 %248, %226
%251 = add i64 %190, %248
%252 = getelementptr inbounds i32, i32* %225, i64 %251
%253 = bitcast i32* %252 to <4 x i32>*
%254 = load <4 x i32>, <4 x i32>* %253
%255 = getelementptr inbounds i32, i32* %252, i64 4
%256 = bitcast i32* %255 to <4 x i32>*
%257 = load <4 x i32>, <4 x i32>* %256
%258 = getelementptr inbounds i32, i32* %7, i64 %250
%259 = bitcast i32* %258 to <4 x i32>*
store <4 x i32> %254, <4 x i32>* %259
%260 = getelementptr inbounds i32, i32* %258, i64 4
%261 = bitcast i32* %260 to <4 x i32>*
store <4 x i32> %257, <4 x i32>* %261
%262 = or i64 %248, 8
%263 = add i64 %262, %226
%264 = add i64 %190, %262
%265 = getelementptr inbounds i32, i32* %225, i64 %264
%266 = bitcast i32* %265 to <4 x i32>*
%267 = load <4 x i32>, <4 x i32>* %266
%268 = getelementptr inbounds i32, i32* %265, i64 4
%269 = bitcast i32* %268 to <4 x i32>*
%270 = load <4 x i32>, <4 x i32>* %269
%271 = getelementptr inbounds i32, i32* %7, i64 %263
%272 = bitcast i32* %271 to <4 x i32>*
store <4 x i32> %267, <4 x i32>* %272
%273 = getelementptr inbounds i32, i32* %271, i64 4
%274 = bitcast i32* %273 to <4 x i32>*
store <4 x i32> %270, <4 x i32>* %274
%275 = add nuw i64 %248, 16
%276 = add i64 %249, 2
%277 = icmp eq i64 %276, %246
br i1 %277, label %278, label %247
278: ; preds = %247, %239
%279 = phi i64 [ 0, %239 ], [ %275, %247 ]
%280 = icmp eq i64 %243, 0
br i1 %280, label %294, label %281
281: ; preds = %278
%282 = add i64 %279, %226
%283 = add i64 %190, %279
%284 = getelementptr inbounds i32, i32* %225, i64 %283
%285 = bitcast i32* %284 to <4 x i32>*
%286 = load <4 x i32>, <4 x i32>* %285
%287 = getelementptr inbounds i32, i32* %284, i64 4
%288 = bitcast i32* %287 to <4 x i32>*
%289 = load <4 x i32>, <4 x i32>* %288
%290 = getelementptr inbounds i32, i32* %7, i64 %282
%291 = bitcast i32* %290 to <4 x i32>*
store <4 x i32> %286, <4 x i32>* %291
%292 = getelementptr inbounds i32, i32* %290, i64 4
%293 = bitcast i32* %292 to <4 x i32>*
store <4 x i32> %289, <4 x i32>* %293
br label %294
294: ; preds = %278, %281
%295 = icmp eq i64 %212, %240
br i1 %295, label %320, label %296
296: ; preds = %229, %223, %294
%297 = phi i64 [ %226, %229 ], [ %226, %223 ], [ %241, %294 ]
%298 = phi i64 [ %190, %229 ], [ %190, %223 ], [ %242, %294 ]
%299 = sub i64 %205, %298
%300 = xor i64 %298, -1
%301 = add i64 %300, %205
%302 = and i64 %299, 3
%303 = icmp eq i64 %302, 0
br i1 %303, label %315, label %304
304: ; preds = %296, %304
%305 = phi i64 [ %312, %304 ], [ %297, %296 ]
%306 = phi i64 [ %311, %304 ], [ %298, %296 ]
%307 = phi i64 [ %313, %304 ], [ 0, %296 ]
%308 = getelementptr inbounds i32, i32* %225, i64 %306
%309 = load i32, i32* %308
%310 = getelementptr inbounds i32, i32* %7, i64 %305
store i32 %309, i32* %310
%311 = add nuw i64 %306, 1
%312 = add nsw i64 %305, 1
%313 = add i64 %307, 1
%314 = icmp eq i64 %313, %302
br i1 %314, label %315, label %304
315: ; preds = %304, %296
%316 = phi i64 [ undef, %296 ], [ %312, %304 ]
%317 = phi i64 [ %297, %296 ], [ %312, %304 ]
%318 = phi i64 [ %298, %296 ], [ %311, %304 ]
%319 = icmp ult i64 %301, 3
br i1 %319, label %320, label %350
320: ; preds = %315, %350, %294
%321 = phi i64 [ %241, %294 ], [ %316, %315 ], [ %372, %350 ]
%322 = trunc i64 %321 to i32
br label %323
323: ; preds = %320, %187
%324 = phi i32 [ %191, %187 ], [ %322, %320 ]
%325 = sub nsw i64 %148, %190
%326 = icmp slt i64 %190, %325
br i1 %326, label %327, label %377
327: ; preds = %323
%328 = sext i32 %324 to i64
%329 = zext i32 %188 to i64
%330 = and i64 %202, 3
%331 = icmp eq i64 %330, 0
br i1 %331, label %345, label %332
332: ; preds = %327, %332
%333 = phi i64 [ %342, %332 ], [ %328, %327 ]
%334 = phi i64 [ %341, %332 ], [ %190, %327 ]
%335 = phi i64 [ %343, %332 ], [ 0, %327 ]
%336 = getelementptr inbounds i32*, i32** %0, i64 %334
%337 = load i32*, i32** %336
%338 = getelementptr inbounds i32, i32* %337, i64 %221
%339 = load i32, i32* %338
%340 = getelementptr inbounds i32, i32* %7, i64 %333
store i32 %339, i32* %340
%341 = add nuw i64 %334, 1
%342 = add nsw i64 %333, 1
%343 = add i64 %335, 1
%344 = icmp eq i64 %343, %330
br i1 %344, label %345, label %332
345: ; preds = %332, %327
%346 = phi i64 [ undef, %327 ], [ %342, %332 ]
%347 = phi i64 [ %328, %327 ], [ %342, %332 ]
%348 = phi i64 [ %190, %327 ], [ %341, %332 ]
%349 = icmp ult i64 %204, 3
br i1 %349, label %374, label %492
350: ; preds = %315, %350
%351 = phi i64 [ %372, %350 ], [ %317, %315 ]
%352 = phi i64 [ %371, %350 ], [ %318, %315 ]
%353 = getelementptr inbounds i32, i32* %225, i64 %352
%354 = load i32, i32* %353
%355 = getelementptr inbounds i32, i32* %7, i64 %351
store i32 %354, i32* %355
%356 = add nuw i64 %352, 1
%357 = add nsw i64 %351, 1
%358 = getelementptr inbounds i32, i32* %225, i64 %356
%359 = load i32, i32* %358
%360 = getelementptr inbounds i32, i32* %7, i64 %357
store i32 %359, i32* %360
%361 = add nuw i64 %352, 2
%362 = add nsw i64 %351, 2
%363 = getelementptr inbounds i32, i32* %225, i64 %361
%364 = load i32, i32* %363
%365 = getelementptr inbounds i32, i32* %7, i64 %362
store i32 %364, i32* %365
%366 = add nuw i64 %352, 3
%367 = add nsw i64 %351, 3
%368 = getelementptr inbounds i32, i32* %225, i64 %366
%369 = load i32, i32* %368
%370 = getelementptr inbounds i32, i32* %7, i64 %367
store i32 %369, i32* %370
%371 = add nuw i64 %352, 4
%372 = add nsw i64 %351, 4
%373 = icmp eq i64 %371, %227
br i1 %373, label %320, label %350
374: ; preds = %492, %345
%375 = phi i64 [ %346, %345 ], [ %522, %492 ]
%376 = trunc i64 %375 to i32
br label %377
377: ; preds = %374, %323
%378 = phi i32 [ %324, %323 ], [ %376, %374 ]
br i1 %222, label %379, label %527
379: ; preds = %377
%380 = getelementptr inbounds i32*, i32** %0, i64 %325
%381 = load i32*, i32** %380
%382 = sext i32 %378 to i64
%383 = zext i32 %189 to i64
%384 = icmp ult i64 %216, 8
br i1 %384, label %467, label %385
385: ; preds = %379
%386 = getelementptr i32, i32* %7, i64 %382
%387 = add i64 %217, %382
%388 = add i64 %387, %218
%389 = getelementptr i32, i32* %149, i64 %388
%390 = getelementptr i32, i32* %381, i64 %219
%391 = getelementptr i32, i32* %381, i64 %220
%392 = icmp ult i32* %386, %391
%393 = icmp ult i32* %390, %389
%394 = and i1 %392, %393
br i1 %394, label %467, label %395
395: ; preds = %385
%396 = and i64 %216, -8
%397 = add i64 %396, %382
%398 = add i64 %190, %396
%399 = and i64 %200, 1
%400 = icmp ult i64 %198, 8
br i1 %400, label %444, label %401
401: ; preds = %395
%402 = and i64 %200, 4611686018427387902
br label %403
403: ; preds = %403, %401
%404 = phi i64 [ 0, %401 ], [ %441, %403 ]
%405 = phi i64 [ 0, %401 ], [ %442, %403 ]
%406 = add i64 %404, %382
%407 = add i64 %190, %404
%408 = sub nsw i64 %147, %407
%409 = getelementptr inbounds i32, i32* %381, i64 %408
%410 = getelementptr inbounds i32, i32* %409, i64 -3
%411 = bitcast i32* %410 to <4 x i32>*
%412 = load <4 x i32>, <4 x i32>* %411
%413 = shufflevector <4 x i32> %412, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%414 = getelementptr inbounds i32, i32* %409, i64 -4
%415 = getelementptr inbounds i32, i32* %414, i64 -3
%416 = bitcast i32* %415 to <4 x i32>*
%417 = load <4 x i32>, <4 x i32>* %416
%418 = shufflevector <4 x i32> %417, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%419 = getelementptr inbounds i32, i32* %7, i64 %406
%420 = bitcast i32* %419 to <4 x i32>*
store <4 x i32> %413, <4 x i32>* %420
%421 = getelementptr inbounds i32, i32* %419, i64 4
%422 = bitcast i32* %421 to <4 x i32>*
store <4 x i32> %418, <4 x i32>* %422
%423 = or i64 %404, 8
%424 = add i64 %423, %382
%425 = add i64 %190, %423
%426 = sub nsw i64 %147, %425
%427 = getelementptr inbounds i32, i32* %381, i64 %426
%428 = getelementptr inbounds i32, i32* %427, i64 -3
%429 = bitcast i32* %428 to <4 x i32>*
%430 = load <4 x i32>, <4 x i32>* %429
%431 = shufflevector <4 x i32> %430, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%432 = getelementptr inbounds i32, i32* %427, i64 -4
%433 = getelementptr inbounds i32, i32* %432, i64 -3
%434 = bitcast i32* %433 to <4 x i32>*
%435 = load <4 x i32>, <4 x i32>* %434
%436 = shufflevector <4 x i32> %435, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%437 = getelementptr inbounds i32, i32* %7, i64 %424
%438 = bitcast i32* %437 to <4 x i32>*
store <4 x i32> %431, <4 x i32>* %438
%439 = getelementptr inbounds i32, i32* %437, i64 4
%440 = bitcast i32* %439 to <4 x i32>*
store <4 x i32> %436, <4 x i32>* %440
%441 = add nuw i64 %404, 16
%442 = add i64 %405, 2
%443 = icmp eq i64 %442, %402
br i1 %443, label %444, label %403
444: ; preds = %403, %395
%445 = phi i64 [ 0, %395 ], [ %441, %403 ]
%446 = icmp eq i64 %399, 0
br i1 %446, label %465, label %447
447: ; preds = %444
%448 = add i64 %445, %382
%449 = add i64 %190, %445
%450 = sub nsw i64 %147, %449
%451 = getelementptr inbounds i32, i32* %381, i64 %450
%452 = getelementptr inbounds i32, i32* %451, i64 -3
%453 = bitcast i32* %452 to <4 x i32>*
%454 = load <4 x i32>, <4 x i32>* %453
%455 = shufflevector <4 x i32> %454, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%456 = getelementptr inbounds i32, i32* %451, i64 -4
%457 = getelementptr inbounds i32, i32* %456, i64 -3
%458 = bitcast i32* %457 to <4 x i32>*
%459 = load <4 x i32>, <4 x i32>* %458
%460 = shufflevector <4 x i32> %459, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%461 = getelementptr inbounds i32, i32* %7, i64 %448
%462 = bitcast i32* %461 to <4 x i32>*
store <4 x i32> %455, <4 x i32>* %462
%463 = getelementptr inbounds i32, i32* %461, i64 4
%464 = bitcast i32* %463 to <4 x i32>*
store <4 x i32> %460, <4 x i32>* %464
br label %465
465: ; preds = %444, %447
%466 = icmp eq i64 %216, %396
br i1 %466, label %524, label %467
467: ; preds = %385, %379, %465
%468 = phi i64 [ %382, %385 ], [ %382, %379 ], [ %397, %465 ]
%469 = phi i64 [ %190, %385 ], [ %190, %379 ], [ %398, %465 ]
%470 = sub i64 %195, %469
%471 = xor i64 %469, -1
%472 = add i64 %471, %195
%473 = and i64 %470, 3
%474 = icmp eq i64 %473, 0
br i1 %474, label %487, label %475
475: ; preds = %467, %475
%476 = phi i64 [ %484, %475 ], [ %468, %467 ]
%477 = phi i64 [ %483, %475 ], [ %469, %467 ]
%478 = phi i64 [ %485, %475 ], [ 0, %467 ]
%479 = sub nsw i64 %147, %477
%480 = getelementptr inbounds i32, i32* %381, i64 %479
%481 = load i32, i32* %480
%482 = getelementptr inbounds i32, i32* %7, i64 %476
store i32 %481, i32* %482
%483 = add nuw i64 %477, 1
%484 = add nsw i64 %476, 1
%485 = add i64 %478, 1
%486 = icmp eq i64 %485, %473
br i1 %486, label %487, label %475
487: ; preds = %475, %467
%488 = phi i64 [ undef, %467 ], [ %484, %475 ]
%489 = phi i64 [ %468, %467 ], [ %484, %475 ]
%490 = phi i64 [ %469, %467 ], [ %483, %475 ]
%491 = icmp ult i64 %472, 3
br i1 %491, label %524, label %549
492: ; preds = %345, %492
%493 = phi i64 [ %522, %492 ], [ %347, %345 ]
%494 = phi i64 [ %521, %492 ], [ %348, %345 ]
%495 = getelementptr inbounds i32*, i32** %0, i64 %494
%496 = load i32*, i32** %495
%497 = getelementptr inbounds i32, i32* %496, i64 %221
%498 = load i32, i32* %497
%499 = getelementptr inbounds i32, i32* %7, i64 %493
store i32 %498, i32* %499
%500 = add nuw i64 %494, 1
%501 = add nsw i64 %493, 1
%502 = getelementptr inbounds i32*, i32** %0, i64 %500
%503 = load i32*, i32** %502
%504 = getelementptr inbounds i32, i32* %503, i64 %221
%505 = load i32, i32* %504
%506 = getelementptr inbounds i32, i32* %7, i64 %501
store i32 %505, i32* %506
%507 = add nuw i64 %494, 2
%508 = add nsw i64 %493, 2
%509 = getelementptr inbounds i32*, i32** %0, i64 %507
%510 = load i32*, i32** %509
%511 = getelementptr inbounds i32, i32* %510, i64 %221
%512 = load i32, i32* %511
%513 = getelementptr inbounds i32, i32* %7, i64 %508
store i32 %512, i32* %513
%514 = add nuw i64 %494, 3
%515 = add nsw i64 %493, 3
%516 = getelementptr inbounds i32*, i32** %0, i64 %514
%517 = load i32*, i32** %516
%518 = getelementptr inbounds i32, i32* %517, i64 %221
%519 = load i32, i32* %518
%520 = getelementptr inbounds i32, i32* %7, i64 %515
store i32 %519, i32* %520
%521 = add nuw i64 %494, 4
%522 = add nsw i64 %493, 4
%523 = icmp eq i64 %521, %329
br i1 %523, label %374, label %492
524: ; preds = %487, %549, %465
%525 = phi i64 [ %397, %465 ], [ %488, %487 ], [ %575, %549 ]
%526 = trunc i64 %525 to i32
br label %527
527: ; preds = %524, %377
%528 = phi i32 [ %378, %377 ], [ %526, %524 ]
br i1 %326, label %529, label %580
529: ; preds = %527
%530 = sext i32 %528 to i64
%531 = zext i32 %188 to i64
%532 = and i64 %193, 1
%533 = icmp eq i64 %532, 0
br i1 %533, label %543, label %534
534: ; preds = %529
%535 = sub nsw i64 %148, %190
%536 = getelementptr inbounds i32*, i32** %0, i64 %535
%537 = load i32*, i32** %536
%538 = getelementptr inbounds i32, i32* %537, i64 %190
%539 = load i32, i32* %538
%540 = getelementptr inbounds i32, i32* %7, i64 %530
store i32 %539, i32* %540
%541 = add nuw i64 %190, 1
%542 = add nsw i64 %530, 1
br label %543
543: ; preds = %534, %529
%544 = phi i64 [ undef, %529 ], [ %542, %534 ]
%545 = phi i64 [ %530, %529 ], [ %542, %534 ]
%546 = phi i64 [ %190, %529 ], [ %541, %534 ]
%547 = sub nsw i64 0, %192
%548 = icmp eq i64 %194, %547
br i1 %548, label %577, label %586
549: ; preds = %487, %549
%550 = phi i64 [ %575, %549 ], [ %489, %487 ]
%551 = phi i64 [ %574, %549 ], [ %490, %487 ]
%552 = sub nsw i64 %147, %551
%553 = getelementptr inbounds i32, i32* %381, i64 %552
%554 = load i32, i32* %553
%555 = getelementptr inbounds i32, i32* %7, i64 %550
store i32 %554, i32* %555
%556 = xor i64 %551, -1
%557 = add nsw i64 %550, 1
%558 = add i64 %556, %147
%559 = getelementptr inbounds i32, i32* %381, i64 %558
%560 = load i32, i32* %559
%561 = getelementptr inbounds i32, i32* %7, i64 %557
store i32 %560, i32* %561
%562 = add nuw i64 %551, 2
%563 = add nsw i64 %550, 2
%564 = sub nsw i64 %147, %562
%565 = getelementptr inbounds i32, i32* %381, i64 %564
%566 = load i32, i32* %565
%567 = getelementptr inbounds i32, i32* %7, i64 %563
store i32 %566, i32* %567
%568 = add nuw i64 %551, 3
%569 = add nsw i64 %550, 3
%570 = sub nsw i64 %147, %568
%571 = getelementptr inbounds i32, i32* %381, i64 %570
%572 = load i32, i32* %571
%573 = getelementptr inbounds i32, i32* %7, i64 %569
store i32 %572, i32* %573
%574 = add nuw i64 %551, 4
%575 = add nsw i64 %550, 4
%576 = icmp eq i64 %574, %383
br i1 %576, label %524, label %549
577: ; preds = %586, %543
%578 = phi i64 [ %544, %543 ], [ %604, %586 ]
%579 = trunc i64 %578 to i32
br label %580
580: ; preds = %577, %527
%581 = phi i32 [ %528, %527 ], [ %579, %577 ]
%582 = add nuw i64 %190, 1
%583 = icmp slt i32 %581, %142
%584 = add i32 %189, -1
%585 = add i32 %188, -1
br i1 %583, label %187, label %606
586: ; preds = %543, %586
%587 = phi i64 [ %604, %586 ], [ %545, %543 ]
%588 = phi i64 [ %603, %586 ], [ %546, %543 ]
%589 = sub nsw i64 %148, %588
%590 = getelementptr inbounds i32*, i32** %0, i64 %589
%591 = load i32*, i32** %590
%592 = getelementptr inbounds i32, i32* %591, i64 %190
%593 = load i32, i32* %592
%594 = getelementptr inbounds i32, i32* %7, i64 %587
store i32 %593, i32* %594
%595 = xor i64 %588, -1
%596 = add nsw i64 %587, 1
%597 = add i64 %595, %148
%598 = getelementptr inbounds i32*, i32** %0, i64 %597
%599 = load i32*, i32** %598
%600 = getelementptr inbounds i32, i32* %599, i64 %190
%601 = load i32, i32* %600
%602 = getelementptr inbounds i32, i32* %7, i64 %596
store i32 %601, i32* %602
%603 = add nuw i64 %588, 2
%604 = add nsw i64 %587, 2
%605 = icmp eq i64 %603, %531
br i1 %605, label %577, label %586
606: ; preds = %580, %141
%607 = phi i32 [ 0, %141 ], [ %581, %580 ]
%608 = icmp eq i32 %1, %2
br i1 %608, label %609, label %631
609: ; preds = %606
%610 = sdiv i32 %2, 2
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds i32*, i32** %0, i64 %611
%613 = load i32*, i32** %612
%614 = getelementptr inbounds i32, i32* %613, i64 %611
%615 = load i32, i32* %614
%616 = sext i32 %607 to i64
%617 = getelementptr inbounds i32, i32* %7, i64 %616
store i32 %615, i32* %617
br label %631
618: ; preds = %162, %155
%619 = phi i64 [ 0, %155 ], [ %184, %162 ]
%620 = icmp eq i64 %158, 0
br i1 %620, label %631, label %621
621: ; preds = %618, %621
%622 = phi i64 [ %628, %621 ], [ %619, %618 ]
%623 = phi i64 [ %629, %621 ], [ 0, %618 ]
%624 = getelementptr inbounds i32*, i32** %0, i64 %622
%625 = load i32*, i32** %624
%626 = load i32, i32* %625
%627 = getelementptr inbounds i32, i32* %7, i64 %622
store i32 %626, i32* %627
%628 = add nuw nsw i64 %622, 1
%629 = add i64 %623, 1
%630 = icmp eq i64 %629, %158
br i1 %630, label %631, label %621
631: ; preds = %618, %621, %117, %120, %100, %153, %10, %606, %609
ret i32* %7
}