#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 *ret = (int *)malloc(sizeof(int) * matrixRowSize * matrixColSize);
  int i;
  int count = 0;
  int m = 0;
  int n = -1;
  while (1) {
    for (i = 0; i < matrixColSize; i++) {
      ret[count++] = matrix[m][++n];
    }
    if (--matrixRowSize <= 0) {
      break;
    }
    for (i = 0; i < matrixRowSize; i++) {
      ret[count++] = matrix[++m][n];
    }
    if (--matrixColSize <= 0) {
      break;
    }
    for (i = 0; i < matrixColSize; i++) {
      ret[count++] = matrix[m][--n];
    }
    if (--matrixRowSize <= 0) {
      break;
    }
    for (i = 0; i < matrixRowSize; i++) {
      ret[count++] = matrix[--m][n];
    }
    if (--matrixColSize <= 0) {
      break;
    }
  }
  return ret;
}


x86 assembly (clang, -O0):
<spiralOrder>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
movslq -0x10(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0xffffffff,-0x28(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11a3 <spiralOrder+0x93>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1159 <spiralOrder+0x49>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
cmp    $0x0,%eax
jg     11ba <spiralOrder+0xaa>
jmp    12f7 <spiralOrder+0x1e7>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    120b <spiralOrder+0xfb>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c1 <spiralOrder+0xb1>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
cmp    $0x0,%eax
jg     1222 <spiralOrder+0x112>
jmp    12f7 <spiralOrder+0x1e7>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1273 <spiralOrder+0x163>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x28(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x28(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1229 <spiralOrder+0x119>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
cmp    $0x0,%eax
jg     128a <spiralOrder+0x17a>
jmp    12f7 <spiralOrder+0x1e7>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12db <spiralOrder+0x1cb>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1291 <spiralOrder+0x181>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
cmp    $0x0,%eax
jg     12f2 <spiralOrder+0x1e2>
jmp    12f7 <spiralOrder+0x1e7>
jmp    1152 <spiralOrder+0x42>
mov    -0x18(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<spiralOrder>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %edx,%r14d
mov    %esi,%r13d
mov    %rdi,%r12
mov    %esi,%edi
imul   %edx,%edi
shl    $0x2,%edi
call   1030 <malloc@plt>
lea    -0x1(%r13),%r15d
lea    -0x1(%r14),%ecx
mov    %ecx,0x14(%rsp)
lea    0x4(%rax),%rcx
mov    %rcx,0x60(%rsp)
lea    -0x2(%r14),%ecx
lea    -0x2(%r13),%edx
lea    -0x3(%r13),%esi
mov    %esi,0x50(%rsp)
lea    0x30(%rax),%rsi
mov    %rsi,0x58(%rsp)
mov    %r14d,%esi
neg    %esi
mov    %esi,0x30(%rsp)
lea    0x8(%r12),%rsi
mov    %rsi,0x70(%rsp)
mov    $0xffffffff,%r11d
xor    %esi,%esi
mov    %rsi,0x40(%rsp)
mov    %edx,0x34(%rsp)
mov    %edx,0x10(%rsp)
mov    %ecx,0x54(%rsp)
mov    %ecx,0x2c(%rsp)
xor    %r10d,%r10d
xor    %r9d,%r9d
jmp    11e0 <spiralOrder+0xd0>
nopw   0x0(%rax,%rax,1)
add    $0xfffffffe,%r13d
lea    -0x2(%r14),%ecx
add    $0xfffffffe,%r15d
add    $0xfffffffe,%ebx
mov    0x40(%rsp),%rdx
add    $0x1,%edx
mov    %rdx,0x40(%rsp)
addl   $0x2,0x30(%rsp)
addl   $0xfffffffe,0x2c(%rsp)
add    $0xfffffffe,%ebp
mov    %ebp,0x10(%rsp)
mov    %ebx,%edx
mov    %ebx,0x14(%rsp)
cmp    $0x2,%r14d
mov    %ecx,%r14d
jle    1789 <spiralOrder+0x679>
mov    0x14(%rsp),%ebx
test   %r14d,%r14d
mov    %rbx,0x20(%rsp)
jle    13d0 <spiralOrder+0x2c0>
mov    %r15d,0xc(%rsp)
mov    %r14,0x18(%rsp)
movslq %r9d,%rcx
mov    (%r12,%rcx,8),%r14
movslq %r11d,%r11
movslq %r10d,%r10
xor    %r15d,%r15d
cmp    $0x7,%ebx
jb     1310 <spiralOrder+0x200>
lea    (%rax,%r10,4),%rdx
lea    (%r11,%rbx,1),%rsi
lea    (%r14,%rsi,4),%rsi
add    $0x8,%rsi
cmp    %rsi,%rdx
jae    1248 <spiralOrder+0x138>
lea    (%r10,%rbx,1),%rdx
mov    0x60(%rsp),%rcx
lea    (%rcx,%rdx,4),%rdx
lea    (%r14,%r11,4),%rsi
add    $0x4,%rsi
cmp    %rdx,%rsi
jb     1310 <spiralOrder+0x200>
lea    0x1(%rbx),%r8
mov    %r8,%r15
movabs $0x1fffffff8,%rcx
and    %rcx,%r15
lea    -0x8(%r15),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     1778 <spiralOrder+0x668>
mov    %r8,%rdi
and    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffff8,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x58(%rsp),%rcx
lea    (%rcx,%r10,4),%rbx
lea    (%r14,%r11,4),%rsi
add    $0x34,%rsi
xor    %edx,%edx
xchg   %ax,%ax
movups -0x30(%rsi,%rdx,4),%xmm0
movups -0x20(%rsi,%rdx,4),%xmm1
movups %xmm0,-0x30(%rbx,%rdx,4)
movups %xmm1,-0x20(%rbx,%rdx,4)
movdqu -0x10(%rsi,%rdx,4),%xmm0
movdqu (%rsi,%rdx,4),%xmm1
movdqu %xmm0,-0x10(%rbx,%rdx,4)
movdqu %xmm1,(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12a0 <spiralOrder+0x190>
test   $0x1,%bpl
je     12fa <spiralOrder+0x1ea>
lea    (%rdx,%r10,1),%rsi
add    %r11,%rdx
movdqu 0x4(%r14,%rdx,4),%xmm0
movdqu 0x14(%r14,%rdx,4),%xmm1
movdqu %xmm0,(%rax,%rsi,4)
movdqu %xmm1,0x10(%rax,%rsi,4)
add    %r15,%r10
add    %r15,%r11
cmp    %r15,%r8
mov    0x20(%rsp),%rbx
je     13c6 <spiralOrder+0x2b6>
xchg   %ax,%ax
mov    0x18(%rsp),%rcx
mov    %ecx,%edx
sub    %r15d,%edx
mov    %ebx,%r8d
sub    %r15d,%r8d
test   $0x3,%dl
je     1372 <spiralOrder+0x262>
lea    (%rax,%r10,4),%rdx
lea    (%r14,%r11,4),%rbp
mov    %ecx,%ebx
sub    %r15b,%bl
movzbl %bl,%ebx
and    $0x3,%ebx
neg    %ebx
mov    $0x4,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x0(%rbp,%rsi,1),%ecx
mov    %ecx,-0x4(%rdx,%rsi,1)
add    $0x4,%rsi
add    $0xffffffffffffffff,%rdi
cmp    %edi,%ebx
jne    1350 <spiralOrder+0x240>
sub    %rdi,%r10
sub    %rdi,%r11
sub    %edi,%r15d
mov    0x20(%rsp),%rbx
cmp    $0x3,%r8d
jb     13c6 <spiralOrder+0x2b6>
lea    (%rax,%r10,4),%rdx
lea    (%r14,%r11,4),%rdi
add    0x30(%rsp),%r15d
mov    $0xc,%ebx
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    -0x8(%rdi,%rbx,1),%ecx
mov    %ecx,-0xc(%rdx,%rbx,1)
mov    -0x4(%rdi,%rbx,1),%ecx
mov    %ecx,-0x8(%rdx,%rbx,1)
mov    (%rdi,%rbx,1),%ecx
mov    %ecx,-0x4(%rdx,%rbx,1)
mov    0x4(%rdi,%rbx,1),%ecx
mov    %ecx,(%rdx,%rbx,1)
add    $0xfffffffffffffffc,%rbp
add    $0x10,%rbx
cmp    %ebp,%r15d
jne    1390 <spiralOrder+0x280>
sub    %rbp,%r10
sub    %rbp,%r11
mov    0x20(%rsp),%rbx
mov    0x18(%rsp),%r14
mov    0xc(%rsp),%r15d
cmp    $0x2,%r13d
jl     1789 <spiralOrder+0x679>
mov    0x40(%rsp),%rcx
lea    (%rcx,%rcx,1),%ebp
movslq %r9d,%rsi
movslq %r11d,%r11
movslq %r10d,%r8
cmp    %ebp,0x34(%rsp)
jne    1410 <spiralOrder+0x300>
test   $0x1,%r15b
jne    147f <spiralOrder+0x36f>
cmp    $0x2,%r14d
jge    149e <spiralOrder+0x38e>
jmp    1789 <spiralOrder+0x679>
nopw   0x0(%rax,%rax,1)
mov    %ebp,%r9d
mov    %r15d,%edx
and    $0xfffffffe,%edx
neg    %edx
lea    (%rax,%r8,4),%rdi
mov    0x70(%rsp),%rcx
mov    %rsi,%r10
lea    (%rcx,%rsi,8),%rbx
mov    $0x4,%esi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x8(%rbx,%rsi,2),%rcx
mov    (%rcx,%r11,4),%ecx
mov    %ecx,-0x4(%rdi,%rsi,1)
mov    (%rbx,%rsi,2),%rcx
mov    (%rcx,%r11,4),%ecx
mov    %ecx,(%rdi,%rsi,1)
add    $0xfffffffffffffffe,%rbp
add    $0x8,%rsi
cmp    %ebp,%edx
jne    1440 <spiralOrder+0x330>
sub    %rbp,%r8
mov    %r10,%rsi
sub    %rbp,%rsi
mov    0x20(%rsp),%rbx
mov    %r9d,%ebp
test   $0x1,%r15b
je     13fb <spiralOrder+0x2eb>
mov    0x8(%r12,%rsi,8),%rcx
add    $0x1,%rsi
mov    (%rcx,%r11,4),%ecx
mov    %ecx,(%rax,%r8,4)
add    $0x1,%r8
cmp    $0x2,%r14d
jl     1789 <spiralOrder+0x679>
mov    0x54(%rsp),%ecx
mov    %ecx,%r10d
sub    %ebp,%r10d
movslq %esi,%rcx
mov    (%r12,%rcx,8),%r9
movslq %r8d,%rdi
xor    %ecx,%ecx
cmp    $0x7,%r10d
mov    %rsi,0x18(%rsp)
jb     1640 <spiralOrder+0x530>
lea    (%rax,%rdi,4),%rdx
lea    (%r9,%r11,4),%rsi
cmp    %rsi,%rdx
jae    1500 <spiralOrder+0x3f0>
lea    (%rdi,%r10,1),%rdx
mov    0x60(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    %r11,%rsi
sub    %r10,%rsi
lea    (%r9,%rsi,4),%rsi
add    $0xfffffffffffffffc,%rsi
cmp    %rdx,%rsi
jae    1500 <spiralOrder+0x3f0>
mov    0x18(%rsp),%rsi
jmp    1640 <spiralOrder+0x530>
nopw   0x0(%rax,%rax,1)
mov    %r13,0x38(%rsp)
lea    0x1(%r10),%rbx
mov    %rbx,%rcx
movabs $0x1fffffff8,%rdx
and    %rdx,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     15ea <spiralOrder+0x4da>
mov    %rbx,0x68(%rsp)
mov    %ebp,0x4c(%rsp)
mov    %r15d,0xc(%rsp)
mov    %r14,%rsi
mov    0x2c(%rsp),%r8d
add    $0x1,%r8
and    $0xfffffffffffffff8,%r8
add    $0xfffffffffffffff8,%r8
shr    $0x3,%r8
add    $0x1,%r8
and    $0xfffffffffffffffe,%r8
mov    0x58(%rsp),%rbp
lea    0x0(,%rdi,4),%r14
add    %rbp,%r14
lea    (%r9,%r11,4),%r15
add    $0xfffffffffffffff0,%r15
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%r15,%r13,4),%xmm0
movdqu (%r15,%r13,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x30(%r14)
movdqu %xmm0,-0x20(%r14)
movdqu -0x30(%r15,%r13,4),%xmm0
movdqu -0x20(%r15,%r13,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,-0x10(%r14)
movdqu %xmm0,(%r14)
add    $0x40,%r14
add    $0xfffffffffffffff0,%r13
add    $0xfffffffffffffffe,%r8
jne    1580 <spiralOrder+0x470>
neg    %r13
mov    %rsi,%r14
mov    0xc(%rsp),%r15d
mov    0x4c(%rsp),%ebp
mov    0x68(%rsp),%rbx
jmp    15ed <spiralOrder+0x4dd>
xor    %r13d,%r13d
test   $0x1,%dl
mov    0x18(%rsp),%rsi
je     1624 <spiralOrder+0x514>
lea    (%rdi,%r13,1),%rdx
not    %r13
add    %r11,%r13
movdqu -0x1c(%r9,%r13,4),%xmm0
movdqu -0xc(%r9,%r13,4),%xmm1
pshufd $0x1b,%xmm1,%xmm1
pshufd $0x1b,%xmm0,%xmm0
movdqu %xmm1,(%rax,%rdx,4)
movdqu %xmm0,0x10(%rax,%rdx,4)
add    %rcx,%rdi
sub    %rcx,%r11
cmp    %rcx,%rbx
mov    0x38(%rsp),%r13
mov    0x20(%rsp),%rbx
je     16f2 <spiralOrder+0x5e2>
nopl   (%rax)
mov    %ebx,%edx
sub    %ecx,%edx
sub    %ecx,%r10d
test   $0x3,%dl
je     16ac <spiralOrder+0x59c>
mov    %r13,0x38(%rsp)
mov    %ebp,%r13d
lea    (%rax,%rdi,4),%rdx
lea    (%r9,%r11,4),%r8
add    $0xfffffffffffffffc,%r8
mov    0x14(%rsp),%esi
sub    %cl,%sil
movzbl %sil,%esi
and    $0x3,%esi
neg    %esi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r8,%rbp,4),%ebx
mov    %ebx,(%rdx)
add    $0x4,%rdx
add    $0xffffffffffffffff,%rbp
cmp    %ebp,%esi
jne    1680 <spiralOrder+0x570>
sub    %rbp,%rdi
add    %rbp,%r11
sub    %ebp,%ecx
mov    0x20(%rsp),%rbx
mov    %r13d,%ebp
mov    0x38(%rsp),%r13
mov    0x18(%rsp),%rsi
cmp    $0x3,%r10d
jb     16f2 <spiralOrder+0x5e2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x4(%r9,%r11,4),%edx
mov    %edx,(%rax,%rdi,4)
mov    -0x8(%r9,%r11,4),%edx
mov    %edx,0x4(%rax,%rdi,4)
mov    -0xc(%r9,%r11,4),%edx
mov    %edx,0x8(%rax,%rdi,4)
mov    -0x10(%r9,%r11,4),%edx
add    $0xfffffffffffffffc,%r11
mov    %edx,0xc(%rax,%rdi,4)
add    $0x4,%rdi
add    $0x4,%ecx
cmp    %ecx,%ebx
jne    16c0 <spiralOrder+0x5b0>
cmp    $0x3,%r13d
jl     1789 <spiralOrder+0x679>
mov    0x34(%rsp),%edx
sub    %ebp,%edx
neg    %ebp
movslq %r11d,%rcx
movslq %esi,%r9
movslq %edi,%r10
add    0x50(%rsp),%ebp
jne    1720 <spiralOrder+0x610>
mov    0x10(%rsp),%ebp
jmp    1756 <spiralOrder+0x646>
nopl   0x0(%rax)
mov    0x10(%rsp),%ebp
mov    %ebp,%edi
and    $0xfffffffe,%edi
nopl   0x0(%rax)
mov    -0x8(%r12,%r9,8),%rsi
mov    (%rsi,%rcx,4),%esi
mov    %esi,(%rax,%r10,4)
mov    -0x10(%r12,%r9,8),%rsi
add    $0xfffffffffffffffe,%r9
mov    (%rsi,%rcx,4),%esi
mov    %esi,0x4(%rax,%r10,4)
add    $0x2,%r10
add    $0xfffffffe,%edi
jne    1730 <spiralOrder+0x620>
test   $0x1,%dl
je     11a0 <spiralOrder+0x90>
mov    -0x8(%r12,%r9,8),%rdx
add    $0xffffffffffffffff,%r9
mov    (%rdx,%rcx,4),%ecx
mov    %ecx,(%rax,%r10,4)
add    $0x1,%r10
jmp    11a0 <spiralOrder+0x90>
xor    %edx,%edx
test   $0x1,%bpl
jne    12da <spiralOrder+0x1ca>
jmp    12fa <spiralOrder+0x1ea>
add    $0x78,%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
store i32** %0, i32*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%12 = load i32, i32* %5
%13 = sext i32 %12 to i64
%14 = mul i64 4, %13
%15 = load i32, i32* %6
%16 = sext i32 %15 to i64
%17 = mul i64 %14, %16
%18 = trunc i64 %17 to i32
%19 = call i64 @malloc(i32 %18)
%20 = inttoptr i64 %19 to i32*
store i32* %20, i32** %7
store i32 0, i32* %9
store i32 0, i32* %10
store i32 -1, i32* %11
br label %21
21: ; preds = %3, %137
store i32 0, i32* %8
br label %22
22: ; preds = %42, %21
%23 = load i32, i32* %8
%24 = load i32, i32* %6
%25 = icmp slt i32 %23, %24
br i1 %25, label %26, label %45
26: ; preds = %22
%27 = load i32**, i32*** %4
%28 = load i32, i32* %10
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i32*, i32** %27, i64 %29
%31 = load i32*, i32** %30
%32 = load i32, i32* %11
%33 = add nsw i32 %32, 1
store i32 %33, i32* %11
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds i32, i32* %31, i64 %34
%36 = load i32, i32* %35
%37 = load i32*, i32** %7
%38 = load i32, i32* %9
%39 = add nsw i32 %38, 1
store i32 %39, i32* %9
%40 = sext i32 %38 to i64
%41 = getelementptr inbounds i32, i32* %37, i64 %40
store i32 %36, i32* %41
br label %42
42: ; preds = %26
%43 = load i32, i32* %8
%44 = add nsw i32 %43, 1
store i32 %44, i32* %8
br label %22
45: ; preds = %22
%46 = load i32, i32* %5
%47 = add nsw i32 %46, -1
store i32 %47, i32* %5
%48 = icmp sle i32 %47, 0
br i1 %48, label %49, label %50
49: ; preds = %45
br label %138
50: ; preds = %45
store i32 0, i32* %8
br label %51
51: ; preds = %71, %50
%52 = load i32, i32* %8
%53 = load i32, i32* %5
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %74
55: ; preds = %51
%56 = load i32**, i32*** %4
%57 = load i32, i32* %10
%58 = add nsw i32 %57, 1
store i32 %58, i32* %10
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i32*, i32** %56, i64 %59
%61 = load i32*, i32** %60
%62 = load i32, i32* %11
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %61, i64 %63
%65 = load i32, i32* %64
%66 = load i32*, i32** %7
%67 = load i32, i32* %9
%68 = add nsw i32 %67, 1
store i32 %68, i32* %9
%69 = sext i32 %67 to i64
%70 = getelementptr inbounds i32, i32* %66, i64 %69
store i32 %65, i32* %70
br label %71
71: ; preds = %55
%72 = load i32, i32* %8
%73 = add nsw i32 %72, 1
store i32 %73, i32* %8
br label %51
74: ; preds = %51
%75 = load i32, i32* %6
%76 = add nsw i32 %75, -1
store i32 %76, i32* %6
%77 = icmp sle i32 %76, 0
br i1 %77, label %78, label %79
78: ; preds = %74
br label %138
79: ; preds = %74
store i32 0, i32* %8
br label %80
80: ; preds = %100, %79
%81 = load i32, i32* %8
%82 = load i32, i32* %6
%83 = icmp slt i32 %81, %82
br i1 %83, label %84, label %103
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* %11
%91 = add nsw i32 %90, -1
store i32 %91, i32* %11
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i32, i32* %89, i64 %92
%94 = load i32, i32* %93
%95 = load i32*, i32** %7
%96 = load i32, i32* %9
%97 = add nsw i32 %96, 1
store i32 %97, i32* %9
%98 = sext i32 %96 to i64
%99 = getelementptr inbounds i32, i32* %95, i64 %98
store i32 %94, i32* %99
br label %100
100: ; preds = %84
%101 = load i32, i32* %8
%102 = add nsw i32 %101, 1
store i32 %102, i32* %8
br label %80
103: ; preds = %80
%104 = load i32, i32* %5
%105 = add nsw i32 %104, -1
store i32 %105, i32* %5
%106 = icmp sle i32 %105, 0
br i1 %106, label %107, label %108
107: ; preds = %103
br label %138
108: ; preds = %103
store i32 0, i32* %8
br label %109
109: ; preds = %129, %108
%110 = load i32, i32* %8
%111 = load i32, i32* %5
%112 = icmp slt i32 %110, %111
br i1 %112, label %113, label %132
113: ; preds = %109
%114 = load i32**, i32*** %4
%115 = load i32, i32* %10
%116 = add nsw i32 %115, -1
store i32 %116, i32* %10
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i32*, i32** %114, i64 %117
%119 = load i32*, i32** %118
%120 = load i32, i32* %11
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %119, i64 %121
%123 = load i32, i32* %122
%124 = load i32*, i32** %7
%125 = load i32, i32* %9
%126 = add nsw i32 %125, 1
store i32 %126, i32* %9
%127 = sext i32 %125 to i64
%128 = getelementptr inbounds i32, i32* %124, i64 %127
store i32 %123, i32* %128
br label %129
129: ; preds = %113
%130 = load i32, i32* %8
%131 = add nsw i32 %130, 1
store i32 %131, i32* %8
br label %109
132: ; preds = %109
%133 = load i32, i32* %6
%134 = add nsw i32 %133, -1
store i32 %134, i32* %6
%135 = icmp sle i32 %134, 0
br i1 %135, label %136, label %137
136: ; preds = %132
br label %138
137: ; preds = %132
br label %21
138: ; preds = %136, %107, %78, %49
%139 = load i32*, i32** %7
ret i32* %139
}

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