int sort_typeBstar(const unsigned char *T, int *SA, int *bucket_A,
                   int *bucket_B, int n, int openMP) {
  int *PAb, *ISAb, *buf;
  int i, j, k, t, m, bufsize;
  int c0, c1;
  (void)openMP;
  for (i = 0; i < ((256)); ++i) {
    bucket_A[i] = 0;
  }
  for (i = 0; i < ((256) * (256)); ++i) {
    bucket_B[i] = 0;
  }
  for (i = n - 1, m = n, c0 = T[n - 1]; 0 <= i;) {
    do {
      ++bucket_A[(c1 = c0)];
    } while ((0 <= --i) && ((c0 = T[i]) >= c1));
    if (0 <= i) {
      ++(bucket_B[((c0) << 8) | (c1)]);
      SA[--m] = i;
      for (--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {
        ++(bucket_B[((c1) << 8) | (c0)]);
      }
    }
  }
  m = n - m;
  for (c0 = 0, i = 0, j = 0; c0 < (256); ++c0) {
    t = i + bucket_A[(c0)];
    bucket_A[(c0)] = i + j;
    i = t + (bucket_B[((c0) << 8) | (c0)]);
    for (c1 = c0 + 1; c1 < (256); ++c1) {
      j += (bucket_B[((c0) << 8) | (c1)]);
      (bucket_B[((c0) << 8) | (c1)]) = j;
      i += (bucket_B[((c1) << 8) | (c0)]);
    }
  }
  if (0 < m) {
    PAb = SA + n - m;
    ISAb = SA + m;
    for (i = m - 2; 0 <= i; --i) {
      t = PAb[i], c0 = T[t], c1 = T[t + 1];
      SA[--(bucket_B[((c0) << 8) | (c1)])] = i;
    }
    t = PAb[m - 1], c0 = T[t], c1 = T[t + 1];
    SA[--(bucket_B[((c0) << 8) | (c1)])] = m - 1;
    buf = SA + m, bufsize = n - (2 * m);
    for (c0 = (256) - 2, j = m; 0 < j; --c0) {
      for (c1 = (256) - 1; c0 < c1; j = i, --c1) {
        i = (bucket_B[((c0) << 8) | (c1)]);
        if (1 < (j - i)) {
          sssort(T, PAb, SA + i, SA + j, buf, bufsize, 2, n,
                 *(SA + i) == (m - 1));
        }
      }
    }
    for (i = m - 1; 0 <= i; --i) {
      if (0 <= SA[i]) {
        j = i;
        do {
          ISAb[SA[i]] = i;
        } while ((0 <= --i) && (0 <= SA[i]));
        SA[i + 1] = i - j;
        if (i <= 0) {
          break;
        }
      }
      j = i;
      do {
        ISAb[SA[i] = ~SA[i]] = j;
      } while (SA[--i] < 0);
      ISAb[SA[i]] = j;
    }
    trsort(ISAb, SA, m, 1);
    for (i = n - 1, j = m, c0 = T[n - 1]; 0 <= i;) {
      for (--i, c1 = c0; (0 <= i) && ((c0 = T[i]) >= c1); --i, c1 = c0) {
      }
      if (0 <= i) {
        t = i;
        for (--i, c1 = c0; (0 <= i) && ((c0 = T[i]) <= c1); --i, c1 = c0) {
        }
        SA[ISAb[--j]] = ((t == 0) || (1 < (t - i))) ? t : ~t;
      }
    }
    (bucket_B[(((256) - 1) << 8) | ((256) - 1)]) = n;
    for (c0 = (256) - 2, k = m - 1; 0 <= c0; --c0) {
      i = bucket_A[(c0 + 1)] - 1;
      for (c1 = (256) - 1; c0 < c1; --c1) {
        t = i - (bucket_B[((c1) << 8) | (c0)]);
        (bucket_B[((c1) << 8) | (c0)]) = i;
        for (i = t, j = (bucket_B[((c0) << 8) | (c1)]); j <= k; --i, --k) {
          SA[i] = SA[k];
        }
      }
      (bucket_B[((c0) << 8) | (c0 + 1)]) =
          i - (bucket_B[((c0) << 8) | (c0)]) + 1;
      (bucket_B[((c0) << 8) | (c0)]) = i;
    }
  }
  return m;
}


x86 assembly (clang, -O0):
<sort_typeBstar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
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   $0x0,-0x44(%rbp)
cmpl   $0x100,-0x44(%rbp)
jge    1174 <sort_typeBstar+0x54>
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    114a <sort_typeBstar+0x2a>
movl   $0x0,-0x44(%rbp)
cmpl   $0x10000,-0x44(%rbp)
jge    11a5 <sort_typeBstar+0x85>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    117b <sort_typeBstar+0x5b>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
xor    %eax,%eax
cmp    -0x44(%rbp),%eax
jg     12e1 <sort_typeBstar+0x1c1>
jmp    11d8 <sort_typeBstar+0xb8>
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
mov    %ecx,-0x60(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
add    $0xffffffff,%edx
mov    %edx,-0x44(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %edx,%ecx
mov    %al,-0x61(%rbp)
jg     121e <sort_typeBstar+0xfe>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
cmp    -0x60(%rbp),%eax
setge  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    11d8 <sort_typeBstar+0xb8>
xor    %eax,%eax
cmp    -0x44(%rbp),%eax
jg     12dc <sort_typeBstar+0x1bc>
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x54(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    -0x44(%rbp),%ecx
mov    %al,-0x62(%rbp)
jg     129a <sort_typeBstar+0x17a>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
cmp    -0x60(%rbp),%eax
setle  %al
mov    %al,-0x62(%rbp)
mov    -0x62(%rbp),%al
test   $0x1,%al
jne    12aa <sort_typeBstar+0x18a>
jmp    12d7 <sort_typeBstar+0x1b7>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
shl    $0x8,%ecx
or     -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1272 <sort_typeBstar+0x152>
jmp    12dc <sort_typeBstar+0x1bc>
jmp    11c8 <sort_typeBstar+0xa8>
mov    -0x24(%rbp),%eax
sub    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x5c(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
cmpl   $0x100,-0x5c(%rbp)
jge    13c6 <sort_typeBstar+0x2a6>
mov    -0x44(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x5c(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%edx
add    -0x48(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    -0x5c(%rbp),%edx
shl    $0x8,%edx
or     -0x5c(%rbp),%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
cmpl   $0x100,-0x60(%rbp)
jge    13b3 <sort_typeBstar+0x293>
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
shl    $0x8,%ecx
or     -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1350 <sort_typeBstar+0x230>
jmp    13b8 <sort_typeBstar+0x298>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    12ff <sort_typeBstar+0x1df>
xor    %eax,%eax
cmp    -0x54(%rbp),%eax
jge    19a1 <sort_typeBstar+0x881>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x44(%rbp)
xor    %eax,%eax
cmp    -0x44(%rbp),%eax
jg     1480 <sort_typeBstar+0x360>
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x60(%rbp)
mov    -0x44(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rsi
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x60(%rbp),%ecx
movslq %ecx,%rdi
mov    (%rsi,%rdi,4),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1410 <sort_typeBstar+0x2f0>
mov    -0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x50(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%edx
sub    $0x1,%edx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rsi
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x60(%rbp),%ecx
movslq %ecx,%rdi
mov    (%rsi,%rdi,4),%ecx
add    $0xffffffff,%ecx
mov    %ecx,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x58(%rbp)
movl   $0xfe,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
xor    %eax,%eax
cmp    -0x48(%rbp),%eax
jge    15e8 <sort_typeBstar+0x4c8>
movl   $0xff,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    15d5 <sort_typeBstar+0x4b5>
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%ecx
sub    -0x44(%rbp),%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jge    15bc <sort_typeBstar+0x49c>
mov    -0x8(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x10(%rbp),%rdx
movslq -0x44(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdx
mov    -0x10(%rbp),%rcx
movslq -0x48(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rcx
mov    -0x40(%rbp),%r8
mov    -0x58(%rbp),%r9d
mov    -0x24(%rbp),%r10d
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%r11
mov    (%rax,%r11,4),%eax
mov    -0x54(%rbp),%r11d
sub    $0x1,%r11d
cmp    %r11d,%eax
sete   %al
and    $0x1,%al
movzbl %al,%eax
movl   $0x2,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %eax,0x10(%rsp)
mov    $0x0,%al
call   1040 <sssort@plt>
jmp    15c1 <sort_typeBstar+0x4a1>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
jmp    151f <sort_typeBstar+0x3ff>
jmp    15da <sort_typeBstar+0x4ba>
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    150d <sort_typeBstar+0x3ed>
mov    -0x54(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
xor    %eax,%eax
cmp    -0x44(%rbp),%eax
jg     16f5 <sort_typeBstar+0x5d5>
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jg     168b <sort_typeBstar+0x56b>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
add    $0xffffffff,%edx
mov    %edx,-0x44(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %edx,%ecx
mov    %al,-0x63(%rbp)
jg     1656 <sort_typeBstar+0x536>
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
setle  %al
mov    %al,-0x63(%rbp)
mov    -0x63(%rbp),%al
test   $0x1,%al
jne    1615 <sort_typeBstar+0x4f5>
mov    -0x44(%rbp),%edx
sub    -0x48(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x44(%rbp)
jg     1686 <sort_typeBstar+0x566>
jmp    16f5 <sort_typeBstar+0x5d5>
jmp    168b <sort_typeBstar+0x56b>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
xor    $0xffffffff,%ecx
mov    -0x10(%rbp),%rsi
movslq -0x44(%rbp),%rdi
mov    %ecx,(%rsi,%rdi,4)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x44(%rbp)
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jl     1691 <sort_typeBstar+0x571>
mov    -0x48(%rbp),%edx
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x44(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    15f1 <sort_typeBstar+0x4d1>
mov    -0x38(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x54(%rbp),%edx
mov    $0x1,%ecx
mov    $0x0,%al
call   1030 <trsort@plt>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
xor    %eax,%eax
cmp    -0x44(%rbp),%eax
jg     185f <sort_typeBstar+0x73f>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    -0x44(%rbp),%ecx
mov    %al,-0x64(%rbp)
jg     1771 <sort_typeBstar+0x651>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
cmp    -0x60(%rbp),%eax
setge  %al
mov    %al,-0x64(%rbp)
mov    -0x64(%rbp),%al
test   $0x1,%al
jne    1781 <sort_typeBstar+0x661>
jmp    179a <sort_typeBstar+0x67a>
jmp    1786 <sort_typeBstar+0x666>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    1749 <sort_typeBstar+0x629>
xor    %eax,%eax
cmp    -0x44(%rbp),%eax
jg     185a <sort_typeBstar+0x73a>
mov    -0x44(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    -0x44(%rbp),%ecx
mov    %al,-0x65(%rbp)
jg     17e2 <sort_typeBstar+0x6c2>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x5c(%rbp)
cmp    -0x60(%rbp),%eax
setle  %al
mov    %al,-0x65(%rbp)
mov    -0x65(%rbp),%al
test   $0x1,%al
jne    17f2 <sort_typeBstar+0x6d2>
jmp    180b <sort_typeBstar+0x6eb>
jmp    17f7 <sort_typeBstar+0x6d7>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
jmp    17ba <sort_typeBstar+0x69a>
cmpl   $0x0,-0x50(%rbp)
je     1828 <sort_typeBstar+0x708>
mov    -0x50(%rbp),%ecx
sub    -0x44(%rbp),%ecx
mov    $0x1,%eax
cmp    %ecx,%eax
jge    1833 <sort_typeBstar+0x713>
mov    -0x50(%rbp),%eax
mov    %eax,-0x6c(%rbp)
jmp    183c <sort_typeBstar+0x71c>
mov    -0x50(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x48(%rbp),%esi
add    $0xffffffff,%esi
mov    %esi,-0x48(%rbp)
movslq %esi,%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    172f <sort_typeBstar+0x60f>
mov    -0x24(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x3fffc(%rax)
movl   $0xfe,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
xor    %eax,%eax
cmp    -0x5c(%rbp),%eax
jg     199c <sort_typeBstar+0x87c>
mov    -0x18(%rbp),%rax
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0xff,-0x60(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1947 <sort_typeBstar+0x827>
mov    -0x44(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    -0x60(%rbp),%edx
shl    $0x8,%edx
or     -0x5c(%rbp),%edx
movslq %edx,%rdx
sub    (%rcx,%rdx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%ecx
shl    $0x8,%ecx
or     -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x60(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1934 <sort_typeBstar+0x814>
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    18fb <sort_typeBstar+0x7db>
jmp    1939 <sort_typeBstar+0x819>
mov    -0x60(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x60(%rbp)
jmp    18a4 <sort_typeBstar+0x784>
mov    -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x5c(%rbp),%ecx
movslq %ecx,%rcx
sub    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
mov    -0x5c(%rbp),%esi
add    $0x1,%esi
or     %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x5c(%rbp),%ecx
shl    $0x8,%ecx
or     -0x5c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x5c(%rbp)
jmp    187c <sort_typeBstar+0x75c>
jmp    19a1 <sort_typeBstar+0x881>
mov    -0x54(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort_typeBstar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r8d,%r12d
mov    %rcx,%r14
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r13
xor    %ebp,%ebp
mov    $0x400,%edx
mov    %r15,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    $0x40000,%edx
mov    %r14,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
movslq %r12d,%r8
lea    -0x1(%r8),%rax
mov    %rax,0x30(%rsp)
mov    %r12,0x8(%rsp)
mov    %r12d,%r9d
mov    %r13,%r12
test   %r8d,%r8d
jle    1239 <sort_typeBstar+0x109>
mov    0x30(%rsp),%r10
mov    (%r12,%r10,1),%sil
mov    0x8(%rsp),%rax
mov    %eax,%r9d
movzbl %sil,%eax
mov    %r10d,%edi
add    $0xfffffffe,%r10d
mov    %r10d,%ecx
mov    %rdi,%rdx
nop
mov    %eax,%esi
mov    %eax,%eax
addl   $0x1,(%r15,%rax,4)
sub    $0x1,%rdx
jb     1239 <sort_typeBstar+0x109>
mov    %ecx,%r10d
movzbl -0x1(%r12,%rdi,1),%eax
lea    -0x1(%r10),%ecx
mov    %rdx,%rdi
cmp    %eax,%esi
jbe    11b0 <sort_typeBstar+0x80>
mov    %eax,%ecx
shl    $0x8,%ecx
or     %esi,%ecx
addl   $0x1,(%r14,%rcx,4)
movslq %r9d,%rcx
add    $0xffffffff,%r9d
mov    %edx,-0x4(%rbx,%rcx,4)
add    $0x1,%edx
cmp    $0x2,%edx
jl     1239 <sort_typeBstar+0x109>
mov    %r10d,%edx
add    $0x1,%rdx
nopl   0x0(%rax)
movzbl -0x1(%r12,%rdx,1),%esi
movzbl %sil,%edi
cmp    %edi,%eax
jb     1230 <sort_typeBstar+0x100>
mov    %eax,%eax
shl    $0x8,%rax
or     %rdi,%rax
addl   $0x1,(%r14,%rax,4)
add    $0xffffffff,%r10d
mov    %edi,%eax
add    $0xffffffffffffffff,%rdx
jg     1200 <sort_typeBstar+0xd0>
jmp    1239 <sort_typeBstar+0x109>
nopw   0x0(%rax,%rax,1)
test   %r10d,%r10d
jns    119e <sort_typeBstar+0x6e>
xor    %r10d,%r10d
xor    %edx,%edx
jmp    124d <sort_typeBstar+0x11d>
cmp    $0x100,%r10
je     1325 <sort_typeBstar+0x1f5>
mov    %r10,%rdi
mov    (%r15,%r10,4),%eax
add    %ebp,%eax
add    %edx,%ebp
mov    %ebp,(%r15,%r10,4)
mov    %edi,%ecx
shl    $0x8,%ecx
or     %edi,%ecx
mov    %eax,%ebp
add    (%r14,%rcx,4),%ebp
add    $0x1,%r10
cmp    $0xfe,%rdi
ja     1240 <sort_typeBstar+0x110>
mov    $0x1,%eax
sub    %edi,%eax
mov    %edi,%r11d
shl    $0x8,%r11d
test   $0x1,%al
jne    12a0 <sort_typeBstar+0x170>
mov    %r10d,%ecx
cmp    $0xfe,%edi
je     1240 <sort_typeBstar+0x110>
jmp    12cc <sort_typeBstar+0x19c>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r11d,%eax
or     %r10d,%eax
add    (%r14,%rax,4),%edx
mov    %edx,(%r14,%rax,4)
mov    %r10d,%eax
shl    $0x8,%eax
mov    %edi,%esi
or     %eax,%esi
add    (%r14,%rsi,4),%ebp
lea    0x1(%r10),%ecx
cmp    $0xfe,%edi
je     1240 <sort_typeBstar+0x110>
mov    %ecx,%esi
shl    $0x8,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%eax
or     %r11d,%eax
add    (%r14,%rax,4),%edx
mov    %edx,(%r14,%rax,4)
mov    %esi,%eax
or     %edi,%eax
add    (%r14,%rax,4),%ebp
lea    0x1(%rcx),%eax
or     %r11d,%eax
add    (%r14,%rax,4),%edx
mov    %edx,(%r14,%rax,4)
lea    0x100(%rsi),%eax
or     %edi,%eax
add    (%r14,%rax,4),%ebp
add    $0x200,%esi
add    $0x2,%ecx
cmp    $0x100,%ecx
jne    12e0 <sort_typeBstar+0x1b0>
jmp    1240 <sort_typeBstar+0x110>
mov    %r15,0x50(%rsp)
mov    0x8(%rsp),%rax
sub    %r9d,%eax
mov    %rax,0x18(%rsp)
jle    1839 <sort_typeBstar+0x709>
lea    (%rbx,%r8,4),%rsi
mov    0x18(%rsp),%rdx
mov    %edx,%eax
lea    0x0(,%rax,4),%rcx
sub    %rcx,%rsi
mov    %rsi,0x38(%rsp)
cmp    $0x1,%edx
je     13ad <sort_typeBstar+0x27d>
mov    0x18(%rsp),%rcx
add    $0xfffffffe,%ecx
not    %r9d
add    0x8(%rsp),%r9d
add    %rcx,%r8
sub    %rax,%r8
lea    (%rbx,%r8,4),%rcx
nopw   0x0(%rax,%rax,1)
movslq (%rcx),%rdx
movzwl (%r12,%rdx,1),%edx
shl    $0x30,%rdx
bswap  %rdx
movslq (%r14,%rdx,4),%rsi
lea    -0x1(%rsi),%rdi
mov    %edi,(%r14,%rdx,4)
add    $0xffffffff,%r9d
mov    %r9d,-0x4(%rbx,%rsi,4)
add    $0xfffffffffffffffc,%rcx
test   %r9d,%r9d
jg     1380 <sort_typeBstar+0x250>
mov    0x18(%rsp),%rsi
lea    -0x1(%rsi),%r13d
mov    0x38(%rsp),%rcx
movslq (%rcx,%r13,4),%rcx
mov    %r12,0x48(%rsp)
movzwl (%r12,%rcx,1),%ecx
shl    $0x30,%rcx
bswap  %rcx
lea    (%rbx,%rax,4),%rax
mov    %rax,0x40(%rsp)
movslq (%r14,%rcx,4),%rax
lea    -0x1(%rax),%rdx
mov    %r14,0x20(%rsp)
mov    %edx,(%r14,%rcx,4)
mov    %r13d,-0x4(%rbx,%rax,4)
mov    0x8(%rsp),%rcx
sub    %esi,%ecx
sub    %esi,%ecx
mov    %ecx,0x2c(%rsp)
mov    $0xfe,%r12d
mov    %esi,%r14d
jmp    141d <sort_typeBstar+0x2ed>
nopw   0x0(%rax,%rax,1)
add    $0xffffffff,%r12d
test   %r14d,%r14d
jle    14ae <sort_typeBstar+0x37e>
mov    %r12d,%esi
shl    $0x8,%esi
mov    $0xff,%r15d
mov    %r14d,%eax
mov    %esi,0x14(%rsp)
jmp    144c <sort_typeBstar+0x31c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffff,%r15d
mov    %r14d,%eax
cmp    %r15d,%r12d
jge    1410 <sort_typeBstar+0x2e0>
mov    %r15d,%ecx
or     %esi,%ecx
movslq %ecx,%rcx
mov    0x20(%rsp),%rdx
mov    (%rdx,%rcx,4),%r14d
mov    %eax,%ecx
sub    %r14d,%ecx
cmp    $0x2,%ecx
jl     1440 <sort_typeBstar+0x310>
movslq %r14d,%rsi
lea    (%rbx,%rsi,4),%rdx
cltq
lea    (%rbx,%rax,4),%rcx
xor    %ebp,%ebp
cmp    %r13d,(%rbx,%rsi,4)
sete   %bpl
sub    $0x8,%rsp
mov    0x50(%rsp),%rdi
mov    0x40(%rsp),%rsi
mov    0x48(%rsp),%r8
mov    0x34(%rsp),%r9d
xor    %eax,%eax
push   %rbp
push   0x18(%rsp)
push   $0x2
call   1050 <sssort@plt>
mov    0x34(%rsp),%esi
add    $0x20,%rsp
jmp    1440 <sort_typeBstar+0x310>
lea    -0x4(%rbx),%r8
mov    %r13d,%ecx
mov    0x30(%rsp),%r14
mov    0x40(%rsp),%r12
mov    %ecx,%eax
mov    (%rbx,%rax,4),%ebp
test   %ebp,%ebp
js     1503 <sort_typeBstar+0x3d3>
lea    (%r8,%rax,4),%rdi
xor    %esi,%esi
xchg   %ax,%ax
mov    %rax,%rdx
mov    %ebp,%ebp
add    %rsi,%rdx
mov    %edx,(%r12,%rbp,4)
je     1537 <sort_typeBstar+0x407>
mov    (%rdi,%rsi,4),%ebp
add    $0xffffffffffffffff,%rsi
test   %ebp,%ebp
jns    14d0 <sort_typeBstar+0x3a0>
lea    (%rax,%rsi,1),%rcx
add    $0x1,%rcx
mov    %ecx,%edx
mov    %esi,(%rbx,%rdx,4)
test   $0xfffffffe,%ecx
je     153b <sort_typeBstar+0x40b>
add    %rsi,%rax
mov    %eax,%ecx
movslq %ecx,%rdx
lea    (%rbx,%rdx,4),%rsi
mov    (%rbx,%rdx,4),%edi
add    $0x1,%edx
not    %edi
mov    %edi,(%rsi)
movslq %edi,%rax
mov    %ecx,(%r12,%rax,4)
mov    -0x4(%rsi),%edi
add    $0xfffffffffffffffc,%rsi
add    $0xffffffff,%edx
test   %edi,%edi
js     1510 <sort_typeBstar+0x3e0>
mov    %ecx,(%r12,%rdi,4)
lea    -0x2(%rdx),%ecx
cmp    $0x1,%edx
jg     14bf <sort_typeBstar+0x38f>
jmp    153b <sort_typeBstar+0x40b>
not    %ecx
mov    %ecx,(%rbx)
mov    %r12,%rdi
mov    %rbx,%rsi
mov    0x18(%rsp),%rdx
mov    $0x1,%ecx
xor    %eax,%eax
call   1040 <trsort@plt>
cmpl   $0x0,0x8(%rsp)
mov    0x20(%rsp),%r15
mov    0x48(%rsp),%r11
jle    1628 <sort_typeBstar+0x4f8>
movzbl (%r11,%r14,1),%eax
lea    -0x1(%r11),%r8
mov    0x18(%rsp),%rcx
mov    %ecx,%r10d
mov    %r14d,%edx
lea    (%r8,%rdx,1),%rbp
add    $0xfffffffe,%r14d
mov    %r14d,%ecx
xor    %edi,%edi
mov    %eax,%esi
nopw   0x0(%rax,%rax,1)
mov    %rdx,%rax
add    %rdi,%rax
je     1628 <sort_typeBstar+0x4f8>
mov    %ecx,%r14d
movzbl 0x0(%rbp,%rdi,1),%eax
add    $0xffffffffffffffff,%rdi
lea    -0x1(%r14),%ecx
cmp    %eax,%esi
mov    %eax,%esi
jbe    1590 <sort_typeBstar+0x460>
lea    (%rdx,%rdi,1),%r9
lea    0x1(%r9),%ecx
cmp    $0x1,%ecx
jle    15f0 <sort_typeBstar+0x4c0>
mov    %r14d,%ebp
add    $0x1,%rbp
cs nopw 0x0(%rax,%rax,1)
movzbl -0x1(%r11,%rbp,1),%esi
cmp    %esi,%eax
jb     15ec <sort_typeBstar+0x4bc>
add    $0xffffffff,%r14d
mov    %esi,%eax
add    $0xffffffffffffffff,%rbp
jg     15d0 <sort_typeBstar+0x4a0>
mov    $0xffffffff,%r14d
mov    %esi,%eax
jmp    15f7 <sort_typeBstar+0x4c7>
lea    -0x1(%rdx),%r14d
add    %rdi,%r14
mov    %edx,%ecx
sub    %r14d,%ecx
add    %edi,%ecx
add    %edi,%edx
cmp    $0x2,%ecx
not    %edx
cmovge %r9d,%edx
test   %r9d,%r9d
cmove  %r9d,%edx
movslq %r10d,%rcx
add    $0xffffffff,%r10d
movslq -0x4(%r12,%rcx,4),%rcx
mov    %edx,(%rbx,%rcx,4)
test   %r14d,%r14d
jns    1578 <sort_typeBstar+0x448>
mov    0x8(%rsp),%rax
mov    %eax,0x3fffc(%r15)
lea    0x4(%rbx),%r11
lea    -0xc(%rbx),%rax
mov    %rax,0x8(%rsp)
mov    $0xfe,%r12d
jmp    167d <sort_typeBstar+0x54d>
nopl   0x0(%rax)
mov    %r14d,%eax
or     %r12d,%eax
cltq
mov    %esi,%ecx
sub    (%r15,%rax,4),%ecx
add    $0x1,%ecx
mov    0x14(%rsp),%edx
or     %r14d,%edx
movslq %edx,%rdx
mov    %ecx,(%r15,%rdx,4)
mov    %esi,(%r15,%rax,4)
sub    $0x1,%r12
jb     1839 <sort_typeBstar+0x709>
lea    0x1(%r12),%eax
mov    %eax,0x14(%rsp)
mov    0x50(%rsp),%rax
mov    0x4(%rax,%r12,4),%esi
add    $0xffffffff,%esi
mov    %r12d,%r14d
shl    $0x8,%r14d
mov    $0xff,%ecx
jmp    16b8 <sort_typeBstar+0x588>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xffffffff,%ecx
cmp    %rcx,%r12
jae    1650 <sort_typeBstar+0x520>
mov    %esi,%eax
mov    %ecx,%edx
shl    $0x8,%edx
or     %r12d,%edx
movslq %edx,%rdx
sub    (%r15,%rdx,4),%esi
mov    %eax,(%r15,%rdx,4)
mov    %ecx,%eax
or     %r14d,%eax
cltq
movslq (%r15,%rax,4),%rbp
cmp    %r13d,%ebp
jg     16b0 <sort_typeBstar+0x580>
movslq %esi,%rsi
movslq %r13d,%rdi
mov    %rbp,%rax
neg    %rax
lea    (%rdi,%rax,1),%r8
add    $0x1,%r8
cmp    $0x8,%r8
jae    1720 <sort_typeBstar+0x5f0>
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rdi,4),%eax
mov    %eax,(%rbx,%rsi,4)
add    $0xffffffffffffffff,%rsi
lea    -0x1(%rdi),%r13
cmp    %rbp,%rdi
mov    %r13,%rdi
jg     1700 <sort_typeBstar+0x5d0>
jmp    16b0 <sort_typeBstar+0x580>
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rax
sub    %rbp,%rax
mov    $0x4,%edx
mul    %rdx
lea    (%rbx,%rsi,4),%r10
seto   %r9b
mov    %r10,%rdx
sub    %rax,%rdx
cmp    %r10,%rdx
ja     1700 <sort_typeBstar+0x5d0>
test   %r9b,%r9b
jne    1700 <sort_typeBstar+0x5d0>
lea    (%rbx,%rdi,4),%r10
mov    %r10,%rdx
sub    %rax,%rdx
cmp    %r10,%rdx
ja     1700 <sort_typeBstar+0x5d0>
test   %r9b,%r9b
jne    1700 <sort_typeBstar+0x5d0>
lea    (%rsi,%rbp,1),%rax
sub    %rdi,%rax
lea    (%rbx,%rax,4),%rax
lea    (%r11,%rdi,4),%rdx
cmp    %rdx,%rax
jae    177b <sort_typeBstar+0x64b>
lea    (%r11,%rsi,4),%rax
lea    (%rbx,%rbp,4),%rdx
cmp    %rax,%rdx
jb     1700 <sort_typeBstar+0x5d0>
mov    %r8,%r15
and    $0xfffffffffffffff8,%r15
lea    -0x8(%r15),%rax
mov    %rax,%r13
shr    $0x3,%r13
add    $0x1,%r13
test   %rax,%rax
je     182f <sort_typeBstar+0x6ff>
mov    %r13,%rdx
and    $0xfffffffffffffffe,%rdx
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,4),%r9
lea    (%rax,%rsi,4),%r10
xor    %eax,%eax
movups -0x10(%r9,%rax,4),%xmm0
movups (%r9,%rax,4),%xmm1
movups %xmm1,(%r10,%rax,4)
movups %xmm0,-0x10(%r10,%rax,4)
movups -0x30(%r9,%rax,4),%xmm0
movups -0x20(%r9,%rax,4),%xmm1
movups %xmm1,-0x20(%r10,%rax,4)
movups %xmm0,-0x30(%r10,%rax,4)
add    $0xfffffffffffffff0,%rax
add    $0xfffffffffffffffe,%rdx
jne    17b0 <sort_typeBstar+0x680>
neg    %rax
test   $0x1,%r13b
je     1813 <sort_typeBstar+0x6e3>
mov    %rdi,%rdx
sub    %rax,%rdx
mov    %rsi,%r9
sub    %rax,%r9
movups -0x1c(%rbx,%rdx,4),%xmm0
movups -0xc(%rbx,%rdx,4),%xmm1
movups %xmm1,-0xc(%rbx,%r9,4)
movups %xmm0,-0x1c(%rbx,%r9,4)
sub    %r15,%rdi
sub    %r15,%rsi
mov    %rdi,%r13
cmp    %r15,%r8
mov    0x20(%rsp),%r15
jne    1700 <sort_typeBstar+0x5d0>
jmp    16b0 <sort_typeBstar+0x580>
xor    %eax,%eax
test   $0x1,%r13b
jne    17f1 <sort_typeBstar+0x6c1>
jmp    1813 <sort_typeBstar+0x6e3>
mov    0x18(%rsp),%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @sort_typeBstar(i8* %0, i32* %1, i32* %2, i32* %3, i32 %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i32*
%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
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
store i8* %0, i8** %7
store i32* %1, i32** %8
store i32* %2, i32** %9
store i32* %3, i32** %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%24 = load i32, i32* %12
store i32 0, i32* %16
br label %25
25: ; preds = %33, %6
%26 = load i32, i32* %16
%27 = icmp slt i32 %26, 256
br i1 %27, label %28, label %36
28: ; preds = %25
%29 = load i32*, i32** %9
%30 = load i32, i32* %16
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
store i32 0, i32* %32
br label %33
33: ; preds = %28
%34 = load i32, i32* %16
%35 = add nsw i32 %34, 1
store i32 %35, i32* %16
br label %25
36: ; preds = %25
store i32 0, i32* %16
br label %37
37: ; preds = %45, %36
%38 = load i32, i32* %16
%39 = icmp slt i32 %38, 65536
br i1 %39, label %40, label %48
40: ; preds = %37
%41 = load i32*, i32** %10
%42 = load i32, i32* %16
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %41, i64 %43
store i32 0, i32* %44
br label %45
45: ; preds = %40
%46 = load i32, i32* %16
%47 = add nsw i32 %46, 1
store i32 %47, i32* %16
br label %37
48: ; preds = %37
%49 = load i32, i32* %11
%50 = sub nsw i32 %49, 1
store i32 %50, i32* %16
%51 = load i32, i32* %11
store i32 %51, i32* %20
%52 = load i8*, i8** %7
%53 = load i32, i32* %11
%54 = sub nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %52, i64 %55
%57 = load i8, i8* %56
%58 = zext i8 %57 to i32
store i32 %58, i32* %22
br label %59
59: ; preds = %136, %48
%60 = load i32, i32* %16
%61 = icmp sle i32 0, %60
br i1 %61, label %62, label %137
62: ; preds = %59
br label %63
63: ; preds = %83, %62
%64 = load i32*, i32** %9
%65 = load i32, i32* %22
store i32 %65, i32* %23
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %64, i64 %66
%68 = load i32, i32* %67
%69 = add nsw i32 %68, 1
store i32 %69, i32* %67
br label %70
70: ; preds = %63
%71 = load i32, i32* %16
%72 = add nsw i32 %71, -1
store i32 %72, i32* %16
%73 = icmp sle i32 0, %72
br i1 %73, label %74, label %83
74: ; preds = %70
%75 = load i8*, i8** %7
%76 = load i32, i32* %16
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %75, i64 %77
%79 = load i8, i8* %78
%80 = zext i8 %79 to i32
store i32 %80, i32* %22
%81 = load i32, i32* %23
%82 = icmp sge i32 %80, %81
br label %83
83: ; preds = %74, %70
%84 = phi i1 [ false, %70 ], [ %82, %74 ]
br i1 %84, label %63, label %85
85: ; preds = %83
%86 = load i32, i32* %16
%87 = icmp sle i32 0, %86
br i1 %87, label %88, label %136
88: ; preds = %85
%89 = load i32*, i32** %10
%90 = load i32, i32* %22
%91 = shl i32 %90, 8
%92 = load i32, i32* %23
%93 = or i32 %91, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %89, i64 %94
%96 = load i32, i32* %95
%97 = add nsw i32 %96, 1
store i32 %97, i32* %95
%98 = load i32, i32* %16
%99 = load i32*, i32** %8
%100 = load i32, i32* %20
%101 = add nsw i32 %100, -1
store i32 %101, i32* %20
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %99, i64 %102
store i32 %98, i32* %103
%104 = load i32, i32* %16
%105 = add nsw i32 %104, -1
store i32 %105, i32* %16
%106 = load i32, i32* %22
store i32 %106, i32* %23
br label %107
107: ; preds = %131, %88
%108 = load i32, i32* %16
%109 = icmp sle i32 0, %108
br i1 %109, label %110, label %119
110: ; preds = %107
%111 = load i8*, i8** %7
%112 = load i32, i32* %16
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8, i8* %111, i64 %113
%115 = load i8, i8* %114
%116 = zext i8 %115 to i32
store i32 %116, i32* %22
%117 = load i32, i32* %23
%118 = icmp sle i32 %116, %117
br label %119
119: ; preds = %110, %107
%120 = phi i1 [ false, %107 ], [ %118, %110 ]
br i1 %120, label %121, label %135
121: ; preds = %119
%122 = load i32*, i32** %10
%123 = load i32, i32* %23
%124 = shl i32 %123, 8
%125 = load i32, i32* %22
%126 = or i32 %124, %125
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i32, i32* %122, i64 %127
%129 = load i32, i32* %128
%130 = add nsw i32 %129, 1
store i32 %130, i32* %128
br label %131
131: ; preds = %121
%132 = load i32, i32* %16
%133 = add nsw i32 %132, -1
store i32 %133, i32* %16
%134 = load i32, i32* %22
store i32 %134, i32* %23
br label %107
135: ; preds = %119
br label %136
136: ; preds = %135, %85
br label %59
137: ; preds = %59
%138 = load i32, i32* %11
%139 = load i32, i32* %20
%140 = sub nsw i32 %138, %139
store i32 %140, i32* %20
store i32 0, i32* %22
store i32 0, i32* %16
store i32 0, i32* %17
br label %141
141: ; preds = %207, %137
%142 = load i32, i32* %22
%143 = icmp slt i32 %142, 256
br i1 %143, label %144, label %210
144: ; preds = %141
%145 = load i32, i32* %16
%146 = load i32*, i32** %9
%147 = load i32, i32* %22
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i32, i32* %146, i64 %148
%150 = load i32, i32* %149
%151 = add nsw i32 %145, %150
store i32 %151, i32* %19
%152 = load i32, i32* %16
%153 = load i32, i32* %17
%154 = add nsw i32 %152, %153
%155 = load i32*, i32** %9
%156 = load i32, i32* %22
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %155, i64 %157
store i32 %154, i32* %158
%159 = load i32, i32* %19
%160 = load i32*, i32** %10
%161 = load i32, i32* %22
%162 = shl i32 %161, 8
%163 = load i32, i32* %22
%164 = or i32 %162, %163
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i32, i32* %160, i64 %165
%167 = load i32, i32* %166
%168 = add nsw i32 %159, %167
store i32 %168, i32* %16
%169 = load i32, i32* %22
%170 = add nsw i32 %169, 1
store i32 %170, i32* %23
br label %171
171: ; preds = %203, %144
%172 = load i32, i32* %23
%173 = icmp slt i32 %172, 256
br i1 %173, label %174, label %206
174: ; preds = %171
%175 = load i32*, i32** %10
%176 = load i32, i32* %22
%177 = shl i32 %176, 8
%178 = load i32, i32* %23
%179 = or i32 %177, %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %175, i64 %180
%182 = load i32, i32* %181
%183 = load i32, i32* %17
%184 = add nsw i32 %183, %182
store i32 %184, i32* %17
%185 = load i32, i32* %17
%186 = load i32*, i32** %10
%187 = load i32, i32* %22
%188 = shl i32 %187, 8
%189 = load i32, i32* %23
%190 = or i32 %188, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %186, i64 %191
store i32 %185, i32* %192
%193 = load i32*, i32** %10
%194 = load i32, i32* %23
%195 = shl i32 %194, 8
%196 = load i32, i32* %22
%197 = or i32 %195, %196
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %193, i64 %198
%200 = load i32, i32* %199
%201 = load i32, i32* %16
%202 = add nsw i32 %201, %200
store i32 %202, i32* %16
br label %203
203: ; preds = %174
%204 = load i32, i32* %23
%205 = add nsw i32 %204, 1
store i32 %205, i32* %23
br label %171
206: ; preds = %171
br label %207
207: ; preds = %206
%208 = load i32, i32* %22
%209 = add nsw i32 %208, 1
store i32 %209, i32* %22
br label %141
210: ; preds = %141
%211 = load i32, i32* %20
%212 = icmp slt i32 0, %211
br i1 %212, label %213, label %649
213: ; preds = %210
%214 = load i32*, i32** %8
%215 = load i32, i32* %11
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds i32, i32* %214, i64 %216
%218 = load i32, i32* %20
%219 = sext i32 %218 to i64
%220 = sub i64 0, %219
%221 = getelementptr inbounds i32, i32* %217, i64 %220
store i32* %221, i32** %13
%222 = load i32*, i32** %8
%223 = load i32, i32* %20
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds i32, i32* %222, i64 %224
store i32* %225, i32** %14
%226 = load i32, i32* %20
%227 = sub nsw i32 %226, 2
store i32 %227, i32* %16
br label %228
228: ; preds = %263, %213
%229 = load i32, i32* %16
%230 = icmp sle i32 0, %229
br i1 %230, label %231, label %266
231: ; preds = %228
%232 = load i32*, i32** %13
%233 = load i32, i32* %16
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %232, i64 %234
%236 = load i32, i32* %235
store i32 %236, i32* %19
%237 = load i8*, i8** %7
%238 = load i32, i32* %19
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i8, i8* %237, i64 %239
%241 = load i8, i8* %240
%242 = zext i8 %241 to i32
store i32 %242, i32* %22
%243 = load i8*, i8** %7
%244 = load i32, i32* %19
%245 = add nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i8, i8* %243, i64 %246
%248 = load i8, i8* %247
%249 = zext i8 %248 to i32
store i32 %249, i32* %23
%250 = load i32, i32* %16
%251 = load i32*, i32** %8
%252 = load i32*, i32** %10
%253 = load i32, i32* %22
%254 = shl i32 %253, 8
%255 = load i32, i32* %23
%256 = or i32 %254, %255
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i32, i32* %252, i64 %257
%259 = load i32, i32* %258
%260 = add nsw i32 %259, -1
store i32 %260, i32* %258
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i32, i32* %251, i64 %261
store i32 %250, i32* %262
br label %263
263: ; preds = %231
%264 = load i32, i32* %16
%265 = add nsw i32 %264, -1
store i32 %265, i32* %16
br label %228
266: ; preds = %228
%267 = load i32*, i32** %13
%268 = load i32, i32* %20
%269 = sub nsw i32 %268, 1
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i32, i32* %267, i64 %270
%272 = load i32, i32* %271
store i32 %272, i32* %19
%273 = load i8*, i8** %7
%274 = load i32, i32* %19
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i8, i8* %273, i64 %275
%277 = load i8, i8* %276
%278 = zext i8 %277 to i32
store i32 %278, i32* %22
%279 = load i8*, i8** %7
%280 = load i32, i32* %19
%281 = add nsw i32 %280, 1
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i8, i8* %279, i64 %282
%284 = load i8, i8* %283
%285 = zext i8 %284 to i32
store i32 %285, i32* %23
%286 = load i32, i32* %20
%287 = sub nsw i32 %286, 1
%288 = load i32*, i32** %8
%289 = load i32*, i32** %10
%290 = load i32, i32* %22
%291 = shl i32 %290, 8
%292 = load i32, i32* %23
%293 = or i32 %291, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i32, i32* %289, i64 %294
%296 = load i32, i32* %295
%297 = add nsw i32 %296, -1
store i32 %297, i32* %295
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i32, i32* %288, i64 %298
store i32 %287, i32* %299
%300 = load i32*, i32** %8
%301 = load i32, i32* %20
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds i32, i32* %300, i64 %302
store i32* %303, i32** %15
%304 = load i32, i32* %11
%305 = load i32, i32* %20
%306 = mul nsw i32 2, %305
%307 = sub nsw i32 %304, %306
store i32 %307, i32* %21
store i32 254, i32* %22
%308 = load i32, i32* %20
store i32 %308, i32* %17
br label %309
309: ; preds = %360, %266
%310 = load i32, i32* %17
%311 = icmp slt i32 0, %310
br i1 %311, label %312, label %363
312: ; preds = %309
store i32 255, i32* %23
br label %313
313: ; preds = %355, %312
%314 = load i32, i32* %22
%315 = load i32, i32* %23
%316 = icmp slt i32 %314, %315
br i1 %316, label %317, label %359
317: ; preds = %313
%318 = load i32*, i32** %10
%319 = load i32, i32* %22
%320 = shl i32 %319, 8
%321 = load i32, i32* %23
%322 = or i32 %320, %321
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds i32, i32* %318, i64 %323
%325 = load i32, i32* %324
store i32 %325, i32* %16
%326 = load i32, i32* %17
%327 = load i32, i32* %16
%328 = sub nsw i32 %326, %327
%329 = icmp slt i32 1, %328
br i1 %329, label %330, label %354
330: ; preds = %317
%331 = load i8*, i8** %7
%332 = load i32*, i32** %13
%333 = load i32*, i32** %8
%334 = load i32, i32* %16
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds i32, i32* %333, i64 %335
%337 = load i32*, i32** %8
%338 = load i32, i32* %17
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i32, i32* %337, i64 %339
%341 = load i32*, i32** %15
%342 = load i32, i32* %21
%343 = load i32, i32* %11
%344 = load i32*, i32** %8
%345 = load i32, i32* %16
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32, i32* %344, i64 %346
%348 = load i32, i32* %347
%349 = load i32, i32* %20
%350 = sub nsw i32 %349, 1
%351 = icmp eq i32 %348, %350
%352 = zext i1 %351 to i32
%353 = call i32 (i8*, i32*, i32*, i32*, i32*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @sssort to i32 (i8*, i32*, i32*, i32*, i32*, i32, i32, i32, i32, ...)*)(i8* %331, i32* %332, i32* %336, i32* %340, i32* %341, i32 %342, i32 2, i32 %343, i32 %352)
br label %354
354: ; preds = %330, %317
br label %355
355: ; preds = %354
%356 = load i32, i32* %16
store i32 %356, i32* %17
%357 = load i32, i32* %23
%358 = add nsw i32 %357, -1
store i32 %358, i32* %23
br label %313
359: ; preds = %313
br label %360
360: ; preds = %359
%361 = load i32, i32* %22
%362 = add nsw i32 %361, -1
store i32 %362, i32* %22
br label %309
363: ; preds = %309
%364 = load i32, i32* %20
%365 = sub nsw i32 %364, 1
store i32 %365, i32* %16
br label %366
366: ; preds = %449, %363
%367 = load i32, i32* %16
%368 = icmp sle i32 0, %367
br i1 %368, label %369, label %452
369: ; preds = %366
%370 = load i32*, i32** %8
%371 = load i32, i32* %16
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds i32, i32* %370, i64 %372
%374 = load i32, i32* %373
%375 = icmp sle i32 0, %374
br i1 %375, label %376, label %414
376: ; preds = %369
%377 = load i32, i32* %16
store i32 %377, i32* %17
br label %378
378: ; preds = %399, %376
%379 = load i32, i32* %16
%380 = load i32*, i32** %14
%381 = load i32*, i32** %8
%382 = load i32, i32* %16
%383 = sext i32 %382 to i64
%384 = getelementptr inbounds i32, i32* %381, i64 %383
%385 = load i32, i32* %384
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i32, i32* %380, i64 %386
store i32 %379, i32* %387
br label %388
388: ; preds = %378
%389 = load i32, i32* %16
%390 = add nsw i32 %389, -1
store i32 %390, i32* %16
%391 = icmp sle i32 0, %390
br i1 %391, label %392, label %399
392: ; preds = %388
%393 = load i32*, i32** %8
%394 = load i32, i32* %16
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i32, i32* %393, i64 %395
%397 = load i32, i32* %396
%398 = icmp sle i32 0, %397
br label %399
399: ; preds = %392, %388
%400 = phi i1 [ false, %388 ], [ %398, %392 ]
br i1 %400, label %378, label %401
401: ; preds = %399
%402 = load i32, i32* %16
%403 = load i32, i32* %17
%404 = sub nsw i32 %402, %403
%405 = load i32*, i32** %8
%406 = load i32, i32* %16
%407 = add nsw i32 %406, 1
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i32, i32* %405, i64 %408
store i32 %404, i32* %409
%410 = load i32, i32* %16
%411 = icmp sle i32 %410, 0
br i1 %411, label %412, label %413
412: ; preds = %401
br label %452
413: ; preds = %401
br label %414
414: ; preds = %413, %369
%415 = load i32, i32* %16
store i32 %415, i32* %17
br label %416
416: ; preds = %431, %414
%417 = load i32, i32* %17
%418 = load i32*, i32** %14
%419 = load i32*, i32** %8
%420 = load i32, i32* %16
%421 = sext i32 %420 to i64
%422 = getelementptr inbounds i32, i32* %419, i64 %421
%423 = load i32, i32* %422
%424 = xor i32 %423, -1
%425 = load i32*, i32** %8
%426 = load i32, i32* %16
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds i32, i32* %425, i64 %427
store i32 %424, i32* %428
%429 = sext i32 %424 to i64
%430 = getelementptr inbounds i32, i32* %418, i64 %429
store i32 %417, i32* %430
br label %431
431: ; preds = %416
%432 = load i32*, i32** %8
%433 = load i32, i32* %16
%434 = add nsw i32 %433, -1
store i32 %434, i32* %16
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds i32, i32* %432, i64 %435
%437 = load i32, i32* %436
%438 = icmp slt i32 %437, 0
br i1 %438, label %416, label %439
439: ; preds = %431
%440 = load i32, i32* %17
%441 = load i32*, i32** %14
%442 = load i32*, i32** %8
%443 = load i32, i32* %16
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds i32, i32* %442, i64 %444
%446 = load i32, i32* %445
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i32, i32* %441, i64 %447
store i32 %440, i32* %448
br label %449
449: ; preds = %439
%450 = load i32, i32* %16
%451 = add nsw i32 %450, -1
store i32 %451, i32* %16
br label %366
452: ; preds = %412, %366
%453 = load i32*, i32** %14
%454 = load i32*, i32** %8
%455 = load i32, i32* %20
%456 = call i32 (i32*, i32*, i32, i32, ...) bitcast (i32 (...)* @trsort to i32 (i32*, i32*, i32, i32, ...)*)(i32* %453, i32* %454, i32 %455, i32 1)
%457 = load i32, i32* %11
%458 = sub nsw i32 %457, 1
store i32 %458, i32* %16
%459 = load i32, i32* %20
store i32 %459, i32* %17
%460 = load i8*, i8** %7
%461 = load i32, i32* %11
%462 = sub nsw i32 %461, 1
%463 = sext i32 %462 to i64
%464 = getelementptr inbounds i8, i8* %460, i64 %463
%465 = load i8, i8* %464
%466 = zext i8 %465 to i32
store i32 %466, i32* %22
br label %467
467: ; preds = %544, %452
%468 = load i32, i32* %16
%469 = icmp sle i32 0, %468
br i1 %469, label %470, label %545
470: ; preds = %467
%471 = load i32, i32* %16
%472 = add nsw i32 %471, -1
store i32 %472, i32* %16
%473 = load i32, i32* %22
store i32 %473, i32* %23
br label %474
474: ; preds = %489, %470
%475 = load i32, i32* %16
%476 = icmp sle i32 0, %475
br i1 %476, label %477, label %486
477: ; preds = %474
%478 = load i8*, i8** %7
%479 = load i32, i32* %16
%480 = sext i32 %479 to i64
%481 = getelementptr inbounds i8, i8* %478, i64 %480
%482 = load i8, i8* %481
%483 = zext i8 %482 to i32
store i32 %483, i32* %22
%484 = load i32, i32* %23
%485 = icmp sge i32 %483, %484
br label %486
486: ; preds = %477, %474
%487 = phi i1 [ false, %474 ], [ %485, %477 ]
br i1 %487, label %488, label %493
488: ; preds = %486
br label %489
489: ; preds = %488
%490 = load i32, i32* %16
%491 = add nsw i32 %490, -1
store i32 %491, i32* %16
%492 = load i32, i32* %22
store i32 %492, i32* %23
br label %474
493: ; preds = %486
%494 = load i32, i32* %16
%495 = icmp sle i32 0, %494
br i1 %495, label %496, label %544
496: ; preds = %493
%497 = load i32, i32* %16
store i32 %497, i32* %19
%498 = load i32, i32* %16
%499 = add nsw i32 %498, -1
store i32 %499, i32* %16
%500 = load i32, i32* %22
store i32 %500, i32* %23
br label %501
501: ; preds = %516, %496
%502 = load i32, i32* %16
%503 = icmp sle i32 0, %502
br i1 %503, label %504, label %513
504: ; preds = %501
%505 = load i8*, i8** %7
%506 = load i32, i32* %16
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds i8, i8* %505, i64 %507
%509 = load i8, i8* %508
%510 = zext i8 %509 to i32
store i32 %510, i32* %22
%511 = load i32, i32* %23
%512 = icmp sle i32 %510, %511
br label %513
513: ; preds = %504, %501
%514 = phi i1 [ false, %501 ], [ %512, %504 ]
br i1 %514, label %515, label %520
515: ; preds = %513
br label %516
516: ; preds = %515
%517 = load i32, i32* %16
%518 = add nsw i32 %517, -1
store i32 %518, i32* %16
%519 = load i32, i32* %22
store i32 %519, i32* %23
br label %501
520: ; preds = %513
%521 = load i32, i32* %19
%522 = icmp eq i32 %521, 0
br i1 %522, label %528, label %523
523: ; preds = %520
%524 = load i32, i32* %19
%525 = load i32, i32* %16
%526 = sub nsw i32 %524, %525
%527 = icmp slt i32 1, %526
br i1 %527, label %528, label %530
528: ; preds = %523, %520
%529 = load i32, i32* %19
br label %533
530: ; preds = %523
%531 = load i32, i32* %19
%532 = xor i32 %531, -1
br label %533
533: ; preds = %530, %528
%534 = phi i32 [ %529, %528 ], [ %532, %530 ]
%535 = load i32*, i32** %8
%536 = load i32*, i32** %14
%537 = load i32, i32* %17
%538 = add nsw i32 %537, -1
store i32 %538, i32* %17
%539 = sext i32 %538 to i64
%540 = getelementptr inbounds i32, i32* %536, i64 %539
%541 = load i32, i32* %540
%542 = sext i32 %541 to i64
%543 = getelementptr inbounds i32, i32* %535, i64 %542
store i32 %534, i32* %543
br label %544
544: ; preds = %533, %493
br label %467
545: ; preds = %467
%546 = load i32, i32* %11
%547 = load i32*, i32** %10
%548 = getelementptr inbounds i32, i32* %547, i64 65535
store i32 %546, i32* %548
store i32 254, i32* %22
%549 = load i32, i32* %20
%550 = sub nsw i32 %549, 1
store i32 %550, i32* %18
br label %551
551: ; preds = %645, %545
%552 = load i32, i32* %22
%553 = icmp sle i32 0, %552
br i1 %553, label %554, label %648
554: ; preds = %551
%555 = load i32*, i32** %9
%556 = load i32, i32* %22
%557 = add nsw i32 %556, 1
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds i32, i32* %555, i64 %558
%560 = load i32, i32* %559
%561 = sub nsw i32 %560, 1
store i32 %561, i32* %16
store i32 255, i32* %23
br label %562
562: ; preds = %614, %554
%563 = load i32, i32* %22
%564 = load i32, i32* %23
%565 = icmp slt i32 %563, %564
br i1 %565, label %566, label %617
566: ; preds = %562
%567 = load i32, i32* %16
%568 = load i32*, i32** %10
%569 = load i32, i32* %23
%570 = shl i32 %569, 8
%571 = load i32, i32* %22
%572 = or i32 %570, %571
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds i32, i32* %568, i64 %573
%575 = load i32, i32* %574
%576 = sub nsw i32 %567, %575
store i32 %576, i32* %19
%577 = load i32, i32* %16
%578 = load i32*, i32** %10
%579 = load i32, i32* %23
%580 = shl i32 %579, 8
%581 = load i32, i32* %22
%582 = or i32 %580, %581
%583 = sext i32 %582 to i64
%584 = getelementptr inbounds i32, i32* %578, i64 %583
store i32 %577, i32* %584
%585 = load i32, i32* %19
store i32 %585, i32* %16
%586 = load i32*, i32** %10
%587 = load i32, i32* %22
%588 = shl i32 %587, 8
%589 = load i32, i32* %23
%590 = or i32 %588, %589
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds i32, i32* %586, i64 %591
%593 = load i32, i32* %592
store i32 %593, i32* %17
br label %594
594: ; preds = %608, %566
%595 = load i32, i32* %17
%596 = load i32, i32* %18
%597 = icmp sle i32 %595, %596
br i1 %597, label %598, label %613
598: ; preds = %594
%599 = load i32*, i32** %8
%600 = load i32, i32* %18
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds i32, i32* %599, i64 %601
%603 = load i32, i32* %602
%604 = load i32*, i32** %8
%605 = load i32, i32* %16
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds i32, i32* %604, i64 %606
store i32 %603, i32* %607
br label %608
608: ; preds = %598
%609 = load i32, i32* %16
%610 = add nsw i32 %609, -1
store i32 %610, i32* %16
%611 = load i32, i32* %18
%612 = add nsw i32 %611, -1
store i32 %612, i32* %18
br label %594
613: ; preds = %594
br label %614
614: ; preds = %613
%615 = load i32, i32* %23
%616 = add nsw i32 %615, -1
store i32 %616, i32* %23
br label %562
617: ; preds = %562
%618 = load i32, i32* %16
%619 = load i32*, i32** %10
%620 = load i32, i32* %22
%621 = shl i32 %620, 8
%622 = load i32, i32* %22
%623 = or i32 %621, %622
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds i32, i32* %619, i64 %624
%626 = load i32, i32* %625
%627 = sub nsw i32 %618, %626
%628 = add nsw i32 %627, 1
%629 = load i32*, i32** %10
%630 = load i32, i32* %22
%631 = shl i32 %630, 8
%632 = load i32, i32* %22
%633 = add nsw i32 %632, 1
%634 = or i32 %631, %633
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds i32, i32* %629, i64 %635
store i32 %628, i32* %636
%637 = load i32, i32* %16
%638 = load i32*, i32** %10
%639 = load i32, i32* %22
%640 = shl i32 %639, 8
%641 = load i32, i32* %22
%642 = or i32 %640, %641
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds i32, i32* %638, i64 %643
store i32 %637, i32* %644
br label %645
645: ; preds = %617
%646 = load i32, i32* %22
%647 = add nsw i32 %646, -1
store i32 %647, i32* %22
br label %551
648: ; preds = %551
br label %649
649: ; preds = %648, %210
%650 = load i32, i32* %20
ret i32 %650
}

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