#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 *sortedSquares(int *A, int ASize, int *returnSize) {
  *returnSize = ASize;
  int *returnA = (int *)malloc(sizeof(int) * ASize);
  int j = 0;
  int type = A[0] < 0 ? 0 : 2;
  if (type == 0) {
    for (int i = 0; i < ASize; i++) {
      if (A[i] >= 0) {
        type = 1;
        j = i;
        break;
      }
    }
  }
  if (type == 0) {
    for (int i = 0; i < ASize; i++) {
      returnA[i] = A[ASize - 1 - i] * A[ASize - 1 - i];
    }
  } else if (type == 2) {
    for (int i = 0; i < ASize; i++) {
      returnA[i] = A[i] * A[i];
    }
  } else {
    int l = j - 1, r = j;
    int i = 0, k = 0;
    while (l >= 0 && r < ASize) {
      if (A[l] + A[r] >= 0) {
        k = A[l--];
      } else {
        k = A[r++];
      }
      returnA[i++] = k * k;
    }
    while (l >= 0) {
      k = A[l--];
      returnA[i++] = k * k;
    }
    while (r < ASize) {
      k = A[r++];
      returnA[i++] = k * k;
    }
  }
  return returnA;
}


x86 assembly (clang, -O0):
<sortedSquares>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%edx
mov    $0x2,%eax
xor    %ecx,%ecx
cmp    $0x0,%edx
cmovl  %ecx,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    11b5 <sortedSquares+0xa5>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b0 <sortedSquares+0xa0>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     119d <sortedSquares+0x8d>
movl   $0x1,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    11b0 <sortedSquares+0xa0>
jmp    11a2 <sortedSquares+0x92>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116d <sortedSquares+0x5d>
jmp    11b5 <sortedSquares+0xa5>
cmpl   $0x0,-0x28(%rbp)
jne    1217 <sortedSquares+0x107>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1212 <sortedSquares+0x102>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
imul   (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c6 <sortedSquares+0xb6>
jmp    13c2 <sortedSquares+0x2b2>
cmpl   $0x2,-0x28(%rbp)
jne    1269 <sortedSquares+0x159>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1264 <sortedSquares+0x154>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1228 <sortedSquares+0x118>
jmp    13bd <sortedSquares+0x2ad>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x38(%rbp)
mov    %al,-0x45(%rbp)
jl     12a1 <sortedSquares+0x191>
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
setl   %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    12b1 <sortedSquares+0x1a1>
jmp    1326 <sortedSquares+0x216>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
cmp    $0x0,%eax
jl     12ed <sortedSquares+0x1dd>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
jmp    1305 <sortedSquares+0x1f5>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%edx
imul   -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1286 <sortedSquares+0x176>
jmp    132b <sortedSquares+0x21b>
cmpl   $0x0,-0x38(%rbp)
jl     136e <sortedSquares+0x25e>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%edx
imul   -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    132b <sortedSquares+0x21b>
jmp    1373 <sortedSquares+0x263>
mov    -0x3c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13b8 <sortedSquares+0x2a8>
mov    -0x8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x3c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%edx
imul   -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1373 <sortedSquares+0x263>
jmp    13bd <sortedSquares+0x2ad>
jmp    13c2 <sortedSquares+0x2b2>
mov    -0x20(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sortedSquares>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%r12d
mov    %rdi,%r14
mov    %esi,(%rdx)
lea    0x0(,%r12,4),%edi
call   1030 <malloc@plt>
mov    (%r14),%ecx
mov    %r12d,%r15d
test   %ecx,%ecx
jns    12f2 <sortedSquares+0x1e2>
test   %r12d,%r12d
jle    12f2 <sortedSquares+0x1e2>
xor    %edi,%edi
mov    $0x1,%edx
xchg   %ax,%ax
cmp    %rdx,%r15
je     12f2 <sortedSquares+0x1e2>
add    $0xffffffff,%edi
cmpl   $0x0,(%r14,%rdx,4)
lea    0x1(%rdx),%rdx
js     1150 <sortedSquares+0x40>
xor    %esi,%esi
mov    %edi,%r8d
neg    %r8d
not    %edi
jae    11c0 <sortedSquares+0xb0>
cmp    %r12d,%r8d
jge    11c0 <sortedSquares+0xb0>
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
mov    %edi,%r9d
mov    %r8d,%ebx
mov    %edi,%edx
mov    (%r14,%rdx,4),%ebp
mov    %r8d,%edx
mov    (%r14,%rdx,4),%edx
lea    (%rdx,%rbp,1),%ecx
mov    %ecx,%edi
sar    $0x1f,%edi
mov    %ecx,%r8d
shr    $0x1f,%r8d
add    %ebx,%r8d
test   %ecx,%ecx
not    %edi
cmovns %ebp,%edx
imul   %edx,%edx
mov    %edx,(%rax,%rsi,4)
add    $0x1,%rsi
add    %r9d,%edi
js     11c0 <sortedSquares+0xb0>
cmp    %r12d,%r8d
jl     1180 <sortedSquares+0x70>
test   %edi,%edi
js     16d9 <sortedSquares+0x5c9>
mov    %esi,%esi
mov    %edi,%r10d
cmp    $0x7,%edi
jb     1660 <sortedSquares+0x550>
lea    (%rax,%rsi,4),%rcx
lea    (%r14,%r10,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rcx
jae    11fc <sortedSquares+0xec>
lea    (%r10,%rsi,1),%rcx
lea    (%rax,%rcx,4),%rcx
add    $0x4,%rcx
cmp    %r14,%rcx
ja     1660 <sortedSquares+0x550>
lea    0x1(%r10),%r9
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r12,%rbx
test   %rcx,%rcx
je     15ee <sortedSquares+0x4de>
mov    %r11,%r12
and    $0xfffffffffffffffe,%r12
lea    (%r14,%r10,4),%rcx
add    $0xfffffffffffffff4,%rcx
lea    (%rax,%rsi,4),%r13
add    $0x30,%r13
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rcx),%xmm0
movdqu (%rcx),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm2,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe2,%xmm1,%xmm1
pshufd $0xe2,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm1,%xmm1
pmuludq %xmm0,%xmm0
pshufd $0xe2,%xmm0,%xmm0
pshufd $0xe2,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm2,-0x30(%r13,%rdi,4)
movdqu %xmm1,-0x20(%r13,%rdi,4)
movdqu -0x30(%rcx),%xmm0
movdqu -0x20(%rcx),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm2,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe2,%xmm1,%xmm1
pshufd $0xe2,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm1,%xmm1
pmuludq %xmm0,%xmm0
pshufd $0xe2,%xmm0,%xmm0
pshufd $0xe2,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm2,-0x10(%r13,%rdi,4)
movdqu %xmm1,0x0(%r13,%rdi,4)
add    $0x10,%rdi
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffe,%r12
jne    1240 <sortedSquares+0x130>
jmp    15f0 <sortedSquares+0x4e0>
test   %ecx,%ecx
js     1421 <sortedSquares+0x311>
test   %r12d,%r12d
jle    1986 <sortedSquares+0x876>
imul   %ecx,%ecx
mov    %ecx,(%rax)
cmp    $0x1,%r12d
je     1986 <sortedSquares+0x876>
lea    -0x1(%r15),%rsi
mov    $0x1,%edx
cmp    $0x8,%rsi
jb     188b <sortedSquares+0x77b>
lea    0x4(%rax),%rcx
lea    (%r14,%r15,4),%rdi
cmp    %rdi,%rcx
jae    1343 <sortedSquares+0x233>
lea    (%rax,%r15,4),%rcx
lea    0x4(%r14),%rdi
cmp    %rcx,%rdi
jb     188b <sortedSquares+0x77b>
mov    %rsi,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1825 <sortedSquares+0x715>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
mov    $0x1,%edi
xchg   %ax,%ax
movdqu (%r14,%rdi,4),%xmm0
movdqu 0x10(%r14,%rdi,4),%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm1,0x10(%rax,%rdi,4)
movdqu 0x20(%r14,%rdi,4),%xmm0
movdqu 0x30(%r14,%rdi,4),%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqu %xmm0,0x20(%rax,%rdi,4)
movdqu %xmm1,0x30(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1370 <sortedSquares+0x260>
jmp    182a <sortedSquares+0x71a>
test   %r12d,%r12d
jle    1986 <sortedSquares+0x876>
cmp    $0x8,%r12d
jae    14af <sortedSquares+0x39f>
xor    %r9d,%r9d
mov    %r9,%rcx
not    %rcx
test   $0x1,%r15b
je     1459 <sortedSquares+0x349>
mov    %r9d,%edx
not    %edx
add    %r12d,%edx
movslq %edx,%rdx
mov    (%r14,%rdx,4),%edx
imul   %edx,%edx
mov    %edx,(%rax,%r9,4)
or     $0x1,%r9
add    %r15,%rcx
je     1986 <sortedSquares+0x876>
sub    %r9,%r15
mov    %r9d,%ecx
not    %ecx
add    %r12d,%ecx
lea    (%rax,%r9,4),%rdx
add    $0x4,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rcx
mov    (%r14,%rcx,4),%edi
imul   %edi,%edi
mov    %edi,-0x4(%rdx,%rsi,4)
lea    -0x1(%rcx),%edi
movslq %edi,%rdi
mov    (%r14,%rdi,4),%edi
imul   %edi,%edi
mov    %edi,(%rdx,%rsi,4)
add    $0x2,%rsi
add    $0xfffffffe,%ecx
cmp    %rsi,%r15
jne    1480 <sortedSquares+0x370>
jmp    1986 <sortedSquares+0x876>
lea    -0x1(%r15),%rdx
lea    -0x1(%r12),%ecx
mov    %ecx,%esi
sub    %edx,%esi
xor    %r9d,%r9d
cmp    %ecx,%esi
jg     1433 <sortedSquares+0x323>
shr    $0x20,%rdx
jne    1433 <sortedSquares+0x323>
movslq %ecx,%rcx
lea    (%r14,%rcx,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rax
jae    14f9 <sortedSquares+0x3e9>
lea    (%rax,%r15,4),%rdx
add    $0x1,%rcx
sub    %r15,%rcx
lea    (%r14,%rcx,4),%rcx
cmp    %rdx,%rcx
jb     1430 <sortedSquares+0x320>
mov    %r15d,%r9d
and    $0xfffffff8,%r9d
lea    -0x8(%r9),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rcx,%rcx
je     1995 <sortedSquares+0x885>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    -0x9(%r12),%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
lea    0x8(%rdx),%ecx
movslq %ecx,%rcx
movdqu -0x1c(%r14,%rcx,4),%xmm0
movdqu -0xc(%r14,%rcx,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm2,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe2,%xmm1,%xmm1
pshufd $0xe2,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm1,%xmm1
pmuludq %xmm0,%xmm0
pshufd $0xe2,%xmm0,%xmm0
pshufd $0xe2,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm2,(%rax,%rsi,4)
movdqu %xmm1,0x10(%rax,%rsi,4)
movslq %edx,%rdx
movdqu -0x1c(%r14,%rdx,4),%xmm0
movdqu -0xc(%r14,%rdx,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm2,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe2,%xmm1,%xmm1
pshufd $0xe2,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm1,%xmm1
pmuludq %xmm0,%xmm0
pshufd $0xe2,%xmm0,%xmm0
pshufd $0xe2,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm2,0x20(%rax,%rsi,4)
movdqu %xmm1,0x30(%rax,%rsi,4)
add    $0x10,%rsi
add    $0xfffffff0,%edx
add    $0xfffffffffffffffe,%rdi
jne    1530 <sortedSquares+0x420>
jmp    1997 <sortedSquares+0x887>
xor    %edi,%edi
test   $0x1,%r11b
je     164e <sortedSquares+0x53e>
mov    %r10,%rcx
sub    %rdi,%rcx
add    %rsi,%rdi
movdqu -0x1c(%r14,%rcx,4),%xmm0
movdqu -0xc(%r14,%rcx,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm2,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe2,%xmm1,%xmm1
pshufd $0xe2,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm1,%xmm1
pmuludq %xmm0,%xmm0
pshufd $0xe2,%xmm0,%xmm0
pshufd $0xe2,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm2,(%rax,%rdi,4)
movdqu %xmm1,0x10(%rax,%rdi,4)
add    %rdx,%rsi
cmp    %rdx,%r9
mov    %rbx,%r12
je     16d9 <sortedSquares+0x5c9>
sub    %rdx,%r10
lea    0x1(%r10),%edi
mov    %r10,%rcx
and    $0x3,%rdi
je     1688 <sortedSquares+0x578>
nopl   (%rax)
mov    (%r14,%rcx,4),%ebx
add    $0xffffffffffffffff,%rcx
imul   %ebx,%ebx
mov    %ebx,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1670 <sortedSquares+0x560>
cmp    $0x3,%r10
jb     16d9 <sortedSquares+0x5c9>
add    $0x1,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x4(%r14,%rcx,4),%edx
imul   %edx,%edx
mov    %edx,(%rax,%rsi,4)
mov    -0x8(%r14,%rcx,4),%edx
imul   %edx,%edx
mov    %edx,0x4(%rax,%rsi,4)
mov    -0xc(%r14,%rcx,4),%edx
imul   %edx,%edx
mov    %edx,0x8(%rax,%rsi,4)
mov    -0x10(%r14,%rcx,4),%edx
imul   %edx,%edx
mov    %edx,0xc(%rax,%rsi,4)
add    $0x4,%rsi
add    $0xfffffffffffffffc,%rcx
jne    16a0 <sortedSquares+0x590>
cmp    %r15d,%r8d
jge    1986 <sortedSquares+0x876>
mov    %esi,%r10d
mov    %r8d,%ecx
not    %r8d
add    %r12d,%r8d
cmp    $0x7,%r8d
jb     1964 <sortedSquares+0x854>
lea    (%rax,%r10,4),%rdx
lea    (%rcx,%r8,1),%rsi
lea    (%r14,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jae    1726 <sortedSquares+0x616>
lea    (%r10,%r8,1),%rdx
lea    (%rax,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%r14,%rcx,4),%rsi
cmp    %rdx,%rsi
jb     1964 <sortedSquares+0x854>
add    $0x1,%r8
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     18fc <sortedSquares+0x7ec>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r14,%rcx,4),%r11
add    $0x30,%r11
lea    (%rax,%r10,4),%r15
add    $0x30,%r15
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu -0x30(%r11,%rdi,4),%xmm0
movdqu -0x20(%r11,%rdi,4),%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqu %xmm0,-0x30(%r15,%rdi,4)
movdqu %xmm1,-0x20(%r15,%rdi,4)
movdqu -0x10(%r11,%rdi,4),%xmm0
movdqu (%r11,%rdi,4),%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqu %xmm0,-0x10(%r15,%rdi,4)
movdqu %xmm1,(%r15,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1770 <sortedSquares+0x660>
jmp    18fe <sortedSquares+0x7ee>
mov    $0x1,%edi
test   $0x1,%r8b
je     187e <sortedSquares+0x76e>
movdqu (%r14,%rdi,4),%xmm0
movdqu 0x10(%r14,%rdi,4),%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm1,0x10(%rax,%rdi,4)
cmp    %rdx,%rsi
je     1986 <sortedSquares+0x876>
or     $0x1,%rdx
mov    %r15d,%esi
sub    %edx,%esi
mov    %rdx,%rcx
not    %rcx
add    %r15,%rcx
and    $0x3,%rsi
je     18b4 <sortedSquares+0x7a4>
nop
mov    (%r14,%rdx,4),%edi
imul   %edi,%edi
mov    %edi,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    18a0 <sortedSquares+0x790>
cmp    $0x3,%rcx
jb     1986 <sortedSquares+0x876>
xchg   %ax,%ax
mov    (%r14,%rdx,4),%ecx
imul   %ecx,%ecx
mov    %ecx,(%rax,%rdx,4)
mov    0x4(%r14,%rdx,4),%ecx
imul   %ecx,%ecx
mov    %ecx,0x4(%rax,%rdx,4)
mov    0x8(%r14,%rdx,4),%ecx
imul   %ecx,%ecx
mov    %ecx,0x8(%rax,%rdx,4)
mov    0xc(%r14,%rdx,4),%ecx
imul   %ecx,%ecx
mov    %ecx,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    18c0 <sortedSquares+0x7b0>
jmp    1986 <sortedSquares+0x876>
xor    %edi,%edi
test   $0x1,%r9b
je     1959 <sortedSquares+0x849>
lea    (%rdi,%rcx,1),%rsi
add    %r10,%rdi
movdqu (%r14,%rsi,4),%xmm0
movdqu 0x10(%r14,%rsi,4),%xmm1
pshufd $0xf5,%xmm0,%xmm2
pmuludq %xmm0,%xmm0
pshufd $0xe8,%xmm0,%xmm0
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm0
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe8,%xmm1,%xmm1
pmuludq %xmm2,%xmm2
pshufd $0xe8,%xmm2,%xmm2
punpckldq %xmm2,%xmm1
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm1,0x10(%rax,%rdi,4)
cmp    %rdx,%r8
je     1986 <sortedSquares+0x876>
add    %rdx,%rcx
add    %rdx,%r10
lea    (%rax,%r10,4),%rdx
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rcx,4),%esi
add    $0x1,%rcx
imul   %esi,%esi
mov    %esi,(%rdx)
add    $0x4,%rdx
cmp    %r12d,%ecx
jl     1970 <sortedSquares+0x860>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%r8b
je     19f6 <sortedSquares+0x8e6>
mov    %esi,%ecx
not    %ecx
add    %r12d,%ecx
movslq %ecx,%rcx
movdqu -0x1c(%r14,%rcx,4),%xmm0
movdqu -0xc(%r14,%rcx,4),%xmm1
pshufd $0xf5,%xmm1,%xmm2
pmuludq %xmm2,%xmm2
pmuludq %xmm1,%xmm1
pshufd $0xe2,%xmm1,%xmm1
pshufd $0xe2,%xmm2,%xmm2
punpckldq %xmm1,%xmm2
pshufd $0xf5,%xmm0,%xmm1
pmuludq %xmm1,%xmm1
pmuludq %xmm0,%xmm0
pshufd $0xe2,%xmm0,%xmm0
pshufd $0xe2,%xmm1,%xmm1
punpckldq %xmm0,%xmm1
movdqu %xmm2,(%rax,%rsi,4)
movdqu %xmm1,0x10(%rax,%rsi,4)
cmp    %r15,%r9
jne    1433 <sortedSquares+0x323>
jmp    1986 <sortedSquares+0x876>

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

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