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


x86 assembly (clang, -O0):
<induceSA>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    117b <induceSA+0x4b>
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,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x48(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    11bf <induceSA+0x8f>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
jmp    11ce <induceSA+0x9e>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x4c(%rbp),%ecx
mov    %ecx,-0x3c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
xor    %eax,%eax
cmp    -0x30(%rbp),%eax
jge    1240 <induceSA+0x110>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1212 <induceSA+0xe2>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
jmp    1226 <induceSA+0xf6>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1240 <induceSA+0x110>
mov    -0x30(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    1246 <induceSA+0x116>
mov    -0x30(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    142b <induceSA+0x2fb>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
xor    %eax,%eax
cmp    -0x30(%rbp),%eax
jge    1418 <induceSA+0x2e8>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    12c5 <induceSA+0x195>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
jmp    12d4 <induceSA+0x1a4>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x5c(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1300 <induceSA+0x1d0>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    1314 <induceSA+0x1e4>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x60(%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    134a <induceSA+0x21a>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
jmp    1359 <induceSA+0x229>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmp    -0x3c(%rbp),%eax
je     1389 <induceSA+0x259>
mov    -0x34(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,-0x3c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
xor    %eax,%eax
cmp    -0x30(%rbp),%eax
jge    13fb <induceSA+0x2cb>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    13cd <induceSA+0x29d>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    13e1 <induceSA+0x2b1>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    13fb <induceSA+0x2cb>
mov    -0x30(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
jmp    1401 <induceSA+0x2d1>
mov    -0x30(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    141d <induceSA+0x2ed>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1265 <induceSA+0x135>
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1450 <induceSA+0x320>
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,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movl   $0x0,-0x3c(%rbp)
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
xor    %eax,%eax
cmp    -0x2c(%rbp),%eax
jg     164e <induceSA+0x51e>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x30(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jge    162a <induceSA+0x4fa>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    14cb <induceSA+0x39b>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
jmp    14da <induceSA+0x3aa>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x74(%rbp)
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    1506 <induceSA+0x3d6>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
jmp    151a <induceSA+0x3ea>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x78(%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    1550 <induceSA+0x420>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
jmp    155f <induceSA+0x42f>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x38(%rbp)
cmp    -0x3c(%rbp),%eax
je     158f <induceSA+0x45f>
mov    -0x34(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,-0x3c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
cmpl   $0x0,-0x30(%rbp)
je     15f2 <induceSA+0x4c2>
movslq 0x10(%rbp),%rax
cmp    $0x4,%rax
jne    15d2 <induceSA+0x4a2>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
jmp    15e6 <induceSA+0x4b6>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1603 <induceSA+0x4d3>
mov    -0x30(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x84(%rbp)
jmp    160c <induceSA+0x4dc>
mov    -0x30(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x34(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    163b <induceSA+0x50b>
mov    -0x30(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1640 <induceSA+0x510>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    147e <induceSA+0x34e>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<induceSA>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9d,%r14d
mov    %r8d,%r13d
mov    %rcx,%rbp
mov    %rdx,%rbx
mov    %rsi,0x8(%rsp)
mov    %rdi,%r15
mov    0x80(%rsp),%r12d
cmp    %rcx,%rdx
jne    1173 <induceSA+0x43>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r13d,%edx
mov    %r14d,%ecx
mov    %r12d,%r8d
call   1030 <getCounts@plt>
mov    %rbx,0x38(%rsp)
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r14d,%edx
xor    %ecx,%ecx
call   1050 <getBuckets@plt>
lea    -0x1(%r13),%eax
mov    %eax,0x14(%rsp)
cltq
cmp    $0x4,%r12d
mov    %rbp,0x20(%rsp)
mov    %r15,0x18(%rsp)
mov    %r12d,%esi
mov    %r13,%rcx
mov    %r13,0x30(%rsp)
jne    11c4 <induceSA+0x94>
movslq (%r15,%rax,4),%r12
mov    0x0(%rbp,%r12,4),%r13d
cmp    $0x1,%ecx
jle    11f5 <induceSA+0xc5>
lea    -0x2(%rcx),%eax
mov    (%r15,%rax,4),%eax
jmp    11db <induceSA+0xab>
movzbl (%r15,%rax,1),%r12d
mov    0x0(%rbp,%r12,4),%r13d
cmp    $0x1,%ecx
jle    11f5 <induceSA+0xc5>
lea    -0x2(%rcx),%eax
movzbl (%r15,%rax,1),%eax
mov    %rcx,%rdi
mov    0x8(%rsp),%rdx
neg    %ecx
cmp    %r12d,%eax
cmovge 0x14(%rsp),%ecx
movslq %r13d,%rax
mov    %ecx,(%rdx,%rax,4)
jmp    120f <induceSA+0xdf>
mov    %rcx,%rdi
mov    0x8(%rsp),%rdx
movslq %r13d,%rax
mov    0x14(%rsp),%ecx
mov    %ecx,(%rdx,%rax,4)
test   %edi,%edi
jle    1311 <induceSA+0x1e1>
mov    %r14d,0x2c(%rsp)
add    $0x1,%r13d
mov    %edi,%eax
mov    %rax,0x40(%rsp)
xor    %r14d,%r14d
jmp    1256 <induceSA+0x126>
mov    0x18(%rsp),%rcx
movzbl (%rcx,%rax,1),%eax
neg    %ebx
cmp    %r15d,%eax
cmovge %ebp,%ebx
mov    %ebx,%eax
mov    %eax,(%rdx,%r13,4)
add    $0x1,%r13d
mov    %r15d,%r12d
mov    0x18(%rsp),%r15
add    $0x1,%r14
cmp    %r14,0x40(%rsp)
je     1302 <induceSA+0x1d2>
mov    (%rdx,%r14,4),%ebx
mov    %ebx,%eax
not    %eax
mov    %eax,(%rdx,%r14,4)
test   %ebx,%ebx
jle    1247 <induceSA+0x117>
lea    -0x1(%rbx),%ebp
cmp    $0x4,%esi
jne    12a0 <induceSA+0x170>
mov    (%r15,%rbp,4),%eax
xor    %edi,%edi
cmp    (%r15,%rbx,4),%eax
setge  %dil
call   1040 <assert@plt>
mov    (%r15,%rbp,4),%r15d
cmp    %r12d,%r15d
je     12be <induceSA+0x18e>
movslq %r12d,%rax
mov    0x20(%rsp),%rcx
mov    %r13d,(%rcx,%rax,4)
movslq %r15d,%rax
mov    (%rcx,%rax,4),%r13d
jmp    12c1 <induceSA+0x191>
nop
movzbl (%r15,%rbp,1),%eax
xor    %edi,%edi
cmp    (%r15,%rbx,1),%al
setae  %dil
call   1040 <assert@plt>
movzbl (%r15,%rbp,1),%r15d
cmp    %r12d,%r15d
jne    128a <induceSA+0x15a>
mov    %r12d,%r15d
movslq %r13d,%r13
xor    %edi,%edi
cmp    %r13,%r14
setl   %dil
call   1040 <assert@plt>
xor    %eax,%eax
cmp    $0x2,%ebx
mov    0x8(%rsp),%rdx
mov    0x80(%rsp),%esi
jb     1237 <induceSA+0x107>
lea    -0x2(%rbx),%eax
cmp    $0x4,%esi
jne    1224 <induceSA+0xf4>
mov    0x18(%rsp),%rcx
mov    (%rcx,%rax,4),%eax
jmp    122d <induceSA+0xfd>
mov    $0x1,%r12b
mov    0x20(%rsp),%rbp
mov    0x2c(%rsp),%r14d
jmp    1314 <induceSA+0x1e4>
xor    %r12d,%r12d
mov    0x38(%rsp),%rbx
cmp    %rbp,%rbx
mov    0x30(%rsp),%rdx
jne    1339 <induceSA+0x209>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r14d,%ecx
mov    0x80(%rsp),%r8d
call   1030 <getCounts@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r14d,%edx
mov    $0x1,%ecx
call   1050 <getBuckets@plt>
test   %r12b,%r12b
mov    0x8(%rsp),%rcx
mov    0x80(%rsp),%esi
je     1463 <induceSA+0x333>
mov    0x20(%rsp),%rax
mov    (%rax),%r14d
mov    0x14(%rsp),%ebp
xor    %r13d,%r13d
jmp    1395 <induceSA+0x265>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
not    %ebx
mov    %ebx,(%rcx,%rbp,4)
lea    -0x1(%rbp),%rax
test   %rbp,%rbp
mov    %rax,%rbp
jle    1463 <induceSA+0x333>
mov    (%rcx,%rbp,4),%ebx
test   %ebx,%ebx
jle    1380 <induceSA+0x250>
lea    -0x1(%rbx),%r12d
cmp    $0x4,%esi
jne    13e0 <induceSA+0x2b0>
mov    (%r15,%r12,4),%eax
xor    %edi,%edi
cmp    (%r15,%rbx,4),%eax
setle  %dil
call   1040 <assert@plt>
mov    (%r15,%r12,4),%r15d
cmp    %r13d,%r15d
je     13fe <induceSA+0x2ce>
movslq %r13d,%rax
mov    0x20(%rsp),%rcx
mov    %r14d,(%rcx,%rax,4)
movslq %r15d,%rax
mov    (%rcx,%rax,4),%r14d
jmp    1401 <induceSA+0x2d1>
cs nopw 0x0(%rax,%rax,1)
movzbl (%r15,%r12,1),%eax
xor    %edi,%edi
cmp    (%r15,%rbx,1),%al
setbe  %dil
call   1040 <assert@plt>
movzbl (%r15,%r12,1),%r15d
cmp    %r13d,%r15d
jne    13c1 <induceSA+0x291>
mov    %r13d,%r15d
movslq %r14d,%r13
xor    %edi,%edi
cmp    %r13,%rbp
setge  %dil
call   1040 <assert@plt>
test   %r12d,%r12d
mov    0x8(%rsp),%rcx
mov    0x80(%rsp),%esi
je     1448 <induceSA+0x318>
lea    -0x2(%rbx),%eax
cmp    $0x4,%esi
jne    143a <induceSA+0x30a>
mov    0x18(%rsp),%rdx
mov    (%rdx,%rax,4),%eax
cmp    %r15d,%eax
jg     1448 <induceSA+0x318>
jmp    144d <induceSA+0x31d>
mov    0x18(%rsp),%rdx
movzbl (%rdx,%rax,1),%eax
cmp    %r15d,%eax
jle    144d <induceSA+0x31d>
neg    %ebx
mov    %ebx,%r12d
lea    -0x1(%r13),%r14d
mov    %r12d,-0x4(%rcx,%r13,4)
mov    %r15d,%r13d
mov    0x18(%rsp),%r15
jmp    1385 <induceSA+0x255>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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