#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);
long long computeBWT64(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, pidx = -1;
  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)])];
  *b++ = ((0 < j) &&
          ((cs == sizeof(long long) ? ((long long *)T)[(j - 1)]
                                    : ((unsigned char *)T)[(j - 1)]) < c1))
             ? ~j
             : j;
  for (i = 0; i < n; ++i) {
    if (0 < (j = SA[i])) {
      --j;
      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)]));
      SA[i] = ~((long long)(c0 = (cs == sizeof(long long)
                                      ? ((long long *)T)[(j)]
                                      : ((unsigned char *)T)[(j)])));
      if (c0 != c1) {
        B[c1] = b - SA;
        b = SA + B[c1 = c0];
      }
      assert(i < (b - SA));
      *b++ = ((0 < j) &&
              ((cs == sizeof(long long) ? ((long long *)T)[(j - 1)]
                                        : ((unsigned char *)T)[(j - 1)]) < c1))
                 ? ~j
                 : j;
    } 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])) {
      --j;
      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)]));
      SA[i] = (c0 = (cs == sizeof(long long) ? ((long long *)T)[(j)]
                                             : ((unsigned char *)T)[(j)]));
      if (c0 != c1) {
        B[c1] = b - SA;
        b = SA + B[c1 = c0];
      }
      assert((b - SA) <= i);
      *--b = ((0 < j) &&
              ((cs == sizeof(long long) ? ((long long *)T)[(j - 1)]
                                        : ((unsigned char *)T)[(j - 1)]) > c1))
                 ? ~((long long)(cs == sizeof(long long)
                                     ? ((long long *)T)[(j - 1)]
                                     : ((unsigned char *)T)[(j - 1)]))
                 : j;
    } else if (j != 0) {
      SA[i] = ~j;
    } else {
      pidx = i;
    }
  }
  return pidx;
}


x86 assembly (clang, -O0):
<computeBWT64>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%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)
movq   $0xffffffffffffffff,-0x50(%rbp)
ff
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1185 <computeBWT64+0x55>
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,-0x70(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    11d7 <computeBWT64+0xa7>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x78(%rbp)
jmp    11e7 <computeBWT64+0xb7>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
mov    -0x68(%rbp),%rcx
mov    -0x78(%rbp),%rdx
mov    %rdx,-0x60(%rbp)
mov    (%rcx,%rdx,8),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
cmp    -0x48(%rbp),%rax
jge    126f <computeBWT64+0x13f>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    1239 <computeBWT64+0x109>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x80(%rbp)
jmp    124d <computeBWT64+0x11d>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
cmp    -0x60(%rbp),%rax
jge    126f <computeBWT64+0x13f>
mov    -0x48(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x88(%rbp)
jmp    127a <computeBWT64+0x14a>
mov    -0x48(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%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    1504 <computeBWT64+0x3d4>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    %rcx,-0x48(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jge    14ca <computeBWT64+0x39a>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    12f6 <computeBWT64+0x1c6>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x90(%rbp)
jmp    1309 <computeBWT64+0x1d9>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x98(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    133e <computeBWT64+0x20e>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0xa0(%rbp)
jmp    1352 <computeBWT64+0x222>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
mov    %rax,-0xa0(%rbp)
mov    -0x98(%rbp),%rax
mov    -0xa0(%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    1396 <computeBWT64+0x266>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xa8(%rbp)
jmp    13a9 <computeBWT64+0x279>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xa8(%rbp)
mov    -0xa8(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
xor    $0xffffffffffffffff,%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
je     140c <computeBWT64+0x2dc>
mov    -0x38(%rbp),%rdx
mov    -0x10(%rbp),%rax
sub    %rax,%rdx
sar    $0x3,%rdx
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    %rdx,-0x60(%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>
xor    %eax,%eax
cmp    -0x48(%rbp),%rax
jge    14a1 <computeBWT64+0x371>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    1465 <computeBWT64+0x335>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb0(%rbp)
jmp    147c <computeBWT64+0x34c>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
cmp    -0x60(%rbp),%rax
jge    14a1 <computeBWT64+0x371>
mov    -0x48(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0xb8(%rbp)
jmp    14ac <computeBWT64+0x37c>
mov    -0x48(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0xb8(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
jmp    14ee <computeBWT64+0x3be>
cmpq   $0x0,-0x48(%rbp)
je     14e9 <computeBWT64+0x3b9>
mov    -0x48(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14ee <computeBWT64+0x3be>
jmp    14f3 <computeBWT64+0x3c3>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    129b <computeBWT64+0x16b>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    152b <computeBWT64+0x3fb>
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,-0x60(%rbp)
mov    (%rcx),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
cmp    -0x40(%rbp),%rax
jg     181d <computeBWT64+0x6ed>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    %rcx,-0x48(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jge    17d6 <computeBWT64+0x6a6>
mov    -0x48(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    15c4 <computeBWT64+0x494>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
jmp    15d7 <computeBWT64+0x4a7>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    160c <computeBWT64+0x4dc>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    0x8(%rax,%rcx,8),%rax
mov    %rax,-0xd0(%rbp)
jmp    1620 <computeBWT64+0x4f0>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl 0x1(%rax,%rcx,1),%eax
mov    %rax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rax
mov    -0xd0(%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    1664 <computeBWT64+0x534>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xd8(%rbp)
jmp    1677 <computeBWT64+0x547>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xd8(%rbp)
mov    -0xd8(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
je     16d6 <computeBWT64+0x5a6>
mov    -0x38(%rbp),%rdx
mov    -0x10(%rbp),%rax
sub    %rax,%rdx
sar    $0x3,%rdx
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    %rdx,-0x60(%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>
xor    %eax,%eax
cmp    -0x48(%rbp),%rax
jge    17ac <computeBWT64+0x67c>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    172c <computeBWT64+0x5fc>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe0(%rbp)
jmp    1743 <computeBWT64+0x613>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xe0(%rbp)
mov    -0xe0(%rbp),%rax
cmp    -0x60(%rbp),%rax
jle    17ac <computeBWT64+0x67c>
movslq 0x10(%rbp),%rax
cmp    $0x8,%rax
jne    177e <computeBWT64+0x64e>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe8(%rbp)
jmp    1795 <computeBWT64+0x665>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xe8(%rbp)
mov    -0xe8(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0xf0(%rbp)
jmp    17b7 <computeBWT64+0x687>
mov    -0x48(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xf0(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,-0x8(%rax)
jmp    1807 <computeBWT64+0x6d7>
cmpq   $0x0,-0x48(%rbp)
je     17fa <computeBWT64+0x6ca>
mov    -0x48(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    1802 <computeBWT64+0x6d2>
mov    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    1807 <computeBWT64+0x6d7>
jmp    180c <computeBWT64+0x6dc>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    156b <computeBWT64+0x43b>
mov    -0x50(%rbp),%rax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeBWT64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r13
mov    %r8,%r14
mov    %rcx,%rbx
mov    %rdx,%rax
mov    %rsi,%r12
mov    %rdi,%rbp
mov    0x60(%rsp),%r15d
cmp    %rcx,%rdx
mov    %rdx,0x8(%rsp)
jne    117a <computeBWT64+0x4a>
mov    %rbp,%rdi
mov    0x8(%rsp),%rsi
mov    %r14,%rdx
mov    %r13,%rcx
mov    %r15d,%r8d
call   1050 <getCounts64@plt>
mov    0x8(%rsp),%rax
mov    %rax,%rdi
mov    %rbx,%rsi
mov    %r13,0x20(%rsp)
mov    %r13,%rdx
xor    %ecx,%ecx
call   1030 <getBuckets64@plt>
lea    -0x1(%r14),%rax
cmp    $0x8,%r15d
mov    %rbx,0x18(%rsp)
mov    %r14,%rsi
mov    %r14,(%rsp)
mov    %rbp,0x10(%rsp)
mov    %r15d,%edi
jne    11c7 <computeBWT64+0x97>
mov    -0x8(%rbp,%rsi,8),%r14
mov    (%rbx,%r14,8),%rcx
lea    (%r12,%rcx,8),%r13
cmp    $0x1,%rsi
jle    11f3 <computeBWT64+0xc3>
mov    -0x10(%rbp,%rsi,8),%rcx
jmp    11e0 <computeBWT64+0xb0>
movzbl -0x1(%rbp,%rsi,1),%r14d
mov    (%rbx,%r14,8),%rcx
lea    (%r12,%rcx,8),%r13
cmp    $0x1,%rsi
jle    11f3 <computeBWT64+0xc3>
movzbl -0x2(%rsi,%rbp,1),%ecx
mov    %rsi,%rdx
neg    %rdx
cmp    %r14,%rcx
cmovl  %rdx,%rax
mov    %rax,0x0(%r13)
jmp    1200 <computeBWT64+0xd0>
mov    %rax,0x0(%r13)
test   %rsi,%rsi
jle    1326 <computeBWT64+0x1f6>
add    $0x8,%r13
xor    %ebp,%ebp
jmp    1232 <computeBWT64+0x102>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    (%rsp),%rsi
mov    0x60(%rsp),%edi
mov    %rax,0x0(%r13)
add    $0x8,%r13
add    $0x1,%rbp
mov    %rbx,%r14
cmp    %rbp,%rsi
je     1321 <computeBWT64+0x1f1>
mov    (%r12,%rbp,8),%r15
test   %r15,%r15
jle    1260 <computeBWT64+0x130>
cmp    $0x8,%edi
jne    1270 <computeBWT64+0x140>
mov    0x10(%rsp),%rbx
mov    -0x8(%rbx,%r15,8),%rax
xor    %edi,%edi
cmp    (%rbx,%r15,8),%rax
setge  %dil
call   1040 <assert@plt>
mov    -0x8(%rbx,%r15,8),%rbx
jmp    1290 <computeBWT64+0x160>
je     1269 <computeBWT64+0x139>
not    %r15
mov    %r15,(%r12,%rbp,8)
mov    %r14,%rbx
jmp    1222 <computeBWT64+0xf2>
xchg   %ax,%ax
mov    0x10(%rsp),%rbx
movzbl -0x1(%rbx,%r15,1),%eax
xor    %edi,%edi
cmp    (%rbx,%r15,1),%al
setae  %dil
call   1040 <assert@plt>
movzbl -0x1(%rbx,%r15,1),%ebx
mov    %rbx,%rax
not    %rax
mov    %rax,(%r12,%rbp,8)
cmp    %r14,%rbx
jne    12b0 <computeBWT64+0x180>
mov    %r14,%rbx
jmp    12c8 <computeBWT64+0x198>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
sub    %r12,%r13
sar    $0x3,%r13
mov    0x18(%rsp),%rax
mov    %r13,(%rax,%r14,8)
mov    (%rax,%rbx,8),%rax
lea    (%r12,%rax,8),%r13
mov    %r13,%rax
sub    %r12,%rax
sar    $0x3,%rax
xor    %edi,%edi
cmp    %rax,%rbp
setl   %dil
call   1040 <assert@plt>
cmp    $0x2,%r15
jb     1210 <computeBWT64+0xe0>
lea    -0x1(%r15),%rax
mov    0x60(%rsp),%edi
cmp    $0x8,%edi
jne    1303 <computeBWT64+0x1d3>
mov    0x10(%rsp),%rcx
mov    -0x10(%rcx,%r15,8),%rcx
jmp    130e <computeBWT64+0x1de>
mov    0x10(%rsp),%rcx
movzbl -0x2(%rcx,%r15,1),%ecx
mov    (%rsp),%rsi
neg    %r15
cmp    %rbx,%rcx
cmovl  %r15,%rax
jmp    121a <computeBWT64+0xea>
mov    $0x1,%r14b
jmp    1329 <computeBWT64+0x1f9>
xor    %r14d,%r14d
mov    0x18(%rsp),%rbp
mov    0x8(%rsp),%rdi
cmp    %rbp,%rdi
mov    0x20(%rsp),%rbx
jne    135d <computeBWT64+0x22d>
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    (%rsp),%rdx
mov    %rbx,%rcx
mov    0x60(%rsp),%r8d
call   1050 <getCounts64@plt>
mov    0x8(%rsp),%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    $0x1,%ecx
call   1030 <getBuckets64@plt>
movq   $0xffffffffffffffff,0x8(%rsp)
ff ff
test   %r14b,%r14b
mov    (%rsp),%rdx
mov    0x60(%rsp),%esi
je     14ff <computeBWT64+0x3cf>
mov    0x18(%rsp),%rax
mov    (%rax),%rax
lea    (%r12,%rax,8),%r13
movq   $0xffffffffffffffff,0x8(%rsp)
ff ff
xor    %r15d,%r15d
jmp    13ce <computeBWT64+0x29e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    (%rsp),%rdx
mov    0x60(%rsp),%esi
mov    %rax,-0x8(%r13)
add    $0xfffffffffffffff8,%r13
mov    %r14,%r15
test   %rdx,%rdx
jle    14ff <computeBWT64+0x3cf>
mov    %rdx,%rbp
add    $0xffffffffffffffff,%rdx
mov    -0x8(%r12,%rbp,8),%rbx
test   %rbx,%rbx
jle    1410 <computeBWT64+0x2e0>
mov    %rdx,(%rsp)
cmp    $0x8,%esi
jne    1430 <computeBWT64+0x300>
mov    0x10(%rsp),%r14
mov    -0x8(%r14,%rbx,8),%rax
xor    %edi,%edi
cmp    (%r14,%rbx,8),%rax
setle  %dil
call   1040 <assert@plt>
mov    -0x8(%r14,%rbx,8),%r14
jmp    1450 <computeBWT64+0x320>
nopl   0x0(%rax,%rax,1)
je     14f2 <computeBWT64+0x3c2>
not    %rbx
mov    %rbx,-0x8(%r12,%rbp,8)
jmp    14f7 <computeBWT64+0x3c7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x10(%rsp),%r14
movzbl -0x1(%r14,%rbx,1),%eax
xor    %edi,%edi
cmp    (%r14,%rbx,1),%al
setbe  %dil
call   1040 <assert@plt>
movzbl -0x1(%r14,%rbx,1),%r14d
mov    %r14,-0x8(%r12,%rbp,8)
cmp    %r15,%r14
mov    (%rsp),%rcx
jne    1470 <computeBWT64+0x340>
mov    %r15,%r14
jmp    1488 <computeBWT64+0x358>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
sub    %r12,%r13
sar    $0x3,%r13
mov    0x18(%rsp),%rax
mov    %r13,(%rax,%r15,8)
mov    (%rax,%r14,8),%rax
lea    (%r12,%rax,8),%r13
mov    %r13,%rax
sub    %r12,%rax
sar    $0x3,%rax
xor    %edi,%edi
cmp    %rcx,%rax
setle  %dil
call   1040 <assert@plt>
cmp    $0x2,%rbx
jb     13b0 <computeBWT64+0x280>
lea    -0x1(%rbx),%rax
mov    0x60(%rsp),%esi
cmp    $0x8,%esi
jne    14d0 <computeBWT64+0x3a0>
mov    0x10(%rsp),%rcx
mov    -0x10(%rcx,%rbx,8),%rcx
cmp    %r14,%rcx
mov    (%rsp),%rdx
jle    13ba <computeBWT64+0x28a>
jmp    14e7 <computeBWT64+0x3b7>
mov    0x10(%rsp),%rcx
movzbl -0x2(%rcx,%rbx,1),%ecx
cmp    %rcx,%r14
mov    (%rsp),%rdx
jge    13ba <computeBWT64+0x28a>
not    %rcx
mov    %rcx,%rax
jmp    13ba <computeBWT64+0x28a>
mov    %rdx,0x8(%rsp)
mov    %r15,%r14
jmp    13c2 <computeBWT64+0x292>
mov    0x8(%rsp),%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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