#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*/ getBuckets(int *, int *, int, int);
int /*<<< orphan*/ getCounts(unsigned char const *, int *, int, int, int);
int computeBWT(const unsigned char *T, int *SA, int *C, int *B, int n, int k,
               int cs) {
  int *b, i, j, pidx = -1;
  int 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(int) ? ((const int *)T)[j]
                                     : ((const unsigned char *)T)[j])];
  *b++ = ((0 < j) &&
          ((cs == sizeof(int) ? ((const int *)T)[j - 1]
                              : ((const unsigned char *)T)[j - 1]) < c1))
             ? ~j
             : j;
  for (i = 0; i < n; ++i) {
    if (0 < (j = SA[i])) {
      --j;
      SA[i] = ~(c0 = (cs == sizeof(int) ? ((const int *)T)[j]
                                        : ((const unsigned char *)T)[j]));
      if (c0 != c1) {
        B[c1] = b - SA;
        b = SA + B[c1 = c0];
      }
      *b++ = ((0 < j) &&
              ((cs == sizeof(int) ? ((const int *)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;
      SA[i] = (c0 = (cs == sizeof(int) ? ((const int *)T)[j]
                                       : ((const unsigned char *)T)[j]));
      if (c0 != c1) {
        B[c1] = b - SA;
        b = SA + B[c1 = c0];
      }
      *--b =
          ((0 < j) &&
           ((cs == sizeof(int) ? ((const int *)T)[j - 1]
                               : ((const unsigned char *)T)[j - 1]) > c1))
              ? ~((int)(cs == sizeof(int) ? ((const int *)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    $0x80,%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    1172 <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   1040 <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    11be <computeBWT+0x9e>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
jmp    11cd <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    124c <computeBWT+0x12c>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    121e <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    1232 <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    124c <computeBWT+0x12c>
mov    -0x38(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x64(%rbp)
jmp    1252 <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    13d7 <computeBWT+0x2b7>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x38(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jge    13a4 <computeBWT+0x284>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    12bb <computeBWT+0x19b>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    12ca <computeBWT+0x1aa>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%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     1326 <computeBWT+0x206>
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)
xor    %eax,%eax
cmp    -0x38(%rbp),%eax
jge    1385 <computeBWT+0x265>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1357 <computeBWT+0x237>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
jmp    136b <computeBWT+0x24b>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1385 <computeBWT+0x265>
mov    -0x38(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x70(%rbp)
jmp    138b <computeBWT+0x26b>
mov    -0x38(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
jmp    13c4 <computeBWT+0x2a4>
cmpl   $0x0,-0x38(%rbp)
je     13bf <computeBWT+0x29f>
mov    -0x38(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13c4 <computeBWT+0x2a4>
jmp    13c9 <computeBWT+0x2a9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126d <computeBWT+0x14d>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    13fc <computeBWT+0x2dc>
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   1040 <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     15e3 <computeBWT+0x4c3>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x38(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jge    15a5 <computeBWT+0x485>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1484 <computeBWT+0x364>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
jmp    1493 <computeBWT+0x373>
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)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
je     14ec <computeBWT+0x3cc>
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)
xor    %eax,%eax
cmp    -0x38(%rbp),%eax
jge    1585 <computeBWT+0x465>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    151d <computeBWT+0x3fd>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
jmp    1531 <computeBWT+0x411>
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
jle    1585 <computeBWT+0x465>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1563 <computeBWT+0x443>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
jmp    1577 <computeBWT+0x457>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x80(%rbp)
jmp    158b <computeBWT+0x46b>
mov    -0x38(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,-0x4(%rax)
jmp    15d0 <computeBWT+0x4b0>
cmpl   $0x0,-0x38(%rbp)
je     15c5 <computeBWT+0x4a5>
mov    -0x38(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    15cb <computeBWT+0x4ab>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    15d0 <computeBWT+0x4b0>
jmp    15d5 <computeBWT+0x4b5>
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1437 <computeBWT+0x317>
mov    -0x3c(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeBWT>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %r8d,%ebx
mov    %rcx,%r14
mov    %rsi,%r12
mov    %rdi,%r15
mov    0x50(%rsp),%r13d
cmp    %rcx,%rdx
mov    %r9d,0x4(%rsp)
mov    %rdx,0x8(%rsp)
jne    116b <computeBWT+0x4b>
mov    %r15,%rdi
mov    %rdx,%rsi
mov    %ebx,%edx
mov    %r9d,%ecx
mov    %r13d,%r8d
call   1030 <getCounts@plt>
mov    0x8(%rsp),%rdx
mov    0x4(%rsp),%r9d
mov    %rdx,%rdi
mov    %r14,%rsi
mov    %r9d,%edx
xor    %ecx,%ecx
call   1040 <getBuckets@plt>
lea    -0x1(%rbx),%ebp
movslq %ebp,%rax
cmp    $0x4,%r13d
mov    %rbx,%rdx
mov    %ebp,0x14(%rsp)
jne    11a8 <computeBWT+0x88>
movslq (%r15,%rax,4),%rcx
movslq (%r14,%rcx,4),%rax
lea    (%r12,%rax,4),%rax
cmp    $0x1,%edx
jle    11d9 <computeBWT+0xb9>
lea    -0x2(%rdx),%esi
mov    (%r15,%rsi,4),%edi
jmp    11c2 <computeBWT+0xa2>
movzbl (%r15,%rax,1),%ecx
movslq (%r14,%rcx,4),%rax
lea    (%r12,%rax,4),%rax
cmp    $0x1,%edx
jle    11d9 <computeBWT+0xb9>
lea    -0x2(%rdx),%esi
movzbl (%r15,%rsi,1),%edi
mov    0x4(%rsp),%r9d
mov    0x8(%rsp),%r10
mov    %edx,%esi
neg    %esi
cmp    %ecx,%edi
cmovge %ebp,%esi
mov    %esi,(%rax)
jmp    11ed <computeBWT+0xcd>
mov    0x4(%rsp),%r9d
mov    0x8(%rsp),%r10
mov    %ebp,(%rax)
test   %edx,%edx
jle    13cc <computeBWT+0x2ac>
add    $0x4,%rax
mov    %edx,%r8d
xor    %esi,%esi
jmp    1218 <computeBWT+0xf8>
movzbl (%r15,%rcx,1),%ecx
neg    %edi
cmp    %ebx,%ecx
cmovge %r11d,%edi
mov    %edi,%ecx
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0x1,%rsi
mov    %ebx,%ecx
cmp    %rsi,%r8
je     1296 <computeBWT+0x176>
mov    (%r12,%rsi,4),%edi
test   %edi,%edi
jle    1230 <computeBWT+0x110>
lea    -0x1(%rdi),%r11d
cmp    $0x4,%r13d
jne    1240 <computeBWT+0x120>
mov    (%r15,%r11,4),%ebx
jmp    1245 <computeBWT+0x125>
je     1238 <computeBWT+0x118>
not    %edi
mov    %edi,(%r12,%rsi,4)
mov    %ecx,%ebx
jmp    120d <computeBWT+0xed>
nopl   0x0(%rax)
movzbl (%r15,%r11,1),%ebx
mov    %ebx,%ebp
not    %ebp
mov    %ebp,(%r12,%rsi,4)
cmp    %ecx,%ebx
jne    1260 <computeBWT+0x140>
mov    %ecx,%ebx
jmp    1279 <computeBWT+0x159>
cs nopw 0x0(%rax,%rax,1)
nop
sub    %r12,%rax
shr    $0x2,%rax
movslq %ecx,%rcx
mov    %eax,(%r14,%rcx,4)
movslq %ebx,%rax
movslq (%r14,%rax,4),%rax
lea    (%r12,%rax,4),%rax
xor    %ecx,%ecx
cmp    $0x2,%edi
jb     1207 <computeBWT+0xe7>
lea    -0x2(%rdi),%ecx
cmp    $0x4,%r13d
jne    11f8 <computeBWT+0xd8>
mov    (%r15,%rcx,4),%ecx
jmp    11fd <computeBWT+0xdd>
mov    $0x1,%bpl
cmp    %r14,%r10
jne    12b9 <computeBWT+0x199>
mov    %r15,%rdi
mov    %r10,%rsi
mov    %r9d,%ecx
mov    %r13d,%r8d
call   1030 <getCounts@plt>
mov    0x8(%rsp),%r10
mov    0x4(%rsp),%r9d
mov    %r10,%rdi
mov    %r14,%rsi
mov    %r9d,%edx
mov    $0x1,%ecx
call   1040 <getBuckets@plt>
mov    $0xffffffff,%eax
test   %bpl,%bpl
je     13bd <computeBWT+0x29d>
movslq (%r14),%rax
lea    (%r12,%rax,4),%rdx
mov    0x14(%rsp),%ecx
mov    $0xffffffff,%eax
xor    %esi,%esi
jmp    130b <computeBWT+0x1eb>
not    %edi
mov    %edi,%esi
mov    %esi,-0x4(%rdx)
add    $0xfffffffffffffffc,%rdx
lea    -0x1(%rcx),%rdi
mov    %ebp,%esi
test   %rcx,%rcx
mov    %rdi,%rcx
jle    13bd <computeBWT+0x29d>
mov    (%r12,%rcx,4),%edi
test   %edi,%edi
jle    1330 <computeBWT+0x210>
lea    -0x1(%rdi),%ebx
cmp    $0x4,%r13d
jne    1340 <computeBWT+0x220>
mov    (%r15,%rbx,4),%ebp
jmp    1345 <computeBWT+0x225>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
je     13b4 <computeBWT+0x294>
not    %edi
mov    %edi,(%r12,%rcx,4)
jmp    13b6 <computeBWT+0x296>
xchg   %ax,%ax
movzbl (%r15,%rbx,1),%ebp
mov    %ebp,(%r12,%rcx,4)
cmp    %esi,%ebp
jne    1360 <computeBWT+0x240>
mov    %esi,%ebp
jmp    1379 <computeBWT+0x259>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
sub    %r12,%rdx
shr    $0x2,%rdx
movslq %esi,%rsi
mov    %edx,(%r14,%rsi,4)
movslq %ebp,%rdx
movslq (%r14,%rdx,4),%rdx
lea    (%r12,%rdx,4),%rdx
xor    %esi,%esi
cmp    $0x2,%edi
jb     12f2 <computeBWT+0x1d2>
add    $0xfffffffe,%edi
cmp    $0x4,%r13d
jne    13a0 <computeBWT+0x280>
mov    (%r15,%rdi,4),%edi
mov    %ebx,%esi
cmp    %ebp,%edi
jg     12ee <computeBWT+0x1ce>
jmp    12f2 <computeBWT+0x1d2>
movzbl (%r15,%rdi,1),%edi
mov    %ebx,%esi
cmp    %edi,%ebp
jl     12ee <computeBWT+0x1ce>
jmp    12f2 <computeBWT+0x1d2>
mov    %ecx,%eax
mov    %esi,%ebp
jmp    12f9 <computeBWT+0x1d9>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
cmp    %r14,%r10
jne    12b9 <computeBWT+0x199>
jmp    129e <computeBWT+0x17e>

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 = %208, %95
%100 = load i32, i32* %16
%101 = load i32, i32* %12
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %211
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 %196
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 ]
store i32 %131, i32* %19
%132 = xor i32 %131, -1
%133 = load i32*, i32** %9
%134 = load i32, i32* %16
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %133, i64 %135
store i32 %132, i32* %136
%137 = load i32, i32* %19
%138 = load i32, i32* %20
%139 = icmp ne i32 %137, %138
br i1 %139, label %140, label %160
140: ; preds = %130
%141 = load i32*, i32** %15
%142 = load i32*, i32** %9
%143 = ptrtoint i32* %141 to i64
%144 = ptrtoint i32* %142 to i64
%145 = sub i64 %143, %144
%146 = sdiv exact i64 %145, 4
%147 = trunc i64 %146 to i32
%148 = load i32*, i32** %11
%149 = load i32, i32* %20
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %148, i64 %150
store i32 %147, i32* %151
%152 = load i32*, i32** %9
%153 = load i32*, i32** %11
%154 = load i32, i32* %19
store i32 %154, i32* %20
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %153, i64 %155
%157 = load i32, i32* %156
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %152, i64 %158
store i32* %159, i32** %15
br label %160
160: ; preds = %140, %130
%161 = load i32, i32* %17
%162 = icmp slt i32 0, %161
br i1 %162, label %163, label %190
163: ; preds = %160
%164 = load i32, i32* %14
%165 = sext i32 %164 to i64
%166 = icmp eq i64 %165, 4
br i1 %166, label %167, label %175
167: ; preds = %163
%168 = load i8*, i8** %8
%169 = bitcast i8* %168 to i32*
%170 = load i32, i32* %17
%171 = sub nsw i32 %170, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %169, i64 %172
%174 = load i32, i32* %173
br label %183
175: ; preds = %163
%176 = load i8*, i8** %8
%177 = load i32, i32* %17
%178 = sub nsw i32 %177, 1
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i8, i8* %176, i64 %179
%181 = load i8, i8* %180
%182 = zext i8 %181 to i32
br label %183
183: ; preds = %175, %167
%184 = phi i32 [ %174, %167 ], [ %182, %175 ]
%185 = load i32, i32* %20
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %190
187: ; preds = %183
%188 = load i32, i32* %17
%189 = xor i32 %188, -1
br label %192
190: ; preds = %183, %160
%191 = load i32, i32* %17
br label %192
192: ; preds = %190, %187
%193 = phi i32 [ %189, %187 ], [ %191, %190 ]
%194 = load i32*, i32** %15
%195 = getelementptr inbounds i32, i32* %194, i32 1
store i32* %195, i32** %15
store i32 %193, i32* %194
br label %207
196: ; preds = %103
%197 = load i32, i32* %17
%198 = icmp ne i32 %197, 0
br i1 %198, label %199, label %206
199: ; preds = %196
%200 = load i32, i32* %17
%201 = xor i32 %200, -1
%202 = load i32*, i32** %9
%203 = load i32, i32* %16
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32, i32* %202, i64 %204
store i32 %201, i32* %205
br label %206
206: ; preds = %199, %196
br label %207
207: ; preds = %206, %192
br label %208
208: ; preds = %207
%209 = load i32, i32* %16
%210 = add nsw i32 %209, 1
store i32 %210, i32* %16
br label %99
211: ; preds = %99
%212 = load i32*, i32** %10
%213 = load i32*, i32** %11
%214 = icmp eq i32* %212, %213
br i1 %214, label %215, label %222
215: ; preds = %211
%216 = load i8*, i8** %8
%217 = load i32*, i32** %10
%218 = load i32, i32* %12
%219 = load i32, i32* %13
%220 = load i32, i32* %14
%221 = call i32 @getCounts(i8* %216, i32* %217, i32 %218, i32 %219, i32 %220)
br label %222
222: ; preds = %215, %211
%223 = load i32*, i32** %10
%224 = load i32*, i32** %11
%225 = load i32, i32* %13
%226 = call i32 @getBuckets(i32* %223, i32* %224, i32 %225, i32 1)
%227 = load i32, i32* %12
%228 = sub nsw i32 %227, 1
store i32 %228, i32* %16
%229 = load i32*, i32** %9
%230 = load i32*, i32** %11
store i32 0, i32* %20
%231 = getelementptr inbounds i32, i32* %230, i64 0
%232 = load i32, i32* %231
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i32, i32* %229, i64 %233
store i32* %234, i32** %15
br label %235
235: ; preds = %364, %222
%236 = load i32, i32* %16
%237 = icmp sle i32 0, %236
br i1 %237, label %238, label %367
238: ; preds = %235
%239 = load i32*, i32** %9
%240 = load i32, i32* %16
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %239, i64 %241
%243 = load i32, i32* %242
store i32 %243, i32* %17
%244 = icmp slt i32 0, %243
br i1 %244, label %245, label %350
245: ; preds = %238
%246 = load i32, i32* %17
%247 = add nsw i32 %246, -1
store i32 %247, i32* %17
%248 = load i32, i32* %14
%249 = sext i32 %248 to i64
%250 = icmp eq i64 %249, 4
br i1 %250, label %251, label %258
251: ; preds = %245
%252 = load i8*, i8** %8
%253 = bitcast i8* %252 to i32*
%254 = load i32, i32* %17
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds i32, i32* %253, i64 %255
%257 = load i32, i32* %256
br label %265
258: ; preds = %245
%259 = load i8*, i8** %8
%260 = load i32, i32* %17
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i8, i8* %259, i64 %261
%263 = load i8, i8* %262
%264 = zext i8 %263 to i32
br label %265
265: ; preds = %258, %251
%266 = phi i32 [ %257, %251 ], [ %264, %258 ]
store i32 %266, i32* %19
%267 = load i32*, i32** %9
%268 = load i32, i32* %16
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds i32, i32* %267, i64 %269
store i32 %266, i32* %270
%271 = load i32, i32* %19
%272 = load i32, i32* %20
%273 = icmp ne i32 %271, %272
br i1 %273, label %274, label %294
274: ; preds = %265
%275 = load i32*, i32** %15
%276 = load i32*, i32** %9
%277 = ptrtoint i32* %275 to i64
%278 = ptrtoint i32* %276 to i64
%279 = sub i64 %277, %278
%280 = sdiv exact i64 %279, 4
%281 = trunc i64 %280 to i32
%282 = load i32*, i32** %11
%283 = load i32, i32* %20
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds i32, i32* %282, i64 %284
store i32 %281, i32* %285
%286 = load i32*, i32** %9
%287 = load i32*, i32** %11
%288 = load i32, i32* %19
store i32 %288, i32* %20
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i32, i32* %287, i64 %289
%291 = load i32, i32* %290
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %286, i64 %292
store i32* %293, i32** %15
br label %294
294: ; preds = %274, %265
%295 = load i32, i32* %17
%296 = icmp slt i32 0, %295
br i1 %296, label %297, label %344
297: ; preds = %294
%298 = load i32, i32* %14
%299 = sext i32 %298 to i64
%300 = icmp eq i64 %299, 4
br i1 %300, label %301, label %309
301: ; preds = %297
%302 = load i8*, i8** %8
%303 = bitcast i8* %302 to i32*
%304 = load i32, i32* %17
%305 = sub nsw i32 %304, 1
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds i32, i32* %303, i64 %306
%308 = load i32, i32* %307
br label %317
309: ; preds = %297
%310 = load i8*, i8** %8
%311 = load i32, i32* %17
%312 = sub nsw i32 %311, 1
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i8, i8* %310, i64 %313
%315 = load i8, i8* %314
%316 = zext i8 %315 to i32
br label %317
317: ; preds = %309, %301
%318 = phi i32 [ %308, %301 ], [ %316, %309 ]
%319 = load i32, i32* %20
%320 = icmp sgt i32 %318, %319
br i1 %320, label %321, label %344
321: ; preds = %317
%322 = load i32, i32* %14
%323 = sext i32 %322 to i64
%324 = icmp eq i64 %323, 4
br i1 %324, label %325, label %333
325: ; preds = %321
%326 = load i8*, i8** %8
%327 = bitcast i8* %326 to i32*
%328 = load i32, i32* %17
%329 = sub nsw i32 %328, 1
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds i32, i32* %327, i64 %330
%332 = load i32, i32* %331
br label %341
333: ; preds = %321
%334 = load i8*, i8** %8
%335 = load i32, i32* %17
%336 = sub nsw i32 %335, 1
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i8, i8* %334, i64 %337
%339 = load i8, i8* %338
%340 = zext i8 %339 to i32
br label %341
341: ; preds = %333, %325
%342 = phi i32 [ %332, %325 ], [ %340, %333 ]
%343 = xor i32 %342, -1
br label %346
344: ; preds = %317, %294
%345 = load i32, i32* %17
br label %346
346: ; preds = %344, %341
%347 = phi i32 [ %343, %341 ], [ %345, %344 ]
%348 = load i32*, i32** %15
%349 = getelementptr inbounds i32, i32* %348, i32 -1
store i32* %349, i32** %15
store i32 %347, i32* %349
br label %363
350: ; preds = %238
%351 = load i32, i32* %17
%352 = icmp ne i32 %351, 0
br i1 %352, label %353, label %360
353: ; preds = %350
%354 = load i32, i32* %17
%355 = xor i32 %354, -1
%356 = load i32*, i32** %9
%357 = load i32, i32* %16
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds i32, i32* %356, i64 %358
store i32 %355, i32* %359
br label %362
360: ; preds = %350
%361 = load i32, i32* %16
store i32 %361, i32* %18
br label %362
362: ; preds = %360, %353
br label %363
363: ; preds = %362, %346
br label %364
364: ; preds = %363
%365 = load i32, i32* %16
%366 = add nsw i32 %365, -1
store i32 %366, i32* %16
br label %235
367: ; preds = %235
%368 = load i32, i32* %18
ret i32 %368
}

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 %130
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, %125
%67 = phi i64 [ 0, %59 ], [ %128, %125 ]
%68 = phi i32 [ %60, %59 ], [ %127, %125 ]
%69 = phi i32* [ %62, %59 ], [ %126, %125 ]
%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 %121
73: ; preds = %66
%74 = add nsw i32 %71, -1
%75 = zext i32 %74 to i64
br i1 %14, label %76, label %79
76: ; preds = %73
%77 = getelementptr inbounds i32, i32* %63, i64 %75
%78 = load i32, i32* %77
br label %83
79: ; preds = %73
%80 = getelementptr inbounds i8, i8* %0, i64 %75
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
br label %83
83: ; preds = %79, %76
%84 = phi i32 [ %78, %76 ], [ %82, %79 ]
%85 = xor i32 %84, -1
store i32 %85, i32* %70
%86 = icmp eq i32 %84, %68
br i1 %86, label %99, label %87
87: ; preds = %83
%88 = ptrtoint i32* %69 to i64
%89 = sub i64 %88, %64
%90 = lshr exact i64 %89, 2
%91 = trunc i64 %90 to i32
%92 = sext i32 %68 to i64
%93 = getelementptr inbounds i32, i32* %3, i64 %92
store i32 %91, i32* %93
%94 = sext i32 %84 to i64
%95 = getelementptr inbounds i32, i32* %3, i64 %94
%96 = load i32, i32* %95
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %1, i64 %97
br label %99
99: ; preds = %87, %83
%100 = phi i32* [ %98, %87 ], [ %69, %83 ]
%101 = phi i32 [ %84, %87 ], [ %68, %83 ]
%102 = icmp ugt i32 %71, 1
br i1 %102, label %103, label %118
103: ; preds = %99
%104 = add nsw i32 %71, -2
%105 = zext i32 %104 to i64
br i1 %14, label %106, label %109
106: ; preds = %103
%107 = getelementptr inbounds i32, i32* %63, i64 %105
%108 = load i32, i32* %107
br label %113
109: ; preds = %103
%110 = getelementptr inbounds i8, i8* %0, i64 %105
%111 = load i8, i8* %110
%112 = zext i8 %111 to i32
br label %113
113: ; preds = %109, %106
%114 = phi i32 [ %108, %106 ], [ %112, %109 ]
%115 = icmp slt i32 %114, %101
%116 = sub nsw i32 0, %71
%117 = select i1 %115, i32 %116, i32 %74
br label %118
118: ; preds = %113, %99
%119 = phi i32 [ 0, %99 ], [ %117, %113 ]
%120 = getelementptr inbounds i32, i32* %100, i64 1
store i32 %119, i32* %100
br label %125
121: ; preds = %66
%122 = icmp eq i32 %71, 0
br i1 %122, label %125, label %123
123: ; preds = %121
%124 = xor i32 %71, -1
store i32 %124, i32* %70
br label %125
125: ; preds = %118, %123, %121
%126 = phi i32* [ %120, %118 ], [ %69, %123 ], [ %69, %121 ]
%127 = phi i32 [ %101, %118 ], [ %68, %123 ], [ %68, %121 ]
%128 = add nuw nsw i64 %67, 1
%129 = icmp eq i64 %128, %65
br i1 %129, label %130, label %66
130: ; preds = %125, %55
%131 = phi i1 [ false, %55 ], [ true, %125 ]
br i1 %8, label %132, label %134
132: ; preds = %130
%133 = tail call i32 @getCounts(i8* %0, i32* %2, i32 %4, i32 %5, i32 %6)
br label %134
134: ; preds = %132, %130
%135 = tail call i32 @getBuckets(i32* %2, i32* %3, i32 %5, i32 1)
br i1 %131, label %136, label %209
136: ; preds = %134
%137 = load i32, i32* %3
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i32, i32* %1, i64 %138
%140 = bitcast i8* %0 to i32*
%141 = ptrtoint i32* %1 to i64
%142 = zext i32 %13 to i64
br label %143
143: ; preds = %136, %203
%144 = phi i64 [ %142, %136 ], [ %207, %203 ]
%145 = phi i32 [ 0, %136 ], [ %206, %203 ]
%146 = phi i32 [ -1, %136 ], [ %205, %203 ]
%147 = phi i32* [ %139, %136 ], [ %204, %203 ]
%148 = getelementptr inbounds i32, i32* %1, i64 %144
%149 = load i32, i32* %148
%150 = icmp sgt i32 %149, 0
br i1 %150, label %151, label %198
151: ; preds = %143
%152 = add nsw i32 %149, -1
%153 = zext i32 %152 to i64
br i1 %14, label %154, label %157
154: ; preds = %151
%155 = getelementptr inbounds i32, i32* %140, i64 %153
%156 = load i32, i32* %155
br label %161
157: ; preds = %151
%158 = getelementptr inbounds i8, i8* %0, i64 %153
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
br label %161
161: ; preds = %157, %154
%162 = phi i32 [ %156, %154 ], [ %160, %157 ]
store i32 %162, i32* %148
%163 = icmp eq i32 %162, %145
br i1 %163, label %176, label %164
164: ; preds = %161
%165 = ptrtoint i32* %147 to i64
%166 = sub i64 %165, %141
%167 = lshr exact i64 %166, 2
%168 = trunc i64 %167 to i32
%169 = sext i32 %145 to i64
%170 = getelementptr inbounds i32, i32* %3, i64 %169
store i32 %168, i32* %170
%171 = sext i32 %162 to i64
%172 = getelementptr inbounds i32, i32* %3, i64 %171
%173 = load i32, i32* %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %1, i64 %174
br label %176
176: ; preds = %164, %161
%177 = phi i32* [ %175, %164 ], [ %147, %161 ]
%178 = phi i32 [ %162, %164 ], [ %145, %161 ]
%179 = icmp ugt i32 %149, 1
br i1 %179, label %180, label %195
180: ; preds = %176
%181 = add nsw i32 %149, -2
%182 = zext i32 %181 to i64
br i1 %14, label %183, label %187
183: ; preds = %180
%184 = getelementptr inbounds i32, i32* %140, i64 %182
%185 = load i32, i32* %184
%186 = icmp sgt i32 %185, %178
br i1 %186, label %192, label %195
187: ; preds = %180
%188 = getelementptr inbounds i8, i8* %0, i64 %182
%189 = load i8, i8* %188
%190 = zext i8 %189 to i32
%191 = icmp slt i32 %178, %190
br i1 %191, label %192, label %195
192: ; preds = %187, %183
%193 = phi i32 [ %185, %183 ], [ %190, %187 ]
%194 = xor i32 %193, -1
br label %195
195: ; preds = %187, %176, %183, %192
%196 = phi i32 [ %194, %192 ], [ %152, %183 ], [ 0, %176 ], [ %152, %187 ]
%197 = getelementptr inbounds i32, i32* %177, i64 -1
store i32 %196, i32* %197
br label %203
198: ; preds = %143
%199 = icmp eq i32 %149, 0
%200 = trunc i64 %144 to i32
br i1 %199, label %203, label %201
201: ; preds = %198
%202 = xor i32 %149, -1
store i32 %202, i32* %148
br label %203
203: ; preds = %198, %195, %201
%204 = phi i32* [ %197, %195 ], [ %147, %201 ], [ %147, %198 ]
%205 = phi i32 [ %146, %195 ], [ %146, %201 ], [ %200, %198 ]
%206 = phi i32 [ %178, %195 ], [ %145, %201 ], [ %145, %198 ]
%207 = add nsw i64 %144, -1
%208 = icmp sgt i64 %144, 0
br i1 %208, label %143, label %209
209: ; preds = %203, %134
%210 = phi i32 [ -1, %134 ], [ %205, %203 ]
ret i32 %210
}