#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int off_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ getBuckets(int *, int *, int, int);
int /*<<< orphan*/ getCounts(void const *, int *, int, int, int);
off_t computeBWT(const void *T, off_t *SA, off_t *C, off_t *B, off_t n, off_t k,
                 int cs) {
  off_t *b, i, j, pidx = -1;
  off_t c0, c1;
  if (C == B) {
    getCounts(T, C, n, k, cs);
  }
  getBuckets(C, B, k, 0);
  j = n - 1;
  b = SA + B[c1 = (cs == sizeof(off_t) ? ((const off_t *)T)[(j)]
                                       : ((const unsigned char *)T)[(j)])];
  *b++ = ((0 < j) &&
          ((cs == sizeof(off_t) ? ((const off_t *)T)[(j - 1)]
                                : ((const unsigned char *)T)[(j - 1)]) < c1))
             ? ~j
             : j;
  for (i = 0; i < n; ++i) {
    if (0 < (j = SA[i])) {
      --j;
      assert((cs == sizeof(off_t) ? ((const off_t *)T)[(j)]
                                  : ((const unsigned char *)T)[(j)]) >=
             (cs == sizeof(off_t) ? ((const off_t *)T)[(j + 1)]
                                  : ((const unsigned char *)T)[(j + 1)]));
      SA[i] = ~((off_t)(c0 = (cs == sizeof(off_t)
                                  ? ((const off_t *)T)[(j)]
                                  : ((const 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(off_t)
                               ? ((const off_t *)T)[(j - 1)]
                               : ((const unsigned char *)T)[(j - 1)]) < c1))
                 ? ~j
                 : j;
    } else if (j != 0) {
      SA[i] = ~j;
    }
  }
  if (C == B) {
    getCounts(T, C, n, k, cs);
  }
  getBuckets(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(off_t) ? ((const off_t *)T)[(j)]
                                  : ((const unsigned char *)T)[(j)]) <=
             (cs == sizeof(off_t) ? ((const off_t *)T)[(j + 1)]
                                  : ((const unsigned char *)T)[(j + 1)]));
      SA[i] = (c0 = (cs == sizeof(off_t) ? ((const off_t *)T)[(j)]
                                         : ((const 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(off_t)
                               ? ((const off_t *)T)[(j - 1)]
                               : ((const unsigned char *)T)[(j - 1)]) > c1))
                 ? ~((off_t)(cs == sizeof(off_t)
                                 ? ((const off_t *)T)[(j - 1)]
                                 : ((const unsigned char *)T)[(j - 1)]))
                 : j;
    } else if (j != 0) {
      SA[i] = ~j;
    } else {
      pidx = i;
    }
  }
  return pidx;
}


x86 assembly (clang, -O0):
<computeBWT>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
movl   $0xffffffff,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1182 <computeBWT+0x52>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    0x10(%rbp),%r8d
call   1030 <getCounts@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%edx
xor    %ecx,%ecx
call   1050 <getBuckets@plt>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x50(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    11ce <computeBWT+0x9e>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
jmp    11dd <computeBWT+0xad>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
mov    -0x5c(%rbp),%edx
mov    %edx,-0x44(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
xor    %eax,%eax
cmp    -0x38(%rbp),%eax
jge    125c <computeBWT+0x12c>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    122e <computeBWT+0xfe>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    1242 <computeBWT+0x112>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    125c <computeBWT+0x12c>
mov    -0x38(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    1262 <computeBWT+0x132>
mov    -0x38(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    148f <computeBWT+0x35f>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x38(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jge    145c <computeBWT+0x32c>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    12cb <computeBWT+0x19b>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    12da <computeBWT+0x1aa>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1306 <computeBWT+0x1d6>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
jmp    131a <computeBWT+0x1ea>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
cmp    %ecx,%eax
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1350 <computeBWT+0x220>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
jmp    135f <computeBWT+0x22f>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%edx
mov    %edx,-0x40(%rbp)
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     13bb <computeBWT+0x28b>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x40(%rbp),%edx
mov    %edx,-0x44(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x10(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
xor    %eax,%eax
cmp    -0x38(%rbp),%eax
jge    143d <computeBWT+0x30d>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    140f <computeBWT+0x2df>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
jmp    1423 <computeBWT+0x2f3>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    143d <computeBWT+0x30d>
mov    -0x38(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x7c(%rbp)
jmp    1443 <computeBWT+0x313>
mov    -0x38(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
jmp    147c <computeBWT+0x34c>
cmpl   $0x0,-0x38(%rbp)
je     1477 <computeBWT+0x347>
mov    -0x38(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    147c <computeBWT+0x34c>
jmp    1481 <computeBWT+0x351>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    127d <computeBWT+0x14d>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    14b4 <computeBWT+0x384>
mov    -0x8(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
mov    0x10(%rbp),%r8d
call   1030 <getCounts@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%edx
mov    $0x1,%ecx
call   1050 <getBuckets@plt>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movl   $0x0,-0x44(%rbp)
movslq (%rcx),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
xor    %eax,%eax
cmp    -0x34(%rbp),%eax
jg     1776 <computeBWT+0x646>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x38(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jge    1738 <computeBWT+0x608>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    153c <computeBWT+0x40c>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
jmp    154b <computeBWT+0x41b>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x84(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    157d <computeBWT+0x44d>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
jmp    1594 <computeBWT+0x464>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x88(%rbp)
mov    -0x84(%rbp),%eax
mov    -0x88(%rbp),%ecx
cmp    %ecx,%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    15d3 <computeBWT+0x4a3>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
jmp    15e5 <computeBWT+0x4b5>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%edx
mov    %edx,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     1641 <computeBWT+0x511>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x40(%rbp),%edx
mov    %edx,-0x44(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
movslq -0x34(%rbp),%rcx
cmp    %rcx,%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
xor    %eax,%eax
cmp    -0x38(%rbp),%eax
jge    1712 <computeBWT+0x5e2>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1698 <computeBWT+0x568>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x90(%rbp)
jmp    16af <computeBWT+0x57f>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x44(%rbp),%eax
jle    1712 <computeBWT+0x5e2>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    16e7 <computeBWT+0x5b7>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
jmp    16fe <computeBWT+0x5ce>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x94(%rbp)
mov    -0x94(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x98(%rbp)
jmp    171b <computeBWT+0x5eb>
mov    -0x38(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,-0x4(%rax)
jmp    1763 <computeBWT+0x633>
cmpl   $0x0,-0x38(%rbp)
je     1758 <computeBWT+0x628>
mov    -0x38(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    175e <computeBWT+0x62e>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1763 <computeBWT+0x633>
jmp    1768 <computeBWT+0x638>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    14ef <computeBWT+0x3bf>
mov    -0x3c(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeBWT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%r15d
mov    %r8d,%r13d
mov    %rcx,%rbx
mov    %rdx,%r12
mov    %rsi,0x8(%rsp)
mov    %rdi,%rbp
mov    0x80(%rsp),%r14d
cmp    %rcx,%rdx
jne    1173 <computeBWT+0x43>
mov    %rbp,%rdi
mov    %r12,%rsi
mov    %r13d,%edx
mov    %r15d,%ecx
mov    %r14d,%r8d
call   1030 <getCounts@plt>
mov    %r12,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
xor    %ecx,%ecx
call   1050 <getBuckets@plt>
lea    -0x1(%r13),%ecx
movslq %ecx,%rax
cmp    $0x4,%r14d
mov    %rbx,0x20(%rsp)
mov    %rbp,(%rsp)
mov    %r14d,%esi
mov    %r13,%rdi
mov    %r13,0x38(%rsp)
mov    %ecx,0x1c(%rsp)
jne    11c8 <computeBWT+0x98>
movslq 0x0(%rbp,%rax,4),%r14
movslq (%rbx,%r14,4),%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,4),%r13
cmp    $0x1,%edi
jle    11fa <computeBWT+0xca>
lea    -0x2(%rdi),%eax
mov    0x0(%rbp,%rax,4),%eax
jmp    11e8 <computeBWT+0xb8>
movzbl 0x0(%rbp,%rax,1),%r14d
movslq (%rbx,%r14,4),%rax
mov    0x8(%rsp),%rdx
lea    (%rdx,%rax,4),%r13
cmp    $0x1,%edi
jle    11fa <computeBWT+0xca>
lea    -0x2(%rdi),%eax
movzbl 0x0(%rbp,%rax,1),%eax
mov    %edi,%ecx
neg    %ecx
cmp    %r14d,%eax
cmovge 0x1c(%rsp),%ecx
mov    %ecx,0x0(%r13)
jmp    1206 <computeBWT+0xd6>
mov    %ecx,0x0(%r13)
test   %edi,%edi
jle    134e <computeBWT+0x21e>
mov    %r12,0x30(%rsp)
mov    %r15d,0x2c(%rsp)
add    $0x4,%r13
mov    %edi,%eax
mov    %rax,0x10(%rsp)
xor    %r12d,%r12d
jmp    1253 <computeBWT+0x123>
mov    (%rsp),%rcx
movzbl (%rcx,%rax,1),%eax
neg    %ebp
cmp    %r15d,%eax
cmovge 0x40(%rsp),%ebp
mov    %ebp,%eax
mov    %eax,0x0(%r13)
add    $0x4,%r13
mov    0x8(%rsp),%rdx
add    $0x1,%r12
mov    %r15d,%r14d
cmp    %r12,0x10(%rsp)
je     1340 <computeBWT+0x210>
mov    (%rdx,%r12,4),%ebp
test   %ebp,%ebp
jle    1290 <computeBWT+0x160>
lea    -0x1(%rbp),%ebx
cmp    $0x4,%esi
mov    %rbx,0x40(%rsp)
jne    12a0 <computeBWT+0x170>
mov    (%rsp),%r15
mov    (%r15,%rbx,4),%eax
xor    %edi,%edi
cmp    (%r15,%rbp,4),%eax
setge  %dil
call   1040 <assert@plt>
mov    0x8(%rsp),%rdx
mov    (%r15,%rbx,4),%r15d
jmp    12c2 <computeBWT+0x192>
nopw   0x0(%rax,%rax,1)
test   %rbp,%rbp
je     129b <computeBWT+0x16b>
not    %ebp
mov    %ebp,(%rdx,%r12,4)
mov    %r14d,%r15d
jmp    1241 <computeBWT+0x111>
mov    (%rsp),%r15
movzbl (%r15,%rbx,1),%eax
xor    %edi,%edi
cmp    (%r15,%rbp,1),%al
setae  %dil
call   1040 <assert@plt>
mov    0x8(%rsp),%rdx
movzbl (%r15,%rbx,1),%r15d
mov    %r15d,%eax
not    %eax
mov    %eax,(%rdx,%r12,4)
cmp    %r14d,%r15d
jne    12e0 <computeBWT+0x1b0>
mov    %r14d,%r15d
jmp    12fe <computeBWT+0x1ce>
cs nopw 0x0(%rax,%rax,1)
nop
sub    %rdx,%r13
shr    $0x2,%r13
movslq %r14d,%rax
mov    0x20(%rsp),%rcx
mov    %r13d,(%rcx,%rax,4)
movslq %r15d,%rax
movslq (%rcx,%rax,4),%rax
lea    (%rdx,%rax,4),%r13
mov    %r13,%rax
sub    %rdx,%rax
sar    $0x2,%rax
xor    %edi,%edi
cmp    %r12,%rax
setg   %dil
call   1040 <assert@plt>
xor    %eax,%eax
cmp    $0x2,%ebp
mov    0x80(%rsp),%esi
jb     1234 <computeBWT+0x104>
lea    -0x2(%rbp),%eax
cmp    $0x4,%esi
jne    1220 <computeBWT+0xf0>
mov    (%rsp),%rcx
mov    (%rcx,%rax,4),%eax
jmp    1228 <computeBWT+0xf8>
mov    $0x1,%bl
mov    0x2c(%rsp),%r15d
mov    0x30(%rsp),%r12
jmp    1350 <computeBWT+0x220>
xor    %ebx,%ebx
mov    0x20(%rsp),%rbp
cmp    %rbp,%r12
mov    0x38(%rsp),%rdx
jne    1376 <computeBWT+0x246>
mov    (%rsp),%rdi
mov    %r12,%rsi
mov    %r15d,%ecx
mov    0x80(%rsp),%r8d
call   1030 <getCounts@plt>
mov    %r12,%rdi
mov    %rbp,%rsi
mov    %r15d,%edx
mov    $0x1,%ecx
call   1050 <getBuckets@plt>
movl   $0xffffffff,0x10(%rsp)
ff
test   %bl,%bl
mov    0x8(%rsp),%rcx
mov    0x80(%rsp),%edx
je     1501 <computeBWT+0x3d1>
mov    0x20(%rsp),%rax
movslq (%rax),%rax
lea    (%rcx,%rax,4),%r13
mov    0x1c(%rsp),%r15d
movl   $0xffffffff,0x10(%rsp)
ff
xor    %ebp,%ebp
jmp    13e6 <computeBWT+0x2b6>
not    %eax
mov    %eax,%ecx
mov    %ecx,-0x4(%r13)
add    $0xfffffffffffffffc,%r13
mov    0x8(%rsp),%rcx
lea    -0x1(%r15),%rax
mov    %r14d,%ebp
test   %r15,%r15
mov    %rax,%r15
jle    1501 <computeBWT+0x3d1>
mov    (%rcx,%r15,4),%ebx
test   %ebx,%ebx
jle    1420 <computeBWT+0x2f0>
lea    -0x1(%rbx),%r12d
cmp    $0x4,%edx
jne    1440 <computeBWT+0x310>
mov    (%rsp),%r14
mov    (%r14,%r12,4),%eax
xor    %edi,%edi
cmp    (%r14,%rbx,4),%eax
setle  %dil
call   1040 <assert@plt>
mov    (%r14,%r12,4),%r14d
jmp    145d <computeBWT+0x32d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %rbx,%rbx
je     14f1 <computeBWT+0x3c1>
not    %ebx
mov    %ebx,(%rcx,%r15,4)
jmp    14f9 <computeBWT+0x3c9>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsp),%r14
movzbl (%r14,%r12,1),%eax
xor    %edi,%edi
cmp    (%r14,%rbx,1),%al
setbe  %dil
call   1040 <assert@plt>
movzbl (%r14,%r12,1),%r14d
mov    0x8(%rsp),%rdx
mov    %r14d,(%rdx,%r15,4)
cmp    %ebp,%r14d
jne    1470 <computeBWT+0x340>
mov    %ebp,%r14d
jmp    148e <computeBWT+0x35e>
sub    %rdx,%r13
shr    $0x2,%r13
movslq %ebp,%rax
mov    0x20(%rsp),%rcx
mov    %r13d,(%rcx,%rax,4)
movslq %r14d,%rax
movslq (%rcx,%rax,4),%rax
lea    (%rdx,%rax,4),%r13
mov    %r13,%rax
sub    %rdx,%rax
sar    $0x2,%rax
xor    %edi,%edi
cmp    %r15,%rax
setle  %dil
call   1040 <assert@plt>
xor    %ecx,%ecx
cmp    $0x2,%ebx
mov    0x80(%rsp),%edx
jb     13c6 <computeBWT+0x296>
add    $0xfffffffe,%ebx
cmp    $0x4,%edx
jne    14d8 <computeBWT+0x3a8>
mov    (%rsp),%rax
mov    (%rax,%rbx,4),%eax
mov    %r12d,%ecx
cmp    %r14d,%eax
jg     13c2 <computeBWT+0x292>
jmp    13c6 <computeBWT+0x296>
mov    (%rsp),%rax
movzbl (%rax,%rbx,1),%eax
mov    %r12d,%ecx
cmp    %eax,%r14d
jl     13c2 <computeBWT+0x292>
jmp    13c6 <computeBWT+0x296>
mov    %r15d,%eax
mov    %r15d,0x10(%rsp)
mov    %ebp,%r14d
jmp    13d3 <computeBWT+0x2a3>
mov    0x10(%rsp),%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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