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


x86 assembly (clang, -O0):
<LMSsort2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x20(%rbp),%rax
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    0x10(%rbp),%edx
xor    %ecx,%ecx
call   1040 <getBuckets@plt>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x58(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    11aa <LMSsort2+0x8a>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
jmp    11b9 <LMSsort2+0x99>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x64(%rbp),%edx
mov    %edx,-0x50(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    1203 <LMSsort2+0xe3>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    1212 <LMSsort2+0xf2>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x50(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,-0x44(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1249 <LMSsort2+0x129>
mov    -0x40(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
jmp    124f <LMSsort2+0x12f>
mov    -0x40(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    14f2 <LMSsort2+0x3d2>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x40(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jge    14bf <LMSsort2+0x39f>
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     12b5 <LMSsort2+0x195>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    12d6 <LMSsort2+0x1b6>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
jmp    12e5 <LMSsort2+0x1c5>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x74(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    1311 <LMSsort2+0x1f1>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x78(%rbp)
jmp    1325 <LMSsort2+0x205>
mov    -0x8(%rbp),%rax
mov    -0x40(%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
setge  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    135b <LMSsort2+0x23b>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
jmp    136a <LMSsort2+0x24a>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmp    -0x50(%rbp),%eax
je     13b5 <LMSsort2+0x295>
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x4c(%rbp),%edx
mov    %edx,-0x50(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%rdx
sub    %rdx,%rcx
sar    $0x2,%rcx
cmp    %rcx,%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x80(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    1414 <LMSsort2+0x2f4>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
jmp    1426 <LMSsort2+0x306>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x84(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x84(%rbp),%ecx
cmp    -0x50(%rbp),%ecx
setl   %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x48(%rbp),%eax
je     146b <LMSsort2+0x34b>
mov    -0x2c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x48(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     148b <LMSsort2+0x36b>
mov    -0x40(%rbp),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
jmp    1494 <LMSsort2+0x374>
mov    -0x40(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    14df <LMSsort2+0x3bf>
cmpl   $0x0,-0x40(%rbp)
jge    14da <LMSsort2+0x3ba>
mov    -0x40(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    14df <LMSsort2+0x3bf>
jmp    14e4 <LMSsort2+0x3c4>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1271 <LMSsort2+0x151>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
xor    %eax,%eax
cmp    -0x3c(%rbp),%eax
jg     159f <LMSsort2+0x47f>
mov    -0x10(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jge    158c <LMSsort2+0x46c>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x2c(%rbp),%eax
jge    1587 <LMSsort2+0x467>
mov    -0x2c(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
add    (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x2c(%rbp),%eax
jge    156e <LMSsort2+0x44e>
jmp    1560 <LMSsort2+0x440>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
jmp    1547 <LMSsort2+0x427>
mov    -0x2c(%rbp),%esi
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
sub    %esi,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    158c <LMSsort2+0x46c>
jmp    1591 <LMSsort2+0x471>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    14fb <LMSsort2+0x3db>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    0x10(%rbp),%edx
mov    $0x1,%ecx
call   1040 <getBuckets@plt>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movl   $0x0,-0x50(%rbp)
movslq (%rcx),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
xor    %eax,%eax
cmp    -0x3c(%rbp),%eax
jg     1869 <LMSsort2+0x749>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    %ecx,-0x40(%rbp)
xor    %eax,%eax
cmp    %ecx,%eax
jge    1856 <LMSsort2+0x736>
mov    -0x2c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1626 <LMSsort2+0x506>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x40(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    164a <LMSsort2+0x52a>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x8c(%rbp)
jmp    165c <LMSsort2+0x53c>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    %eax,-0x90(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    1691 <LMSsort2+0x571>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x94(%rbp)
jmp    16a8 <LMSsort2+0x588>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x94(%rbp)
mov    -0x90(%rbp),%eax
mov    -0x94(%rbp),%ecx
cmp    %ecx,%eax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    16e7 <LMSsort2+0x5c7>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x98(%rbp)
jmp    16f9 <LMSsort2+0x5d9>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmp    -0x50(%rbp),%eax
je     1747 <LMSsort2+0x627>
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x4c(%rbp),%edx
mov    %edx,-0x50(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
movslq -0x3c(%rbp),%rcx
cmp    %rcx,%rax
setle  %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x40(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x9c(%rbp)
movslq 0x18(%rbp),%rax
cmp    $0x4,%rax
jne    17a9 <LMSsort2+0x689>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa0(%rbp)
jmp    17bb <LMSsort2+0x69b>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x9c(%rbp),%eax
mov    -0xa0(%rbp),%ecx
cmp    -0x50(%rbp),%ecx
setg   %cl
and    $0x1,%cl
movzbl %cl,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x48(%rbp),%eax
je     1803 <LMSsort2+0x6e3>
mov    -0x2c(%rbp),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x48(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1826 <LMSsort2+0x706>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
xor    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    182f <LMSsort2+0x70f>
mov    -0x40(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x38(%rbp)
mov    %ecx,-0x4(%rax)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    185b <LMSsort2+0x73b>
mov    -0x3c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x3c(%rbp)
jmp    15e3 <LMSsort2+0x4c3>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LMSsort2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9d,%r12d
mov    %r8,0x40(%rsp)
mov    %rcx,%rbp
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r15
mov    0x98(%rsp),%eax
mov    %eax,0xc(%rsp)
mov    0x90(%rsp),%r13d
xor    %edi,%edi
cmp    %rcx,%rdx
setne  %dil
call   1030 <assert@plt>
mov    %r14,0x50(%rsp)
mov    %r14,%rdi
mov    %rbp,0x28(%rsp)
mov    %rbp,%rsi
mov    %r13d,0x3c(%rsp)
mov    %r13d,%edx
xor    %ecx,%ecx
call   1040 <getBuckets@plt>
lea    -0x1(%r12),%edi
movslq %edi,%rax
movslq %r12d,%rsi
cmpl   $0x4,0xc(%rsp)
jne    11a5 <LMSsort2+0x85>
mov    (%r15,%rax,4),%r8d
movslq %r8d,%rcx
lea    -0x2(%rsi),%eax
mov    -0x8(%r15,%rsi,4),%edx
jmp    11b9 <LMSsort2+0x99>
movzbl (%r15,%rax,1),%ecx
movzbl -0x2(%r15,%rsi,1),%edx
add    $0xfffffffffffffffe,%rsi
mov    %esi,%eax
mov    %ecx,%r8d
mov    0x28(%rsp),%rsi
movslq (%rsi,%rcx,4),%rcx
xor    %esi,%esi
cmp    %r8d,%edx
setl   %sil
add    %r12d,%eax
neg    %esi
xor    %eax,%esi
mov    %esi,(%rbx,%rcx,4)
test   %r12d,%r12d
jle    13d4 <LMSsort2+0x2b4>
mov    %edi,0x4c(%rsp)
lea    (%rbx,%rcx,4),%rsi
add    $0x4,%rsi
mov    %r12d,%eax
mov    %rax,0x30(%rsp)
xor    %r13d,%r13d
xor    %ebp,%ebp
mov    %r15,0x10(%rsp)
jmp    1231 <LMSsort2+0x111>
xchg   %ax,%ax
mov    0x10(%rsp),%r15
mov    0x18(%rsp),%rsi
xor    %edx,%edx
cmp    %r8d,%ecx
setl   %dl
neg    %edx
xor    %eax,%edx
mov    %edx,(%rsi)
add    $0x4,%rsi
xor    %eax,%eax
mov    %eax,(%rbx,%r13,4)
add    $0x1,%r13
cmp    %r13,0x30(%rsp)
je     1385 <LMSsort2+0x265>
mov    (%rbx,%r13,4),%eax
test   %eax,%eax
jle    12a0 <LMSsort2+0x180>
mov    %ebp,0x18(%rsp)
xor    %ebp,%ebp
cmp    %r12d,%eax
mov    %r12d,%ecx
mov    $0x0,%edx
cmovl  %edx,%ecx
setge  %dl
sub    %ecx,%eax
movslq %eax,%r14
cmpl   $0x4,0xc(%rsp)
mov    %r8d,0x20(%rsp)
mov    %dl,0xb(%rsp)
jne    12b0 <LMSsort2+0x190>
mov    (%r15,%r14,4),%eax
xor    %edi,%edi
cmp    0x4(%r15,%r14,4),%eax
setge  %dil
mov    %rsi,%r15
call   1030 <assert@plt>
mov    %r15,%rdx
mov    0x20(%rsp),%eax
mov    0x10(%rsp),%rcx
mov    (%rcx,%r14,4),%r15d
cmp    %eax,%r15d
jne    12de <LMSsort2+0x1be>
jmp    12ff <LMSsort2+0x1df>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
jns    1222 <LMSsort2+0x102>
not    %eax
jmp    121e <LMSsort2+0xfe>
nopl   0x0(%rax)
movzbl (%r15,%r14,1),%eax
xor    %edi,%edi
cmp    0x1(%r15,%r14,1),%al
setae  %dil
mov    %rsi,%r15
call   1030 <assert@plt>
mov    %r15,%rdx
mov    0x20(%rsp),%eax
mov    0x10(%rsp),%rcx
movzbl (%rcx,%r14,1),%r15d
cmp    %eax,%r15d
je     12ff <LMSsort2+0x1df>
sub    %rbx,%rdx
shr    $0x2,%rdx
cltq
mov    0x28(%rsp),%rcx
mov    %edx,(%rcx,%rax,4)
movslq %r15d,%rax
movslq (%rcx,%rax,4),%rax
lea    (%rbx,%rax,4),%rdx
mov    %r15d,0x20(%rsp)
movzbl 0xb(%rsp),%eax
mov    %al,%bpl
mov    0x18(%rsp),%eax
add    %ebp,%eax
mov    %eax,%ebp
mov    %rdx,0x18(%rsp)
mov    %rdx,%rax
sub    %rbx,%rax
sar    $0x2,%rax
xor    %edi,%edi
cmp    %r13,%rax
setg   %dil
call   1030 <assert@plt>
lea    -0x1(%r14),%rax
add    %r15d,%r15d
cmpl   $0x4,0xc(%rsp)
jne    1350 <LMSsort2+0x230>
mov    0x10(%rsp),%rcx
mov    -0x4(%rcx,%r14,4),%ecx
jmp    1359 <LMSsort2+0x239>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rcx
movzbl (%rcx,%rax,1),%ecx
mov    0x40(%rsp),%rsi
mov    0x20(%rsp),%r8d
xor    %edx,%edx
cmp    %r8d,%ecx
setl   %dl
or     %edx,%r15d
movslq %r15d,%rdx
cmp    %ebp,(%rsi,%rdx,4)
je     1200 <LMSsort2+0xe0>
add    %r12d,%eax
mov    %ebp,(%rsi,%rdx,4)
jmp    1200 <LMSsort2+0xe0>
test   %r12d,%r12d
mov    0x4c(%rsp),%r14d
jle    13d4 <LMSsort2+0x2b4>
mov    %r14d,%ecx
jmp    13a9 <LMSsort2+0x289>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x1(%rcx),%eax
test   %ecx,%ecx
mov    %eax,%ecx
jle    13fa <LMSsort2+0x2da>
mov    %ecx,%eax
mov    (%rbx,%rax,4),%edx
test   %edx,%edx
jle    13a0 <LMSsort2+0x280>
cmp    %r12d,%edx
jge    13a0 <LMSsort2+0x280>
add    %r12d,%edx
mov    %edx,(%rbx,%rax,4)
nopl   (%rax)
mov    -0x4(%rbx,%rax,4),%ecx
add    $0xffffffffffffffff,%rax
sub    %r12d,%ecx
jl     13c0 <LMSsort2+0x2a0>
mov    %ecx,(%rbx,%rax,4)
mov    %eax,%ecx
jmp    13a0 <LMSsort2+0x280>
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x3c(%rsp),%edx
mov    $0x1,%ecx
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <getBuckets@plt>
mov    %ebp,0x18(%rsp)
mov    0x50(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x3c(%rsp),%edx
mov    $0x1,%ecx
call   1040 <getBuckets@plt>
test   %r12d,%r12d
jle    15a9 <LMSsort2+0x489>
mov    0x28(%rsp),%rax
movslq (%rax),%rax
lea    (%rbx,%rax,4),%r15
addl   $0x1,0x18(%rsp)
mov    %r14d,%ebp
xor    %r8d,%r8d
jmp    146c <LMSsort2+0x34c>
nopl   0x0(%rax,%rax,1)
mov    $0xfffffffe,%edx
sub    %eax,%edx
cmp    %r8d,%ecx
cmovle %eax,%edx
mov    %edx,-0x4(%r15)
add    $0xfffffffffffffffc,%r15
movl   $0x0,(%rbx,%rbp,4)
lea    -0x1(%rbp),%rax
test   %rbp,%rbp
mov    %rax,%rbp
jle    15a9 <LMSsort2+0x489>
mov    (%rbx,%rbp,4),%eax
test   %eax,%eax
jle    145c <LMSsort2+0x33c>
mov    %r15,0x20(%rsp)
cmp    %r12d,%eax
mov    %r12d,%ecx
mov    $0x0,%edx
cmovl  %edx,%ecx
setge  %dl
sub    %ecx,%eax
movslq %eax,%r14
cmpl   $0x4,0xc(%rsp)
mov    %dl,0xb(%rsp)
jne    14f0 <LMSsort2+0x3d0>
mov    0x10(%rsp),%r13
mov    0x0(%r13,%r14,4),%eax
xor    %edi,%edi
cmp    0x4(%r13,%r14,4),%eax
setle  %dil
mov    %r8d,%r15d
call   1030 <assert@plt>
mov    %r15d,%eax
mov    0x0(%r13,%r14,4),%r13d
cmp    %eax,%r13d
je     151c <LMSsort2+0x3fc>
mov    0x20(%rsp),%r15
sub    %rbx,%r15
shr    $0x2,%r15
cltq
mov    0x28(%rsp),%rcx
mov    %r15d,(%rcx,%rax,4)
movslq %r13d,%rax
movslq (%rcx,%rax,4),%rax
lea    (%rbx,%rax,4),%r15
mov    %r13d,0x30(%rsp)
jmp    1525 <LMSsort2+0x405>
nopl   0x0(%rax)
mov    0x10(%rsp),%r13
movzbl 0x0(%r13,%r14,1),%eax
xor    %edi,%edi
cmp    0x1(%r13,%r14,1),%al
setbe  %dil
mov    %r8d,%r15d
call   1030 <assert@plt>
mov    %r15d,%eax
movzbl 0x0(%r13,%r14,1),%r13d
cmp    %eax,%r13d
jne    14c3 <LMSsort2+0x3a3>
mov    %eax,0x30(%rsp)
mov    0x20(%rsp),%r15
xor    %eax,%eax
movzbl 0xb(%rsp),%ecx
mov    %cl,%al
add    %eax,0x18(%rsp)
mov    %r15,%rax
sub    %rbx,%rax
sar    $0x2,%rax
xor    %edi,%edi
cmp    %rbp,%rax
setle  %dil
call   1030 <assert@plt>
lea    -0x1(%r14),%rax
add    %r13d,%r13d
cmpl   $0x4,0xc(%rsp)
jne    1570 <LMSsort2+0x450>
mov    0x10(%rsp),%rcx
mov    -0x4(%rcx,%r14,4),%ecx
jmp    1579 <LMSsort2+0x459>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x10(%rsp),%rcx
movzbl (%rcx,%rax,1),%ecx
mov    0x40(%rsp),%rsi
mov    0x30(%rsp),%r8d
xor    %edx,%edx
cmp    %r8d,%ecx
setg   %dl
or     %edx,%r13d
movslq %r13d,%rdx
mov    0x18(%rsp),%edi
cmp    %edi,(%rsi,%rdx,4)
je     1440 <LMSsort2+0x320>
add    %r12d,%eax
mov    %edi,(%rsi,%rdx,4)
jmp    1440 <LMSsort2+0x320>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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