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


x86 assembly (clang, -O0):
<LMSsort2_64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x100,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
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
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    0x10(%rbp),%rdx
xor    %ecx,%ecx
call   1030 <getBuckets64@plt>
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x70(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    11b1 <LMSsort2_64+0x91>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x80(%rbp)
jmp    11c1 <LMSsort2_64+0xa1>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x80(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rcx
mov    -0x80(%rbp),%rdx
mov    %rdx,-0x68(%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 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    1212 <LMSsort2_64+0xf2>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x88(%rbp)
jmp    1225 <LMSsort2_64+0x105>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
cmp    -0x68(%rbp),%rax
setl   %al
and    $0x1,%al
movzbl %al,%eax
cltq
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1270 <LMSsort2_64+0x150>
mov    -0x48(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x90(%rbp)
jmp    127b <LMSsort2_64+0x15b>
mov    -0x48(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    158d <LMSsort2_64+0x46d>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    %rcx,-0x48(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jge    1553 <LMSsort2_64+0x433>
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
jg     12f6 <LMSsort2_64+0x1d6>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x48(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x48(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    131c <LMSsort2_64+0x1fc>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x98(%rbp)
jmp    132f <LMSsort2_64+0x20f>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x98(%rbp)
mov    -0x98(%rbp),%rax
mov    %rax,-0xa0(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    1364 <LMSsort2_64+0x244>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0xa8(%rbp)
jmp    1378 <LMSsort2_64+0x258>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
mov    %rax,-0xa8(%rbp)
mov    -0xa0(%rbp),%rax
mov    -0xa8(%rbp),%rcx
cmp    %rcx,%rax
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    13bc <LMSsort2_64+0x29c>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb0(%rbp)
jmp    13cf <LMSsort2_64+0x2af>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmp    -0x68(%rbp),%rax
je     141e <LMSsort2_64+0x2fe>
mov    -0x38(%rbp),%rdx
mov    -0x10(%rbp),%rax
sub    %rax,%rdx
sar    $0x3,%rdx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    %rdx,-0x68(%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)
mov    -0x60(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xb8(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    148a <LMSsort2_64+0x36a>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
jmp    149d <LMSsort2_64+0x37d>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xc0(%rbp)
mov    -0xb8(%rbp),%rax
mov    -0xc0(%rbp),%rcx
cmp    -0x68(%rbp),%rcx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
or     %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x58(%rbp),%rax
je     14f4 <LMSsort2_64+0x3d4>
mov    -0x30(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%rdx
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     151a <LMSsort2_64+0x3fa>
mov    -0x48(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0xc8(%rbp)
jmp    1525 <LMSsort2_64+0x405>
mov    -0x48(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%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    1577 <LMSsort2_64+0x457>
cmpq   $0x0,-0x48(%rbp)
jge    1572 <LMSsort2_64+0x452>
mov    -0x48(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1577 <LMSsort2_64+0x457>
jmp    157c <LMSsort2_64+0x45c>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12a4 <LMSsort2_64+0x184>
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
xor    %eax,%eax
cmp    -0x40(%rbp),%rax
jg     1655 <LMSsort2_64+0x535>
mov    -0x10(%rbp),%rcx
mov    -0x40(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,8),%rax
jge    163f <LMSsort2_64+0x51f>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x30(%rbp),%rax
jge    163a <LMSsort2_64+0x51a>
mov    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x30(%rbp),%rax
jge    161b <LMSsort2_64+0x4fb>
jmp    160a <LMSsort2_64+0x4ea>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
jmp    15ef <LMSsort2_64+0x4cf>
mov    -0x30(%rbp),%rsi
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
sub    %rsi,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    163f <LMSsort2_64+0x51f>
jmp    1644 <LMSsort2_64+0x524>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    1599 <LMSsort2_64+0x479>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    0x10(%rbp),%rdx
mov    $0x1,%ecx
call   1030 <getBuckets64@plt>
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movq   $0x0,-0x68(%rbp)
mov    (%rcx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
cmp    -0x40(%rbp),%rax
jg     1961 <LMSsort2_64+0x841>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    %rcx,-0x48(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jge    194b <LMSsort2_64+0x82b>
mov    -0x30(%rbp),%rax
cmp    -0x48(%rbp),%rax
jg     16f1 <LMSsort2_64+0x5d1>
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x48(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x48(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    1717 <LMSsort2_64+0x5f7>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xd0(%rbp)
jmp    172a <LMSsort2_64+0x60a>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xd0(%rbp)
mov    -0xd0(%rbp),%rax
mov    %rax,-0xd8(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    175f <LMSsort2_64+0x63f>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0xe0(%rbp)
jmp    1773 <LMSsort2_64+0x653>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
mov    %rax,-0xe0(%rbp)
mov    -0xd8(%rbp),%rax
mov    -0xe0(%rbp),%rcx
cmp    %rcx,%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    17b7 <LMSsort2_64+0x697>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe8(%rbp)
jmp    17ca <LMSsort2_64+0x6aa>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmp    -0x68(%rbp),%rax
je     1819 <LMSsort2_64+0x6f9>
mov    -0x38(%rbp),%rdx
mov    -0x10(%rbp),%rax
sub    %rax,%rdx
sar    $0x3,%rdx
mov    -0x20(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x60(%rbp),%rdx
mov    %rdx,-0x68(%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)
mov    -0x60(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0xf0(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x8,%rax
jne    1882 <LMSsort2_64+0x762>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1895 <LMSsort2_64+0x775>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xf8(%rbp)
mov    -0xf0(%rbp),%rax
mov    -0xf8(%rbp),%rcx
cmp    -0x68(%rbp),%rcx
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
movslq %ecx,%rcx
or     %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmp    -0x58(%rbp),%rax
je     18ec <LMSsort2_64+0x7cc>
mov    -0x30(%rbp),%rax
add    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x58(%rbp),%rdx
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     1916 <LMSsort2_64+0x7f6>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x100(%rbp)
jmp    1921 <LMSsort2_64+0x801>
mov    -0x48(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x100(%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    1950 <LMSsort2_64+0x830>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    16a1 <LMSsort2_64+0x581>
add    $0x100,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LMSsort2_64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%r12
mov    %r8,0x40(%rsp)
mov    %rcx,%rbp
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r13
mov    0x88(%rsp),%r15d
mov    0x80(%rsp),%rax
mov    %rax,0x38(%rsp)
xor    %edi,%edi
cmp    %rcx,%rdx
setne  %dil
call   1040 <assert@plt>
mov    %r14,0x30(%rsp)
mov    %r14,%rdi
mov    %rbp,0x28(%rsp)
mov    %rbp,%rsi
mov    0x38(%rsp),%rbp
mov    %rbp,%rdx
xor    %ecx,%ecx
call   1030 <getBuckets64@plt>
mov    %r15d,0x1c(%rsp)
cmp    $0x8,%r15d
jne    11a0 <LMSsort2_64+0x80>
mov    -0x10(%r13,%r12,8),%rdx
mov    -0x8(%r13,%r12,8),%r10
lea    -0x2(%r12),%rax
jmp    11b1 <LMSsort2_64+0x91>
movzbl -0x1(%r13,%r12,1),%r10d
lea    -0x2(%r12),%rax
movzbl -0x2(%r13,%r12,1),%edx
mov    %r13,%r9
mov    0x28(%rsp),%rcx
mov    (%rcx,%r10,8),%rcx
xor    %esi,%esi
cmp    %r10,%rdx
setl   %sil
add    %r12,%rax
neg    %rsi
xor    %rax,%rsi
mov    %rsi,(%rbx,%rcx,8)
test   %r12,%r12
mov    0x30(%rsp),%rdi
jle    13e4 <LMSsort2_64+0x2c4>
lea    -0x1(%r12),%r15
lea    (%rbx,%rcx,8),%rsi
add    $0x8,%rsi
xor    %r8d,%r8d
xor    %r13d,%r13d
mov    %r9,0x10(%rsp)
jmp    122d <LMSsort2_64+0x10d>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r9
xor    %edx,%edx
cmp    %r10,%rcx
setl   %dl
neg    %rdx
xor    %rax,%rdx
mov    %rdx,(%rsi)
add    $0x8,%rsi
xor    %ebp,%ebp
mov    %rbp,(%rbx,%r13,8)
add    $0x1,%r13
cmp    %r13,%r12
je     137d <LMSsort2_64+0x25d>
mov    (%rbx,%r13,8),%rbp
test   %rbp,%rbp
jle    1290 <LMSsort2_64+0x170>
cmp    %r12,%rbp
setge  %cl
mov    $0x0,%eax
cmovge %r12,%rax
sub    %rax,%rbp
cmpl   $0x8,0x1c(%rsp)
mov    %r10,0x8(%rsp)
mov    %r8,0x20(%rsp)
mov    %cl,(%rsp)
jne    12a0 <LMSsort2_64+0x180>
mov    (%r9,%rbp,8),%rax
xor    %edi,%edi
cmp    0x8(%r9,%rbp,8),%rax
setge  %dil
mov    %rsi,%r14
call   1040 <assert@plt>
mov    %r14,%rsi
mov    0x8(%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%rax
mov    (%rax,%rbp,8),%r14
cmp    %rdx,%r14
jne    12d4 <LMSsort2_64+0x1b4>
jmp    12f1 <LMSsort2_64+0x1d1>
jns    1220 <LMSsort2_64+0x100>
not    %rbp
jmp    121c <LMSsort2_64+0xfc>
nopw   0x0(%rax,%rax,1)
movzbl (%r9,%rbp,1),%eax
xor    %edi,%edi
cmp    0x1(%r9,%rbp,1),%al
setae  %dil
mov    %rsi,%r14
call   1040 <assert@plt>
mov    %r14,%rsi
mov    0x8(%rsp),%rdx
mov    0x20(%rsp),%rcx
mov    0x10(%rsp),%rax
movzbl (%rax,%rbp,1),%r14d
cmp    %rdx,%r14
je     12f1 <LMSsort2_64+0x1d1>
sub    %rbx,%rsi
sar    $0x3,%rsi
mov    0x28(%rsp),%rax
mov    %rsi,(%rax,%rdx,8)
mov    (%rax,%r14,8),%rax
lea    (%rbx,%rax,8),%rsi
mov    %r14,0x8(%rsp)
xor    %eax,%eax
movzbl (%rsp),%edx
mov    %dl,%al
add    %rax,%rcx
mov    %rcx,0x20(%rsp)
mov    %rsi,(%rsp)
mov    %rsi,%rax
sub    %rbx,%rax
sar    $0x3,%rax
xor    %edi,%edi
cmp    %rax,%r13
setl   %dil
call   1040 <assert@plt>
lea    -0x1(%rbp),%rax
add    %r14,%r14
cmpl   $0x8,0x1c(%rsp)
jne    1340 <LMSsort2_64+0x220>
mov    0x10(%rsp),%rcx
mov    -0x8(%rcx,%rbp,8),%rcx
jmp    1349 <LMSsort2_64+0x229>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
movzbl (%rcx,%rax,1),%ecx
mov    0x20(%rsp),%r8
mov    0x8(%rsp),%r10
mov    (%rsp),%rsi
xor    %edx,%edx
cmp    %r10,%rcx
setl   %dl
or     %rdx,%r14
mov    0x40(%rsp),%rdx
cmp    %r8,(%rdx,%r14,8)
je     1200 <LMSsort2_64+0xe0>
add    %r12,%rax
mov    %r8,(%rdx,%r14,8)
jmp    1200 <LMSsort2_64+0xe0>
test   %r12,%r12
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rbp
jle    13e4 <LMSsort2_64+0x2c4>
mov    %rbp,%rdx
mov    %r8,%rbp
jmp    13ac <LMSsort2_64+0x28c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%r15),%rax
test   %r15,%r15
mov    %rax,%r15
jle    1404 <LMSsort2_64+0x2e4>
mov    (%rbx,%r15,8),%rax
test   %rax,%rax
jle    13a0 <LMSsort2_64+0x280>
cmp    %r12,%rax
jge    13a0 <LMSsort2_64+0x280>
add    %r12,%rax
mov    %rax,(%rbx,%r15,8)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rbx,%r15,8),%rax
add    $0xffffffffffffffff,%r15
sub    %r12,%rax
jl     13d0 <LMSsort2_64+0x2b0>
mov    %rax,(%rbx,%r15,8)
jmp    13a0 <LMSsort2_64+0x280>
mov    0x28(%rsp),%rsi
mov    %rbp,%rdx
mov    $0x1,%ecx
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <getBuckets64@plt>
mov    0x28(%rsp),%rsi
mov    $0x1,%ecx
call   1030 <getBuckets64@plt>
test   %r12,%r12
jle    15bb <LMSsort2_64+0x49b>
mov    %rbp,%r8
mov    0x28(%rsp),%rax
mov    (%rax),%rax
lea    (%rbx,%rax,8),%rdi
add    $0x1,%r8
xor    %esi,%esi
mov    %r12,%r13
jmp    146c <LMSsort2_64+0x34c>
cs nopw 0x0(%rax,%rax,1)
mov    $0xfffffffffffffffe,%rdx
sub    %rax,%rdx
cmp    %rsi,%rcx
cmovle %rax,%rdx
mov    %rdx,-0x8(%rdi)
add    $0xfffffffffffffff8,%rdi
movq   $0x0,-0x8(%rbx,%r13,8)
add    $0xffffffffffffffff,%r13
jle    15bb <LMSsort2_64+0x49b>
mov    -0x8(%rbx,%r13,8),%rbp
test   %rbp,%rbp
jle    1462 <LMSsort2_64+0x342>
xor    %r14d,%r14d
cmp    %r12,%rbp
setge  %cl
mov    $0x0,%eax
cmovge %r12,%rax
sub    %rax,%rbp
cmpl   $0x8,0x1c(%rsp)
mov    %r8,0x20(%rsp)
mov    %rdi,0x8(%rsp)
mov    %rsi,(%rsp)
mov    %cl,0x30(%rsp)
jne    14e0 <LMSsort2_64+0x3c0>
mov    0x10(%rsp),%r15
mov    (%r15,%rbp,8),%rax
xor    %edi,%edi
cmp    0x8(%r15,%rbp,8),%rax
setle  %dil
call   1040 <assert@plt>
mov    (%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    0x20(%rsp),%rdx
mov    (%r15,%rbp,8),%r15
jmp    150d <LMSsort2_64+0x3ed>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r15
movzbl (%r15,%rbp,1),%eax
xor    %edi,%edi
cmp    0x1(%r15,%rbp,1),%al
setbe  %dil
call   1040 <assert@plt>
mov    (%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    0x20(%rsp),%rdx
movzbl (%r15,%rbp,1),%r15d
lea    -0x1(%r13),%rax
cmp    %rdi,%r15
je     1532 <LMSsort2_64+0x412>
sub    %rbx,%rsi
sar    $0x3,%rsi
mov    0x28(%rsp),%rcx
mov    %rsi,(%rcx,%rdi,8)
mov    (%rcx,%r15,8),%rcx
lea    (%rbx,%rcx,8),%rsi
mov    %r15,(%rsp)
movzbl 0x30(%rsp),%ecx
mov    %cl,%r14b
add    %r14,%rdx
mov    %rdx,%r14
mov    %rsi,0x8(%rsp)
mov    %rsi,%rcx
sub    %rbx,%rcx
sar    $0x3,%rcx
xor    %edi,%edi
cmp    %rax,%rcx
setle  %dil
call   1040 <assert@plt>
lea    -0x1(%rbp),%rax
add    %r15,%r15
cmpl   $0x8,0x1c(%rsp)
jne    1580 <LMSsort2_64+0x460>
mov    0x10(%rsp),%rcx
mov    -0x8(%rcx,%rbp,8),%rcx
jmp    1589 <LMSsort2_64+0x469>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
movzbl (%rcx,%rax,1),%ecx
mov    %r14,%r8
mov    0x8(%rsp),%rdi
mov    (%rsp),%rsi
xor    %edx,%edx
cmp    %rsi,%rcx
setg   %dl
or     %rdx,%r15
mov    0x40(%rsp),%rdx
cmp    %r14,(%rdx,%r15,8)
je     1440 <LMSsort2_64+0x320>
add    %r12,%rax
mov    %r8,(%rdx,%r15,8)
jmp    1440 <LMSsort2_64+0x320>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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