#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 */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ getBuckets64(long long *, long long *, long long, int);
int /*<<< orphan*/ getCounts64(void const *, long long *, long long, long long,
                               int);
void LMSsort1_64(const void *T, long long *SA, long long *C, long long *B,
                 long long n, long long k, int cs) {
  long long *b, i, j;
  long long c0, c1;
  if (C == B) {
    getCounts64(T, C, n, k, cs);
  }
  getBuckets64(C, B, k, 0);
  j = n - 1;
  b = SA + B[c1 = (cs == sizeof(long long) ? ((long long *)T)[(j)]
                                           : ((unsigned char *)T)[(j)])];
  --j;
  *b++ = ((cs == sizeof(long long) ? ((long long *)T)[(j)]
                                   : ((unsigned char *)T)[(j)]) < c1)
             ? ~j
             : j;
  for (i = 0; i < n; ++i) {
    if (0 < (j = SA[i])) {
      assert((cs == sizeof(long long) ? ((long long *)T)[(j)]
                                      : ((unsigned char *)T)[(j)]) >=
             (cs == sizeof(long long) ? ((long long *)T)[(j + 1)]
                                      : ((unsigned char *)T)[(j + 1)]));
      if ((c0 = (cs == sizeof(long long) ? ((long long *)T)[(j)]
                                         : ((unsigned char *)T)[(j)])) != c1) {
        B[c1] = b - SA;
        b = SA + B[c1 = c0];
      }
      assert(i < (b - SA));
      --j;
      *b++ = ((cs == sizeof(long long) ? ((long long *)T)[(j)]
                                       : ((unsigned char *)T)[(j)]) < c1)
                 ? ~j
                 : j;
      SA[i] = 0;
    } else if (j < 0) {
      SA[i] = ~j;
    }
  }
  if (C == B) {
    getCounts64(T, C, n, k, cs);
  }
  getBuckets64(C, B, k, 1);
  for (i = n - 1, b = SA + B[c1 = 0]; 0 <= i; --i) {
    if (0 < (j = SA[i])) {
      assert((cs == sizeof(long long) ? ((long long *)T)[(j)]
                                      : ((unsigned char *)T)[(j)]) <=
             (cs == sizeof(long long) ? ((long long *)T)[(j + 1)]
                                      : ((unsigned char *)T)[(j + 1)]));
      if ((c0 = (cs == sizeof(long long) ? ((long long *)T)[(j)]
                                         : ((unsigned char *)T)[(j)])) != c1) {
        B[c1] = b - SA;
        b = SA + B[c1 = c0];
      }
      assert((b - SA) <= i);
      --j;
      *--b = ((cs == sizeof(long long) ? ((long long *)T)[(j)]
                                       : ((unsigned char *)T)[(j)]) > c1)
                 ? ~(j + 1)
                 : j;
      SA[i] = 0;
    }
  }
}


x86 assembly (clang, -O0):
<LMSsort1_64>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    117d <LMSsort1_64+0x4d>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    0x10(%rbp),%r8d
call   1050 <getCounts64@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rdx
xor    %ecx,%ecx
call   1030 <getBuckets64@plt>
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x60(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    11cf <LMSsort1_64+0x9f>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x70(%rbp)
jmp    11df <LMSsort1_64+0xaf>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    -0x70(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
mov    (%rcx,%rdx,8),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    122d <LMSsort1_64+0xfd>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x78(%rbp)
jmp    123d <LMSsort1_64+0x10d>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
cmp    -0x58(%rbp),%rax
jge    125c <LMSsort1_64+0x12c>
mov    -0x48(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x80(%rbp)
jmp    1264 <LMSsort1_64+0x134>
mov    -0x48(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    14d3 <LMSsort1_64+0x3a3>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    %rcx,-0x48(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jge    1499 <LMSsort1_64+0x369>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    12d1 <LMSsort1_64+0x1a1>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x88(%rbp)
jmp    12e4 <LMSsort1_64+0x1b4>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    %rax,-0x90(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    1319 <LMSsort1_64+0x1e9>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0x98(%rbp)
jmp    132d <LMSsort1_64+0x1fd>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x98(%rbp),%rcx
cmp    %rcx,%rax
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    1371 <LMSsort1_64+0x241>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xa0(%rbp)
jmp    1384 <LMSsort1_64+0x254>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmp    -0x58(%rbp),%rax
je     13d3 <LMSsort1_64+0x2a3>
mov    -0x38(%rbp),%rdx
mov    -0x10(%rbp),%rax
sub    %rax,%rdx
sar    $0x3,%rdx
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
mov    (%rcx,%rdx,8),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x3,%rcx
cmp    %rcx,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    1428 <LMSsort1_64+0x2f8>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xa8(%rbp)
jmp    143b <LMSsort1_64+0x30b>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rax
cmp    -0x58(%rbp),%rax
jge    1460 <LMSsort1_64+0x330>
mov    -0x48(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0xb0(%rbp)
jmp    146b <LMSsort1_64+0x33b>
mov    -0x48(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
jmp    14bd <LMSsort1_64+0x38d>
cmpq   $0x0,-0x48(%rbp)
jge    14b8 <LMSsort1_64+0x388>
mov    -0x48(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14bd <LMSsort1_64+0x38d>
jmp    14c2 <LMSsort1_64+0x392>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1282 <LMSsort1_64+0x152>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    14fa <LMSsort1_64+0x3ca>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x30(%rbp),%rcx
mov    0x10(%rbp),%r8d
call   1050 <getCounts64@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    $0x1,%ecx
call   1030 <getBuckets64@plt>
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movq   $0x0,-0x58(%rbp)
mov    (%rcx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
cmp    -0x40(%rbp),%rax
jg     1762 <LMSsort1_64+0x632>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    %rcx,-0x48(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jge    174c <LMSsort1_64+0x61c>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    1587 <LMSsort1_64+0x457>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb8(%rbp)
jmp    159a <LMSsort1_64+0x46a>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    15cf <LMSsort1_64+0x49f>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0xc8(%rbp)
jmp    15e3 <LMSsort1_64+0x4b3>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
mov    %rax,-0xc8(%rbp)
mov    -0xc0(%rbp),%rax
mov    -0xc8(%rbp),%rcx
cmp    %rcx,%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    1627 <LMSsort1_64+0x4f7>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xd0(%rbp)
jmp    163a <LMSsort1_64+0x50a>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0x50(%rbp)
cmp    -0x58(%rbp),%rax
je     1689 <LMSsort1_64+0x559>
mov    -0x38(%rbp),%rdx
mov    -0x10(%rbp),%rax
sub    %rax,%rdx
sar    $0x3,%rdx
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
mov    (%rcx,%rdx,8),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x3,%rax
cmp    -0x40(%rbp),%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    16db <LMSsort1_64+0x5ab>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xd8(%rbp)
jmp    16ee <LMSsort1_64+0x5be>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rax
cmp    -0x58(%rbp),%rax
jle    1717 <LMSsort1_64+0x5e7>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0xe0(%rbp)
jmp    1722 <LMSsort1_64+0x5f2>
mov    -0x48(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x8(%rax)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
jmp    1751 <LMSsort1_64+0x621>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    153a <LMSsort1_64+0x40a>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LMSsort1_64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r13
mov    %r8,%r12
mov    %rcx,%r14
mov    %rdx,%rbp
mov    %rsi,%r15
mov    %rdi,(%rsp)
mov    0x60(%rsp),%ebx
cmp    %rcx,%rdx
jne    116f <LMSsort1_64+0x3f>
mov    (%rsp),%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %r13,%rcx
mov    %ebx,%r8d
call   1050 <getCounts64@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %r13,%rdx
xor    %ecx,%ecx
call   1030 <getBuckets64@plt>
cmp    $0x8,%ebx
mov    %ebx,%edi
mov    %r13,0x20(%rsp)
mov    %rbp,0x18(%rsp)
jne    11a5 <LMSsort1_64+0x75>
mov    (%rsp),%rax
mov    -0x10(%rax,%r12,8),%rcx
mov    -0x8(%rax,%r12,8),%rbx
lea    -0x2(%r12),%rax
jmp    11ba <LMSsort1_64+0x8a>
mov    (%rsp),%rcx
movzbl -0x1(%rcx,%r12,1),%ebx
lea    -0x2(%r12),%rax
movzbl -0x2(%rcx,%r12,1),%ecx
mov    %r14,0x8(%rsp)
mov    (%r14,%rbx,8),%rdx
mov    $0x1,%esi
sub    %r12,%rsi
cmp    %rbx,%rcx
cmovge %rax,%rsi
mov    %rsi,(%r15,%rdx,8)
test   %r12,%r12
jle    12f2 <LMSsort1_64+0x1c2>
lea    (%r15,%rdx,8),%r13
add    $0x8,%r13
xor    %ebp,%ebp
mov    %r15,0x10(%rsp)
jmp    121e <LMSsort1_64+0xee>
mov    (%rsp),%rcx
movzbl (%rcx,%rax,1),%ecx
neg    %r14
cmp    %rbx,%rcx
cmovl  %r14,%rax
mov    %rax,0x0(%r13)
add    $0x8,%r13
xor    %r14d,%r14d
mov    %r14,(%r15,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r12
je     12f2 <LMSsort1_64+0x1c2>
mov    (%r15,%rbp,8),%r14
test   %r14,%r14
jle    1280 <LMSsort1_64+0x150>
mov    %rbx,%r15
cmp    $0x8,%edi
jne    1290 <LMSsort1_64+0x160>
mov    (%rsp),%rbx
mov    (%rbx,%r14,8),%rax
xor    %edi,%edi
cmp    0x8(%rbx,%r14,8),%rax
setge  %dil
call   1040 <assert@plt>
mov    (%rbx,%r14,8),%rbx
cmp    %r15,%rbx
je     12b3 <LMSsort1_64+0x183>
mov    0x10(%rsp),%rcx
sub    %rcx,%r13
sar    $0x3,%r13
mov    0x8(%rsp),%rax
mov    %r13,(%rax,%r15,8)
mov    %rcx,%r15
mov    (%rax,%rbx,8),%rax
lea    (%rcx,%rax,8),%r13
jmp    12bb <LMSsort1_64+0x18b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
jns    1211 <LMSsort1_64+0xe1>
not    %r14
jmp    120d <LMSsort1_64+0xdd>
nopw   0x0(%rax,%rax,1)
mov    (%rsp),%rbx
movzbl (%rbx,%r14,1),%eax
xor    %edi,%edi
cmp    0x1(%rbx,%r14,1),%al
setae  %dil
call   1040 <assert@plt>
movzbl (%rbx,%r14,1),%ebx
cmp    %r15,%rbx
jne    1250 <LMSsort1_64+0x120>
mov    %r15,%rbx
mov    0x10(%rsp),%r15
mov    %r13,%rax
sub    %r15,%rax
sar    $0x3,%rax
xor    %edi,%edi
cmp    %rax,%rbp
setl   %dil
call   1040 <assert@plt>
lea    -0x1(%r14),%rax
mov    0x60(%rsp),%edi
cmp    $0x8,%edi
jne    11f0 <LMSsort1_64+0xc0>
mov    (%rsp),%rcx
mov    -0x8(%rcx,%r14,8),%rcx
jmp    11f8 <LMSsort1_64+0xc8>
mov    0x8(%rsp),%rbx
mov    0x18(%rsp),%rbp
cmp    %rbx,%rbp
mov    0x20(%rsp),%r14
jne    131d <LMSsort1_64+0x1ed>
mov    (%rsp),%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
mov    %r14,%rcx
mov    0x60(%rsp),%r8d
call   1050 <getCounts64@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r14,%rdx
mov    $0x1,%ecx
call   1030 <getBuckets64@plt>
test   %r12,%r12
mov    0x60(%rsp),%edx
jle    142f <LMSsort1_64+0x2ff>
mov    0x8(%rsp),%rax
mov    (%rax),%rax
lea    (%r15,%rax,8),%r13
xor    %r14d,%r14d
jmp    1380 <LMSsort1_64+0x250>
xchg   %ax,%ax
mov    (%rsp),%rcx
movzbl (%rcx,%rax,1),%ecx
cmp    %rbp,%rcx
not    %rbx
cmovg  %rbx,%rax
mov    %rax,-0x8(%r13)
add    $0xfffffffffffffff8,%r13
movq   $0x0,-0x8(%r15,%r12,8)
mov    %rbp,%r14
add    $0xffffffffffffffff,%r12
jle    142f <LMSsort1_64+0x2ff>
mov    -0x8(%r15,%r12,8),%rbx
test   %rbx,%rbx
jle    1376 <LMSsort1_64+0x246>
cmp    $0x8,%edx
jne    13b0 <LMSsort1_64+0x280>
mov    (%rsp),%rbp
mov    0x0(%rbp,%rbx,8),%rax
xor    %edi,%edi
cmp    0x8(%rbp,%rbx,8),%rax
setle  %dil
call   1040 <assert@plt>
mov    0x0(%rbp,%rbx,8),%rbp
jmp    13cd <LMSsort1_64+0x29d>
nop
mov    (%rsp),%rbp
movzbl 0x0(%rbp,%rbx,1),%eax
xor    %edi,%edi
cmp    0x1(%rbp,%rbx,1),%al
setbe  %dil
call   1040 <assert@plt>
movzbl 0x0(%rbp,%rbx,1),%ebp
lea    -0x1(%r12),%rax
cmp    %r14,%rbp
jne    13e0 <LMSsort1_64+0x2b0>
mov    %r14,%rbp
jmp    13f8 <LMSsort1_64+0x2c8>
nopl   0x0(%rax)
sub    %r15,%r13
sar    $0x3,%r13
mov    0x8(%rsp),%rcx
mov    %r13,(%rcx,%r14,8)
mov    (%rcx,%rbp,8),%rcx
lea    (%r15,%rcx,8),%r13
mov    %r13,%rcx
sub    %r15,%rcx
sar    $0x3,%rcx
xor    %edi,%edi
cmp    %rax,%rcx
setle  %dil
call   1040 <assert@plt>
lea    -0x1(%rbx),%rax
mov    0x60(%rsp),%edx
cmp    $0x8,%edx
jne    1350 <LMSsort1_64+0x220>
mov    (%rsp),%rcx
mov    -0x8(%rcx,%rbx,8),%rcx
jmp    1358 <LMSsort1_64+0x228>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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