#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 */
typedef size_t u_char;
typedef int int32_t;

/* Variables and functions */
int /*<<< orphan*/ split(int *, int *, int, int, int);
void qsufsort(int32_t *I, int32_t *V, u_char *old, int32_t oldsize) {
  int32_t buckets[256];
  int32_t i, h, len;
  for (i = 0; i < 256; i++)
    buckets[i] = 0;
  for (i = 0; i < oldsize; i++)
    buckets[old[i]]++;
  for (i = 1; i < 256; i++)
    buckets[i] += buckets[i - 1];
  for (i = 255; i > 0; i--)
    buckets[i] = buckets[i - 1];
  buckets[0] = 0;
  for (i = 0; i < oldsize; i++)
    I[++buckets[old[i]]] = i;
  I[0] = oldsize;
  for (i = 0; i < oldsize; i++)
    V[i] = buckets[old[i]];
  V[oldsize] = 0;
  for (i = 1; i < 256; i++)
    if (buckets[i] == buckets[i - 1] + 1)
      I[buckets[i]] = -1;
  I[0] = -1;
  for (h = 1; I[0] != -(oldsize + 1); h += h) {
    len = 0;
    for (i = 0; i < oldsize + 1;) {
      if (I[i] < 0) {
        len -= I[i];
        i -= I[i];
      } else {
        if (len)
          I[i - len] = -len;
        len = V[I[i]] + 1 - i;
        split(I, V, i, len, h);
        i += len;
        len = 0;
      };
    };
    if (len)
      I[i - len] = -len;
  };
  for (i = 0; i < oldsize + 1; i++)
    I[V[i]] = i;
}


x86 assembly (clang, -O0):
<qsufsort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x430,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x424(%rbp)
cmpl   $0x100,-0x424(%rbp)
jge    116a <qsufsort+0x5a>
movslq -0x424(%rbp),%rax
movl   $0x0,-0x420(%rbp,%rax,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    1134 <qsufsort+0x24>
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11b7 <qsufsort+0xa7>
mov    -0x18(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x420(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x420(%rbp,%rax,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    1174 <qsufsort+0x64>
movl   $0x1,-0x424(%rbp)
cmpl   $0x100,-0x424(%rbp)
jge    120c <qsufsort+0xfc>
mov    -0x424(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x420(%rbp,%rax,4),%ecx
movslq -0x424(%rbp),%rax
add    -0x420(%rbp,%rax,4),%ecx
mov    %ecx,-0x420(%rbp,%rax,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    11c1 <qsufsort+0xb1>
movl   $0xff,-0x424(%rbp)
cmpl   $0x0,-0x424(%rbp)
jle    1257 <qsufsort+0x147>
mov    -0x424(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x420(%rbp,%rax,4),%ecx
movslq -0x424(%rbp),%rax
mov    %ecx,-0x420(%rbp,%rax,4)
mov    -0x424(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x424(%rbp)
jmp    1216 <qsufsort+0x106>
movl   $0x0,-0x420(%rbp)
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12be <qsufsort+0x1ae>
mov    -0x424(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x424(%rbp),%rsi
mov    (%rcx,%rsi,8),%rsi
mov    -0x420(%rbp,%rsi,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x420(%rbp,%rsi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    126b <qsufsort+0x15b>
mov    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1318 <qsufsort+0x208>
mov    -0x18(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x420(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    12d1 <qsufsort+0x1c1>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
movl   $0x1,-0x424(%rbp)
cmpl   $0x100,-0x424(%rbp)
jge    13a0 <qsufsort+0x290>
movslq -0x424(%rbp),%rax
mov    -0x420(%rbp,%rax,4),%eax
mov    -0x424(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    -0x420(%rbp,%rcx,4),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1387 <qsufsort+0x277>
mov    -0x8(%rbp),%rax
movslq -0x424(%rbp),%rcx
movslq -0x420(%rbp,%rcx,4),%rcx
ff
movl   $0xffffffff,(%rax,%rcx,4)
jmp    138c <qsufsort+0x27c>
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    1331 <qsufsort+0x221>
mov    -0x8(%rbp),%rax
movl   $0xffffffff,(%rax)
movl   $0x1,-0x428(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
xor    %ecx,%ecx
sub    %edx,%ecx
cmp    %ecx,%eax
je     151e <qsufsort+0x40e>
movl   $0x0,-0x42c(%rbp)
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    14d7 <qsufsort+0x3c7>
mov    -0x8(%rbp),%rax
movslq -0x424(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jge    1446 <qsufsort+0x336>
mov    -0x8(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x42c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x42c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    -0x424(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x424(%rbp)
jmp    14d2 <qsufsort+0x3c2>
cmpl   $0x0,-0x42c(%rbp)
je     1471 <qsufsort+0x361>
xor    %edx,%edx
sub    -0x42c(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x424(%rbp),%ecx
sub    -0x42c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x424(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
sub    -0x424(%rbp),%eax
mov    %eax,-0x42c(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x424(%rbp),%edx
mov    -0x42c(%rbp),%ecx
mov    -0x428(%rbp),%r8d
call   1030 <split@plt>
mov    -0x42c(%rbp),%eax
add    -0x424(%rbp),%eax
mov    %eax,-0x424(%rbp)
movl   $0x0,-0x42c(%rbp)
jmp    13e0 <qsufsort+0x2d0>
cmpl   $0x0,-0x42c(%rbp)
je     1502 <qsufsort+0x3f2>
xor    %edx,%edx
sub    -0x42c(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x424(%rbp),%ecx
sub    -0x42c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1507 <qsufsort+0x3f7>
mov    -0x428(%rbp),%eax
add    -0x428(%rbp),%eax
mov    %eax,-0x428(%rbp)
jmp    13b4 <qsufsort+0x2a4>
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    156c <qsufsort+0x45c>
mov    -0x424(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x424(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    1528 <qsufsort+0x418>
add    $0x430,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qsufsort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x418,%rsp
mov    %ecx,%r12d
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
lea    0x10(%rsp),%rdi
xor    %ebp,%ebp
mov    $0x400,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r12d,%eax
mov    %rax,0x8(%rsp)
test   %r12d,%r12d
jle    11e6 <qsufsort+0xb6>
mov    0x8(%rsp),%rdx
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    1185 <qsufsort+0x55>
xor    %ecx,%ecx
jmp    11c0 <qsufsort+0x90>
and    $0xfffffffc,%edx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rcx,8),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
mov    0x8(%r15,%rcx,8),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
mov    0x10(%r15,%rcx,8),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
mov    0x18(%r15,%rcx,8),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1190 <qsufsort+0x60>
test   %rax,%rax
je     11e2 <qsufsort+0xb2>
lea    (%r15,%rcx,8),%rcx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rdx,8),%rsi
addl   $0x1,0x10(%rsp,%rsi,4)
add    $0x1,%rdx
cmp    %rdx,%rax
jne    11d0 <qsufsort+0xa0>
mov    0x10(%rsp),%ebp
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
add    0x14(%rsp,%rax,4),%ebp
mov    %ebp,0x14(%rsp,%rax,4)
add    0x18(%rsp,%rax,4),%ebp
mov    %ebp,0x18(%rsp,%rax,4)
add    0x1c(%rsp,%rax,4),%ebp
mov    %ebp,0x1c(%rsp,%rax,4)
add    0x20(%rsp,%rax,4),%ebp
mov    %ebp,0x20(%rsp,%rax,4)
add    0x24(%rsp,%rax,4),%ebp
mov    %ebp,0x24(%rsp,%rax,4)
add    $0x5,%rax
cmp    $0xff,%rax
jne    11f0 <qsufsort+0xc0>
lea    0x14(%rsp),%rdi
lea    0x10(%rsp),%rsi
mov    $0x3fc,%edx
call   1050 <memmove@plt>
movl   $0x0,0x10(%rsp)
test   %r12d,%r12d
mov    0x8(%rsp),%rbp
jle    1344 <qsufsort+0x214>
mov    %rbp,%rax
add    $0xffffffffffffffff,%rax
je     12cf <qsufsort+0x19f>
mov    %ebp,%edx
and    $0xfffffffe,%edx
xor    %ecx,%ecx
xchg   %ax,%ax
mov    (%r15,%rcx,8),%rsi
movslq 0x10(%rsp,%rsi,4),%rdi
lea    0x1(%rdi),%rbp
mov    %ebp,0x10(%rsp,%rsi,4)
mov    %ecx,0x4(%rbx,%rdi,4)
mov    0x8(%r15,%rcx,8),%rsi
movslq 0x10(%rsp,%rsi,4),%rdi
lea    0x1(%rdi),%rbp
mov    %ebp,0x10(%rsp,%rsi,4)
lea    0x1(%rcx),%esi
mov    %esi,0x4(%rbx,%rdi,4)
add    $0x2,%rcx
cmp    %rdx,%rcx
jne    1260 <qsufsort+0x130>
mov    0x8(%rsp),%rbp
test   $0x1,%bpl
je     12b7 <qsufsort+0x187>
mov    (%r15,%rcx,8),%rdx
movslq 0x10(%rsp,%rdx,4),%rsi
lea    0x1(%rsi),%rdi
mov    %edi,0x10(%rsp,%rdx,4)
mov    %ecx,0x4(%rbx,%rsi,4)
test   %r12d,%r12d
jle    1344 <qsufsort+0x214>
mov    %ebp,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    12d9 <qsufsort+0x1a9>
xor    %eax,%eax
jmp    131f <qsufsort+0x1ef>
xor    %ecx,%ecx
test   $0x1,%bpl
jne    12a2 <qsufsort+0x172>
jmp    12b7 <qsufsort+0x187>
mov    %ebp,%edx
and    $0xfffffffc,%edx
xor    %eax,%eax
mov    (%r15,%rax,8),%rsi
mov    0x10(%rsp,%rsi,4),%esi
mov    %esi,(%r14,%rax,4)
mov    0x8(%r15,%rax,8),%rsi
mov    0x10(%rsp,%rsi,4),%esi
mov    %esi,0x4(%r14,%rax,4)
mov    0x10(%r15,%rax,8),%rsi
mov    0x10(%rsp,%rsi,4),%esi
mov    %esi,0x8(%r14,%rax,4)
mov    0x18(%r15,%rax,8),%rsi
mov    0x10(%rsp,%rsi,4),%esi
mov    %esi,0xc(%r14,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdx
jne    12e0 <qsufsort+0x1b0>
test   %rcx,%rcx
je     1344 <qsufsort+0x214>
lea    (%r14,%rax,4),%rdx
lea    (%r15,%rax,8),%rax
xor    %esi,%esi
xchg   %ax,%ax
mov    (%rax,%rsi,8),%rdi
mov    0x10(%rsp,%rdi,4),%edi
mov    %edi,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1330 <qsufsort+0x200>
movslq %r12d,%rax
movl   $0x0,(%r14,%rax,4)
movd   0x10(%rsp),%xmm0
pshufd $0x0,%xmm0,%xmm1
mov    $0x5,%eax
pcmpeqd %xmm0,%xmm0
jmp    1380 <qsufsort+0x250>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x8,%rax
cmp    $0xfd,%rax
je     148e <qsufsort+0x35e>
movups (%rsp,%rax,4),%xmm2
shufps $0x3,%xmm2,%xmm1
shufps $0x98,%xmm2,%xmm1
psubd  %xmm0,%xmm1
pcmpeqd %xmm2,%xmm1
movd   %xmm1,%ecx
test   $0x1,%cl
je     13ab <qsufsort+0x27b>
movd   %xmm2,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
pextrw $0x2,%xmm1,%ecx
test   $0x1,%cl
je     13c8 <qsufsort+0x298>
pshufd $0x55,%xmm2,%xmm3
movd   %xmm3,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
pextrw $0x4,%xmm1,%ecx
test   $0x1,%cl
je     13e5 <qsufsort+0x2b5>
pshufd $0xee,%xmm2,%xmm3
movd   %xmm3,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
pextrw $0x6,%xmm1,%ecx
test   $0x1,%cl
je     1402 <qsufsort+0x2d2>
pshufd $0xff,%xmm2,%xmm1
movd   %xmm1,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
movups 0x10(%rsp,%rax,4),%xmm1
shufps $0x3,%xmm1,%xmm2
shufps $0x98,%xmm1,%xmm2
psubd  %xmm0,%xmm2
pcmpeqd %xmm1,%xmm2
movd   %xmm2,%ecx
test   $0x1,%cl
je     142e <qsufsort+0x2fe>
movd   %xmm1,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
pextrw $0x2,%xmm2,%ecx
test   $0x1,%cl
je     144b <qsufsort+0x31b>
pshufd $0x55,%xmm1,%xmm3
movd   %xmm3,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
pextrw $0x4,%xmm2,%ecx
test   $0x1,%cl
je     1468 <qsufsort+0x338>
pshufd $0xee,%xmm1,%xmm3
movd   %xmm3,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
pextrw $0x6,%xmm2,%ecx
test   $0x1,%cl
je     1370 <qsufsort+0x240>
pshufd $0xff,%xmm1,%xmm2
movd   %xmm2,%ecx
movslq %ecx,%rcx
movl   $0xffffffff,(%rbx,%rcx,4)
jmp    1370 <qsufsort+0x240>
pshufd $0xff,%xmm1,%xmm0
movd   %xmm0,%ecx
movslq 0x3f4(%rsp),%rax
add    $0x1,%ecx
cmp    %ecx,%eax
jne    14ad <qsufsort+0x37d>
movl   $0xffffffff,(%rbx,%rax,4)
movslq 0x3f8(%rsp),%rcx
add    $0x1,%eax
cmp    %eax,%ecx
jne    14c3 <qsufsort+0x393>
movl   $0xffffffff,(%rbx,%rcx,4)
movslq 0x3fc(%rsp),%rax
add    $0x1,%ecx
cmp    %ecx,%eax
jne    14d9 <qsufsort+0x3a9>
movl   $0xffffffff,(%rbx,%rax,4)
movslq 0x400(%rsp),%rcx
add    $0x1,%eax
cmp    %eax,%ecx
jne    14ef <qsufsort+0x3bf>
movl   $0xffffffff,(%rbx,%rcx,4)
movslq 0x404(%rsp),%rax
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1505 <qsufsort+0x3d5>
movl   $0xffffffff,(%rbx,%rax,4)
movslq 0x408(%rsp),%rcx
add    $0x1,%eax
cmp    %eax,%ecx
jne    151b <qsufsort+0x3eb>
movl   $0xffffffff,(%rbx,%rcx,4)
movslq 0x40c(%rsp),%rax
add    $0x1,%ecx
cmp    %ecx,%eax
jne    1531 <qsufsort+0x401>
movl   $0xffffffff,(%rbx,%rax,4)
movl   $0xffffffff,(%rbx)
test   %r12d,%r12d
je     1601 <qsufsort+0x4d1>
mov    %r12d,%r15d
not    %r15d
mov    $0x1,%ebp
mov    $0xffffffff,%ecx
jmp    156d <qsufsort+0x43d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    %ebp,%ebp
mov    (%rbx),%ecx
cmp    %r15d,%ecx
je     15f7 <qsufsort+0x4c7>
test   %r12d,%r12d
js     1560 <qsufsort+0x430>
xor    %eax,%eax
xor    %edx,%edx
test   %ecx,%ecx
js     15c0 <qsufsort+0x490>
nopw   0x0(%rax,%rax,1)
test   %eax,%eax
je     1596 <qsufsort+0x466>
movslq %edx,%rcx
mov    %edx,%esi
sub    %eax,%esi
neg    %eax
movslq %esi,%rsi
mov    %eax,(%rbx,%rsi,4)
mov    (%rbx,%rcx,4),%ecx
movslq %ecx,%rax
mov    (%r14,%rax,4),%r13d
add    $0x1,%r13d
mov    %r13d,%ecx
sub    %edx,%ecx
mov    %rbx,%rdi
mov    %r14,%rsi
mov    %ebp,%r8d
call   1040 <split@plt>
xor    %eax,%eax
mov    %r13d,%edx
cmp    %r12d,%edx
jle    15c9 <qsufsort+0x499>
jmp    15e0 <qsufsort+0x4b0>
sub    %ecx,%eax
sub    %ecx,%edx
cmp    %r12d,%edx
jg     15e0 <qsufsort+0x4b0>
movslq %edx,%rcx
mov    (%rbx,%rcx,4),%ecx
test   %ecx,%ecx
jns    1580 <qsufsort+0x450>
jmp    15c0 <qsufsort+0x490>
cs nopw 0x0(%rax,%rax,1)
nop
test   %eax,%eax
je     1560 <qsufsort+0x430>
sub    %eax,%edx
neg    %eax
movslq %edx,%rcx
mov    %eax,(%rbx,%rcx,4)
jmp    1560 <qsufsort+0x430>
test   %r12d,%r12d
mov    0x8(%rsp),%rbp
js     1671 <qsufsort+0x541>
add    $0x1,%rbp
mov    %ebp,%eax
and    $0x3,%eax
cmp    $0x3,%r12d
jae    1614 <qsufsort+0x4e4>
xor    %ecx,%ecx
jmp    1651 <qsufsort+0x521>
and    $0xfffffffc,%ebp
xor    %ecx,%ecx
nopl   0x0(%rax)
movslq (%r14,%rcx,4),%rdx
mov    %ecx,(%rbx,%rdx,4)
movslq 0x4(%r14,%rcx,4),%rdx
lea    0x1(%rcx),%esi
mov    %esi,(%rbx,%rdx,4)
movslq 0x8(%r14,%rcx,4),%rdx
lea    0x2(%rcx),%esi
mov    %esi,(%rbx,%rdx,4)
movslq 0xc(%r14,%rcx,4),%rdx
lea    0x3(%rcx),%esi
mov    %esi,(%rbx,%rdx,4)
add    $0x4,%rcx
cmp    %rbp,%rcx
jne    1620 <qsufsort+0x4f0>
test   %rax,%rax
je     1671 <qsufsort+0x541>
cs nopw 0x0(%rax,%rax,1)
movslq (%r14,%rcx,4),%rdx
mov    %ecx,(%rbx,%rdx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1660 <qsufsort+0x530>
add    $0x418,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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