#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 r_max, c_max, i, j, times, size = 0, *ret;
  times =
      ((matrixRowSize < matrixColSize ? matrixRowSize : matrixColSize) + 1) / 2;
  ret = (int *)malloc(matrixRowSize * matrixColSize * sizeof(int));
  for (i = 0; i < times; ++i) {
    r_max = matrixRowSize - 1 - i;
    c_max = matrixColSize - 1 - i;
    if (i == r_max) {
      for (j = i; j <= c_max; ++j)
        ret[size++] = matrix[i][j];
    } else if (i == c_max) {
      for (j = i; j <= r_max; ++j)
        ret[size++] = matrix[j][i];
    } else {
      for (j = i; j < c_max; ++j)
        ret[size++] = matrix[i][j];
      for (j = i; j < r_max; ++j)
        ret[size++] = matrix[j][c_max];
      for (j = c_max; j > i; --j)
        ret[size++] = matrix[r_max][j];
      for (j = r_max; j > i; --j)
        ret[size++] = matrix[j][i];
    }
  }
  return ret;
}


x86 assembly (clang, -O0):
<spiralOrder>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1140 <spiralOrder+0x30>
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1146 <spiralOrder+0x36>
mov    -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x10(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1389 <spiralOrder+0x279>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    11f3 <spiralOrder+0xe3>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     11ee <spiralOrder+0xde>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11ac <spiralOrder+0x9c>
jmp    1376 <spiralOrder+0x266>
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    124c <spiralOrder+0x13c>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1247 <spiralOrder+0x137>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1205 <spiralOrder+0xf5>
jmp    1371 <spiralOrder+0x261>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1294 <spiralOrder+0x184>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1252 <spiralOrder+0x142>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12dc <spiralOrder+0x1cc>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129a <spiralOrder+0x18a>
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    1324 <spiralOrder+0x214>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    12e2 <spiralOrder+0x1d2>
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    136c <spiralOrder+0x25c>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    132a <spiralOrder+0x21a>
jmp    1371 <spiralOrder+0x261>
jmp    1376 <spiralOrder+0x266>
jmp    137b <spiralOrder+0x26b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1176 <spiralOrder+0x66>
mov    -0x30(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spiralOrder>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %edx,%ebx
mov    %esi,%ebp
mov    %rdi,%r13
cmp    %edx,%esi
mov    %edx,%r12d
cmovl  %esi,%r12d
mov    %esi,%edi
imul   %edx,%edi
shl    $0x2,%edi
call   1030 <malloc@plt>
test   %r12d,%r12d
jle    1ad5 <spiralOrder+0x9c5>
mov    %rbp,%r8
mov    %rbx,%r10
add    $0x1,%r12d
shr    %r12d
lea    0x4(%rax),%rcx
mov    %rcx,0x70(%rsp)
lea    -0x1(%rbx),%ecx
lea    -0x1(%rbp),%edx
lea    0x30(%rax),%rsi
mov    %rsi,0x68(%rsp)
lea    0xc(%rax),%rsi
mov    %rsi,0x58(%rsp)
lea    0x3(%rbp),%r9d
lea    0x18(%r13),%rsi
mov    %rsi,0x90(%rsp)
xor    %esi,%esi
mov    %rsi,0x80(%rsp)
mov    $0xc,%esi
mov    %rsi,0x78(%rsp)
movq   $0xfffffffffffffff8,0x60(%rsp)
ff ff
mov    %r8d,%r15d
mov    %edx,0x88(%rsp)
mov    %edx,%esi
mov    %r13,%r14
mov    %ecx,0x8c(%rsp)
mov    %ecx,0x1c(%rsp)
mov    %r10d,%ecx
mov    %r10d,0x34(%rsp)
mov    %r8d,%ecx
mov    %r8d,0x30(%rsp)
xor    %edi,%edi
xor    %r11d,%r11d
mov    %rbx,0x98(%rsp)
mov    %rbp,0x40(%rsp)
mov    %r12,0x20(%rsp)
jmp    1224 <spiralOrder+0x114>
add    %rsi,%r11
mov    0x10(%rsp),%rsi
mov    0x28(%rsp),%rdi
addq   $0x1,0x78(%rsp)
addq   $0xffffffffffffffff,0x60(%rsp)
addl   $0xffffffff,0x1c(%rsp)
addq   $0xffffffffffffffff,0x80(%rsp)
add    $0x8,%r14
add    $0x2,%r9b
add    $0xffffffff,%esi
add    $0x2,%r15b
cmp    %r12,%rdi
je     1ad5 <spiralOrder+0x9c5>
mov    0x30(%rsp),%ecx
mov    %ecx,%edx
mov    0x34(%rsp),%ecx
mov    %ecx,%ebp
movzbl %r15b,%r15d
and    $0x3,%r15d
movzbl %r9b,%r9d
and    $0x3,%r9d
mov    %esi,%esi
mov    %rdi,%rcx
not    %rcx
mov    %rcx,0x8(%rsp)
lea    0x1(%rdi),%rcx
mov    %rcx,0x28(%rsp)
lea    -0x1(%rbp),%ecx
mov    %ecx,0x34(%rsp)
lea    -0x1(%rdx),%ecx
mov    %ecx,0x30(%rsp)
mov    %edi,%ecx
not    %ecx
lea    (%rcx,%r8,1),%ebx
add    %r10d,%ecx
cmp    %rbx,%rdi
jne    1300 <spiralOrder+0x1f0>
movslq %ecx,%rcx
cmp    %rcx,%rdi
jg     11ed <spiralOrder+0xdd>
mov    %rsi,0x10(%rsp)
mov    %ebp,%edx
mov    %rdx,%r12
sub    %rdi,%r12
mov    0x0(%r13,%rdi,8),%rsi
movslq %r11d,%r11
cmp    $0x8,%r12
jb     1550 <spiralOrder+0x440>
lea    (%rax,%r11,4),%rcx
lea    (%rsi,%rdx,4),%rbx
cmp    %rbx,%rcx
jae    12d1 <spiralOrder+0x1c1>
mov    0x8(%rsp),%rbx
add    %r11,%rbx
add    %rdx,%rbx
mov    0x70(%rsp),%rcx
lea    (%rcx,%rbx,4),%rcx
lea    (%rsi,%rdi,4),%rbx
cmp    %rcx,%rbx
jb     1550 <spiralOrder+0x440>
lea    -0x8(%r12),%rbx
mov    %rbx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
cmp    $0x8,%rbx
mov    %rcx,0x8(%rsp)
jae    145d <spiralOrder+0x34d>
xor    %ebx,%ebx
jmp    14cc <spiralOrder+0x3bc>
nopw   0x0(%rax,%rax,1)
mov    %rsi,0x10(%rsp)
mov    %ecx,%esi
cmp    %rsi,%rdi
jne    1370 <spiralOrder+0x260>
movslq %ebx,%rcx
cmp    %rcx,%rdi
jg     11e8 <spiralOrder+0xd8>
mov    %edx,%edx
mov    %rdx,%rcx
sub    %rdi,%rcx
mov    0x8(%rsp),%rbx
add    %rdx,%rbx
movslq %r11d,%r11
test   $0x3,%cl
je     13f1 <spiralOrder+0x2e1>
lea    (%rax,%r11,4),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rsi,8),%rbp
mov    0x0(%rbp,%rdi,4),%ebp
mov    %ebp,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r15
jne    1340 <spiralOrder+0x230>
add    %rsi,%r11
sub    0x80(%rsp),%rsi
cmp    $0x3,%rbx
jb     11e8 <spiralOrder+0xd8>
jmp    13fe <spiralOrder+0x2ee>
xchg   %ax,%ax
mov    0x8c(%rsp),%edx
sub    %edi,%edx
movslq %ecx,%r12
cmp    %r12,%rdi
jge    13a7 <spiralOrder+0x297>
mov    0x1c(%rsp),%r10d
mov    %rdx,%rbp
sub    %rdi,%rbp
mov    0x0(%r13,%rdi,8),%rsi
movslq %r11d,%r11
cmp    $0x8,%rbp
mov    %rdx,0x50(%rsp)
jae    13b1 <spiralOrder+0x2a1>
mov    %rdi,%rbp
jmp    16b7 <spiralOrder+0x5a7>
mov    0x10(%rsp),%rsi
jmp    175c <spiralOrder+0x64c>
lea    (%rax,%r11,4),%rcx
mov    %rdx,%r8
lea    (%rsi,%rdx,4),%rdx
cmp    %rdx,%rcx
jae    151d <spiralOrder+0x40d>
mov    0x8(%rsp),%rcx
add    %r11,%rcx
add    %r8,%rcx
mov    0x70(%rsp),%rdx
lea    (%rdx,%rcx,4),%rcx
lea    (%rsi,%rdi,4),%rdx
cmp    %rcx,%rdx
jae    151d <spiralOrder+0x40d>
mov    %rdi,%rbp
mov    %r8,%rdx
jmp    16b7 <spiralOrder+0x5a7>
mov    %rdi,%rsi
cmp    $0x3,%rbx
jb     11e8 <spiralOrder+0xd8>
sub    %rsi,%rdx
mov    0x90(%rsp),%rcx
lea    (%rcx,%rsi,8),%rcx
mov    0x58(%rsp),%rsi
lea    (%rsi,%r11,4),%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    -0x18(%rcx,%rsi,8),%rbx
mov    (%rbx,%rdi,4),%ebx
mov    %ebx,-0xc(%rbp,%rsi,4)
mov    -0x10(%rcx,%rsi,8),%rbx
mov    (%rbx,%rdi,4),%ebx
mov    %ebx,-0x8(%rbp,%rsi,4)
mov    -0x8(%rcx,%rsi,8),%rbx
mov    (%rbx,%rdi,4),%ebx
mov    %ebx,-0x4(%rbp,%rsi,4)
mov    (%rcx,%rsi,8),%rbx
mov    (%rbx,%rdi,4),%ebx
mov    %ebx,0x0(%rbp,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1420 <spiralOrder+0x310>
jmp    11e5 <spiralOrder+0xd5>
mov    0x60(%rsp),%rcx
add    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
and    $0xfffffffffffffffe,%rcx
mov    0x78(%rsp),%rbx
lea    (%rsi,%rbx,4),%r8
mov    0x68(%rsp),%rbx
lea    (%rbx,%r11,4),%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%r8,%rbx,4),%xmm0
movups -0x20(%r8,%rbx,4),%xmm1
movups %xmm0,-0x30(%r10,%rbx,4)
movups %xmm1,-0x20(%r10,%rbx,4)
movdqu -0x10(%r8,%rbx,4),%xmm0
movdqu (%r8,%rbx,4),%xmm1
movdqu %xmm0,-0x10(%r10,%rbx,4)
movdqu %xmm1,(%r10,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1490 <spiralOrder+0x380>
mov    %r12,%rcx
and    $0xfffffffffffffff8,%rcx
testb  $0x1,0x8(%rsp)
mov    0x98(%rsp),%r10
mov    0x40(%rsp),%r8
je     150b <spiralOrder+0x3fb>
lea    (%rdi,%rbx,1),%r8
add    %r11,%rbx
movdqu (%rsi,%r8,4),%xmm0
movdqu 0x10(%rsi,%r8,4),%xmm1
mov    0x40(%rsp),%r8
movdqu %xmm0,(%rax,%rbx,4)
movdqu %xmm1,0x10(%rax,%rbx,4)
add    %rcx,%r11
cmp    %rcx,%r12
jne    1548 <spiralOrder+0x438>
mov    0x20(%rsp),%r12
jmp    11e8 <spiralOrder+0xd8>
mov    %rbp,0x48(%rsp)
lea    -0x8(%rbp),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,0x38(%rsp)
cmp    $0x8,%rcx
jae    15fc <spiralOrder+0x4ec>
xor    %r8d,%r8d
jmp    166c <spiralOrder+0x55c>
add    %rcx,%rdi
nopl   0x0(%rax,%rax,1)
mov    %edx,%ecx
sub    %edi,%ecx
mov    %rdi,%rbx
not    %rbx
add    %rdx,%rbx
test   $0x3,%cl
je     15a1 <spiralOrder+0x491>
sub    %dil,%bpl
movzbl %bpl,%ecx
and    $0x3,%ecx
mov    0x20(%rsp),%r12
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rdi,4),%ebp
mov    %ebp,(%rax,%r11,4)
add    $0x1,%r11
add    $0x1,%rdi
add    $0xffffffffffffffff,%rcx
jne    1580 <spiralOrder+0x470>
cmp    $0x3,%rbx
jb     11e8 <spiralOrder+0xd8>
jmp    15b0 <spiralOrder+0x4a0>
mov    0x20(%rsp),%r12
cmp    $0x3,%rbx
jb     11e8 <spiralOrder+0xd8>
sub    %rdi,%rdx
lea    (%rsi,%rdi,4),%rcx
add    $0xc,%rcx
mov    0x58(%rsp),%rsi
lea    (%rsi,%r11,4),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    -0xc(%rcx,%rsi,4),%ebp
mov    %ebp,-0xc(%rdi,%rsi,4)
mov    -0x8(%rcx,%rsi,4),%ebp
mov    %ebp,-0x8(%rdi,%rsi,4)
mov    -0x4(%rcx,%rsi,4),%ebp
mov    %ebp,-0x4(%rdi,%rsi,4)
mov    (%rcx,%rsi,4),%ebp
mov    %ebp,(%rdi,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    15d0 <spiralOrder+0x4c0>
jmp    11e5 <spiralOrder+0xd5>
mov    0x60(%rsp),%rcx
lea    (%rcx,%r10,1),%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
mov    0x78(%rsp),%rcx
lea    (%rsi,%rcx,4),%rcx
mov    0x68(%rsp),%rdx
lea    (%rdx,%r11,4),%rdx
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rcx,%r8,4),%xmm0
movups -0x20(%rcx,%r8,4),%xmm1
movups %xmm0,-0x30(%rdx,%r8,4)
movups %xmm1,-0x20(%rdx,%r8,4)
movdqu -0x10(%rcx,%r8,4),%xmm0
movdqu (%rcx,%r8,4),%xmm1
movdqu %xmm0,-0x10(%rdx,%r8,4)
movdqu %xmm1,(%rdx,%r8,4)
add    $0x10,%r8
add    $0xfffffffffffffffe,%rbp
jne    1630 <spiralOrder+0x520>
mov    0x48(%rsp),%rbp
and    $0xfffffffffffffff8,%rbp
testb  $0x1,0x38(%rsp)
je     169b <spiralOrder+0x58b>
lea    (%rdi,%r8,1),%rcx
add    %r11,%r8
movdqu (%rsi,%rcx,4),%xmm0
movdqu 0x10(%rsi,%rcx,4),%xmm1
movdqu %xmm0,(%rax,%r8,4)
movdqu %xmm1,0x10(%rax,%r8,4)
add    %rbp,%r11
cmp    %rbp,0x48(%rsp)
jne    16af <spiralOrder+0x59f>
mov    0x40(%rsp),%r8
jmp    174a <spiralOrder+0x63a>
add    %rdi,%rbp
mov    0x50(%rsp),%rdx
mov    %edx,%ecx
sub    %ebp,%ecx
mov    %rbp,%r8
not    %r8
add    %rdx,%r8
test   $0x3,%cl
je     16f5 <spiralOrder+0x5e5>
mov    0x1c(%rsp),%ecx
sub    %bpl,%cl
movzbl %cl,%ecx
and    $0x3,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%rbp,4),%edx
mov    %edx,(%rax,%r11,4)
add    $0x1,%r11
add    $0x1,%rbp
add    $0xffffffffffffffff,%rcx
jne    16e0 <spiralOrder+0x5d0>
cmp    $0x3,%r8
mov    0x40(%rsp),%r8
jb     174a <spiralOrder+0x63a>
sub    %rbp,%r10
lea    (%rsi,%rbp,4),%rcx
add    $0xc,%rcx
mov    0x58(%rsp),%rdx
lea    (%rdx,%r11,4),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
mov    -0xc(%rcx,%rdx,4),%ebp
mov    %ebp,-0xc(%rsi,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%ebp
mov    %ebp,-0x8(%rsi,%rdx,4)
mov    -0x4(%rcx,%rdx,4),%ebp
mov    %ebp,-0x4(%rsi,%rdx,4)
mov    (%rcx,%rdx,4),%ebp
mov    %ebp,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r10
jne    1720 <spiralOrder+0x610>
add    %rdx,%r11
mov    0x98(%rsp),%r10
mov    0x10(%rsp),%rsi
mov    0x50(%rsp),%rdx
mov    0x88(%rsp),%ecx
mov    %ecx,%ebp
sub    %edi,%ebp
movslq %ebx,%rbx
mov    %rbx,%rcx
mov    %rbx,0x48(%rsp)
cmp    %rbx,%rdi
jge    1864 <spiralOrder+0x754>
mov    %r10,%r8
mov    %rdx,%r10
mov    0x8(%rsp),%rcx
lea    (%rcx,%rbp,1),%rdx
mov    %rbp,%rcx
sub    %rdi,%rcx
movslq %r11d,%r11
test   $0x3,%cl
je     17db <spiralOrder+0x6cb>
mov    %rbp,%rbx
lea    (%rax,%r11,4),%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rsi,8),%rbp
mov    0x0(%rbp,%r12,4),%ebp
mov    %ebp,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r9
jne    17b0 <spiralOrder+0x6a0>
add    %rsi,%r11
sub    0x80(%rsp),%rsi
mov    %rbx,%rbp
cmp    $0x3,%rdx
jae    17e4 <spiralOrder+0x6d4>
jmp    1854 <spiralOrder+0x744>
mov    %rdi,%rsi
cmp    $0x3,%rdx
jb     1854 <spiralOrder+0x744>
mov    %rbp,0x38(%rsp)
mov    0x10(%rsp),%rcx
sub    %rsi,%rcx
mov    0x90(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
mov    0x58(%rsp),%rsi
lea    (%rsi,%r11,4),%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    -0x18(%rdx,%rsi,8),%rbx
mov    (%rbx,%r12,4),%ebx
mov    %ebx,-0xc(%rbp,%rsi,4)
mov    -0x10(%rdx,%rsi,8),%rbx
mov    (%rbx,%r12,4),%ebx
mov    %ebx,-0x8(%rbp,%rsi,4)
mov    -0x8(%rdx,%rsi,8),%rbx
mov    (%rbx,%r12,4),%ebx
mov    %ebx,-0x4(%rbp,%rsi,4)
mov    (%rdx,%rsi,8),%rbx
mov    (%rbx,%r12,4),%ebx
mov    %ebx,0x0(%rbp,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1810 <spiralOrder+0x700>
add    %rsi,%r11
mov    0x38(%rsp),%rbp
mov    0x10(%rsp),%rsi
mov    %r10,%rdx
mov    %r8,%r10
mov    0x40(%rsp),%r8
cmp    %r12,%rdi
jge    1899 <spiralOrder+0x789>
movslq %edx,%r12
mov    %r12,%rcx
sub    %rdi,%rcx
movslq 0x34(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    0x0(%r13,%rsi,8),%rsi
movslq %r11d,%r11
cmp    $0x8,%rcx
jae    18b3 <spiralOrder+0x7a3>
mov    0x20(%rsp),%r12
mov    0x8(%rsp),%rbx
jmp    1a20 <spiralOrder+0x910>
mov    0x20(%rsp),%r12
mov    0x8(%rsp),%rbx
cmp    0x48(%rsp),%rdi
jge    11ed <spiralOrder+0xdd>
jmp    1a44 <spiralOrder+0x934>
mov    %rbp,0x38(%rsp)
lea    (%rax,%r11,4),%rbp
lea    (%rsi,%r12,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%rbp
jae    18ff <spiralOrder+0x7ef>
mov    0x8(%rsp),%rbx
add    %rbx,%r12
add    %r11,%r12
mov    0x70(%rsp),%rbx
lea    (%rbx,%r12,4),%r12
mov    0x28(%rsp),%rbx
lea    (%rsi,%rbx,4),%rbp
cmp    %r12,%rbp
jae    18ff <spiralOrder+0x7ef>
mov    0x20(%rsp),%r12
mov    0x8(%rsp),%rbx
mov    0x38(%rsp),%rbp
jmp    1a20 <spiralOrder+0x910>
mov    %rcx,0x50(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %rbp,0xa0(%rsp)
cmp    $0x8,%rcx
jae    1928 <spiralOrder+0x818>
xor    %ebx,%ebx
jmp    19b8 <spiralOrder+0x8a8>
movslq 0x1c(%rsp),%rcx
mov    0x60(%rsp),%rbp
add    %rcx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rsi,%rcx,4),%r12
add    $0xfffffffffffffff4,%r12
mov    0x68(%rsp),%rcx
lea    (%rcx,%r11,4),%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu -0x10(%r12),%xmm0
movdqu (%r12),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x30(%r8,%rbx,4)
movdqu %xmm0,-0x20(%r8,%rbx,4)
movdqu -0x30(%r12),%xmm0
movdqu -0x20(%r12),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x10(%r8,%rbx,4)
movdqu %xmm0,(%r8,%rbx,4)
add    $0x10,%rbx
add    $0xffffffffffffffc0,%r12
add    $0xfffffffffffffffe,%rbp
jne    1960 <spiralOrder+0x850>
mov    0x50(%rsp),%r8
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
testb  $0x1,0xa0(%rsp)
01
je     19f8 <spiralOrder+0x8e8>
mov    %rdx,%rbp
sub    %rbx,%rbp
add    %r11,%rbx
movdqu -0x1c(%rsi,%rbp,4),%xmm0
movdqu -0xc(%rsi,%rbp,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%rax,%rbx,4)
movdqu %xmm0,0x10(%rax,%rbx,4)
add    %rcx,%r11
cmp    %rcx,%r8
mov    0x40(%rsp),%r8
mov    0x20(%rsp),%r12
mov    0x8(%rsp),%rbx
mov    0x38(%rsp),%rbp
je     1a34 <spiralOrder+0x924>
sub    %rcx,%rdx
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rdx,4),%ecx
mov    %ecx,(%rax,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rdx
cmp    %rdi,%rdx
jg     1a20 <spiralOrder+0x910>
mov    0x10(%rsp),%rsi
cmp    0x48(%rsp),%rdi
jge    11ed <spiralOrder+0xdd>
movslq %ebp,%rcx
add    %rcx,%rbx
sub    %rdi,%rcx
movslq 0x30(%rsp),%rdx
movslq %r11d,%r11
test   $0x3,%cl
je     1a7a <spiralOrder+0x96a>
mov    %r9,%rcx
nopl   (%rax)
mov    0x0(%r13,%rdx,8),%rsi
mov    (%rsi,%rdi,4),%esi
mov    %esi,(%rax,%r11,4)
add    $0x1,%r11
add    $0xffffffffffffffff,%rdx
add    $0xffffffffffffffff,%rcx
jne    1a60 <spiralOrder+0x950>
cmp    $0x3,%rbx
jb     11e8 <spiralOrder+0xd8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rdx,8),%rcx
mov    (%rcx,%rdi,4),%ecx
mov    %ecx,(%rax,%r11,4)
mov    -0x8(%r13,%rdx,8),%rcx
mov    (%rcx,%rdi,4),%ecx
mov    %ecx,0x4(%rax,%r11,4)
mov    -0x10(%r13,%rdx,8),%rcx
mov    (%rcx,%rdi,4),%ecx
mov    %ecx,0x8(%rax,%r11,4)
mov    -0x18(%r13,%rdx,8),%rcx
mov    (%rcx,%rdi,4),%ecx
mov    %ecx,0xc(%rax,%r11,4)
add    $0x4,%r11
add    $0xfffffffffffffffc,%rdx
cmp    %rdi,%rdx
jg     1a90 <spiralOrder+0x980>
jmp    11e8 <spiralOrder+0xd8>
add    $0xa8,%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*
store i32** %0, i32*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store i32 0, i32* %12
%14 = load i32, i32* %5
%15 = load i32, i32* %6
%16 = icmp slt i32 %14, %15
br i1 %16, label %17, label %19
17: ; preds = %3
%18 = load i32, i32* %5
br label %21
19: ; preds = %3
%20 = load i32, i32* %6
br label %21
21: ; preds = %19, %17
%22 = phi i32 [ %18, %17 ], [ %20, %19 ]
%23 = add nsw i32 %22, 1
%24 = sdiv i32 %23, 2
store i32 %24, i32* %11
%25 = load i32, i32* %5
%26 = load i32, i32* %6
%27 = mul nsw i32 %25, %26
%28 = sext i32 %27 to i64
%29 = mul i64 %28, 4
%30 = trunc i64 %29 to i32
%31 = call i64 @malloc(i32 %30)
%32 = inttoptr i64 %31 to i32*
store i32* %32, i32** %13
store i32 0, i32* %9
br label %33
33: ; preds = %202, %21
%34 = load i32, i32* %9
%35 = load i32, i32* %11
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %205
37: ; preds = %33
%38 = load i32, i32* %5
%39 = sub nsw i32 %38, 1
%40 = load i32, i32* %9
%41 = sub nsw i32 %39, %40
store i32 %41, i32* %7
%42 = load i32, i32* %6
%43 = sub nsw i32 %42, 1
%44 = load i32, i32* %9
%45 = sub nsw i32 %43, %44
store i32 %45, i32* %8
%46 = load i32, i32* %9
%47 = load i32, i32* %7
%48 = icmp eq i32 %46, %47
br i1 %48, label %49, label %74
49: ; preds = %37
%50 = load i32, i32* %9
store i32 %50, i32* %10
br label %51
51: ; preds = %70, %49
%52 = load i32, i32* %10
%53 = load i32, i32* %8
%54 = icmp sle i32 %52, %53
br i1 %54, label %55, label %73
55: ; preds = %51
%56 = load i32**, i32*** %4
%57 = load i32, i32* %9
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32*, i32** %56, i64 %58
%60 = load i32*, i32** %59
%61 = load i32, i32* %10
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %60, i64 %62
%64 = load i32, i32* %63
%65 = load i32*, i32** %13
%66 = load i32, i32* %12
%67 = add nsw i32 %66, 1
store i32 %67, i32* %12
%68 = sext i32 %66 to i64
%69 = getelementptr inbounds i32, i32* %65, i64 %68
store i32 %64, i32* %69
br label %70
70: ; preds = %55
%71 = load i32, i32* %10
%72 = add nsw i32 %71, 1
store i32 %72, i32* %10
br label %51
73: ; preds = %51
br label %201
74: ; preds = %37
%75 = load i32, i32* %9
%76 = load i32, i32* %8
%77 = icmp eq i32 %75, %76
br i1 %77, label %78, label %103
78: ; preds = %74
%79 = load i32, i32* %9
store i32 %79, i32* %10
br label %80
80: ; preds = %99, %78
%81 = load i32, i32* %10
%82 = load i32, i32* %7
%83 = icmp sle i32 %81, %82
br i1 %83, label %84, label %102
84: ; preds = %80
%85 = load i32**, i32*** %4
%86 = load i32, i32* %10
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i32*, i32** %85, i64 %87
%89 = load i32*, i32** %88
%90 = load i32, i32* %9
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i32, i32* %89, i64 %91
%93 = load i32, i32* %92
%94 = load i32*, i32** %13
%95 = load i32, i32* %12
%96 = add nsw i32 %95, 1
store i32 %96, i32* %12
%97 = sext i32 %95 to i64
%98 = getelementptr inbounds i32, i32* %94, i64 %97
store i32 %93, i32* %98
br label %99
99: ; preds = %84
%100 = load i32, i32* %10
%101 = add nsw i32 %100, 1
store i32 %101, i32* %10
br label %80
102: ; preds = %80
br label %200
103: ; preds = %74
%104 = load i32, i32* %9
store i32 %104, i32* %10
br label %105
105: ; preds = %124, %103
%106 = load i32, i32* %10
%107 = load i32, i32* %8
%108 = icmp slt i32 %106, %107
br i1 %108, label %109, label %127
109: ; preds = %105
%110 = load i32**, i32*** %4
%111 = load i32, i32* %9
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32*, i32** %110, i64 %112
%114 = load i32*, i32** %113
%115 = load i32, i32* %10
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %114, i64 %116
%118 = load i32, i32* %117
%119 = load i32*, i32** %13
%120 = load i32, i32* %12
%121 = add nsw i32 %120, 1
store i32 %121, i32* %12
%122 = sext i32 %120 to i64
%123 = getelementptr inbounds i32, i32* %119, i64 %122
store i32 %118, i32* %123
br label %124
124: ; preds = %109
%125 = load i32, i32* %10
%126 = add nsw i32 %125, 1
store i32 %126, i32* %10
br label %105
127: ; preds = %105
%128 = load i32, i32* %9
store i32 %128, i32* %10
br label %129
129: ; preds = %148, %127
%130 = load i32, i32* %10
%131 = load i32, i32* %7
%132 = icmp slt i32 %130, %131
br i1 %132, label %133, label %151
133: ; preds = %129
%134 = load i32**, i32*** %4
%135 = load i32, i32* %10
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32*, i32** %134, i64 %136
%138 = load i32*, i32** %137
%139 = load i32, i32* %8
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %138, i64 %140
%142 = load i32, i32* %141
%143 = load i32*, i32** %13
%144 = load i32, i32* %12
%145 = add nsw i32 %144, 1
store i32 %145, i32* %12
%146 = sext i32 %144 to i64
%147 = getelementptr inbounds i32, i32* %143, i64 %146
store i32 %142, i32* %147
br label %148
148: ; preds = %133
%149 = load i32, i32* %10
%150 = add nsw i32 %149, 1
store i32 %150, i32* %10
br label %129
151: ; preds = %129
%152 = load i32, i32* %8
store i32 %152, i32* %10
br label %153
153: ; preds = %172, %151
%154 = load i32, i32* %10
%155 = load i32, i32* %9
%156 = icmp sgt i32 %154, %155
br i1 %156, label %157, label %175
157: ; preds = %153
%158 = load i32**, i32*** %4
%159 = load i32, i32* %7
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32*, i32** %158, i64 %160
%162 = load i32*, i32** %161
%163 = load i32, i32* %10
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %162, i64 %164
%166 = load i32, i32* %165
%167 = load i32*, i32** %13
%168 = load i32, i32* %12
%169 = add nsw i32 %168, 1
store i32 %169, i32* %12
%170 = sext i32 %168 to i64
%171 = getelementptr inbounds i32, i32* %167, i64 %170
store i32 %166, i32* %171
br label %172
172: ; preds = %157
%173 = load i32, i32* %10
%174 = add nsw i32 %173, -1
store i32 %174, i32* %10
br label %153
175: ; preds = %153
%176 = load i32, i32* %7
store i32 %176, i32* %10
br label %177
177: ; preds = %196, %175
%178 = load i32, i32* %10
%179 = load i32, i32* %9
%180 = icmp sgt i32 %178, %179
br i1 %180, label %181, label %199
181: ; preds = %177
%182 = load i32**, i32*** %4
%183 = load i32, i32* %10
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i32*, i32** %182, i64 %184
%186 = load i32*, i32** %185
%187 = load i32, i32* %9
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %186, i64 %188
%190 = load i32, i32* %189
%191 = load i32*, i32** %13
%192 = load i32, i32* %12
%193 = add nsw i32 %192, 1
store i32 %193, i32* %12
%194 = sext i32 %192 to i64
%195 = getelementptr inbounds i32, i32* %191, i64 %194
store i32 %190, i32* %195
br label %196
196: ; preds = %181
%197 = load i32, i32* %10
%198 = add nsw i32 %197, -1
store i32 %198, i32* %10
br label %177
199: ; preds = %177
br label %200
200: ; preds = %199, %102
br label %201
201: ; preds = %200, %73
br label %202
202: ; preds = %201
%203 = load i32, i32* %9
%204 = add nsw i32 %203, 1
store i32 %204, i32* %9
br label %33
205: ; preds = %33
%206 = load i32*, i32** %13
ret i32* %206
}

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