#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);
long long LMSpostproc1_64(const void *T, long long *SA, long long n,
                          long long m, int cs) {
  long long i, j, p, q, plen, qlen, name;
  long long c0, c1;
  long long diff;
  assert(0 < n);
  for (i = 0; (p = SA[i]) < 0; ++i) {
    SA[i] = ~p;
    assert((i + 1) < n);
  }
  if (i < m) {
    for (j = i, ++i;; ++i) {
      assert(i < n);
      if ((p = SA[i]) < 0) {
        SA[j++] = ~p;
        SA[i] = 0;
        if (j == m) {
          break;
        }
      }
    }
  }
  i = n - 1;
  j = n - 1;
  c0 = (cs == sizeof(long long) ? ((long long *)T)[(n - 1)]
                                : ((unsigned char *)T)[(n - 1)]);
  do {
    c1 = c0;
  } while ((0 <= --i) && ((c0 = (cs == sizeof(long long)
                                     ? ((long long *)T)[(i)]
                                     : ((unsigned char *)T)[(i)])) >= c1));
  for (; 0 <= i;) {
    do {
      c1 = c0;
    } while ((0 <= --i) && ((c0 = (cs == sizeof(long long)
                                       ? ((long long *)T)[(i)]
                                       : ((unsigned char *)T)[(i)])) <= c1));
    if (0 <= i) {
      SA[m + ((i + 1) >> 1)] = j - i;
      j = i + 1;
      do {
        c1 = c0;
      } while ((0 <= --i) && ((c0 = (cs == sizeof(long long)
                                         ? ((long long *)T)[(i)]
                                         : ((unsigned char *)T)[(i)])) >= c1));
    }
  }
  for (i = 0, name = 0, q = n, qlen = 0; i < m; ++i) {
    p = SA[i], plen = SA[m + (p >> 1)], diff = 1;
    if ((plen == qlen) && ((q + plen) < n)) {
      for (j = 0; (j < plen) &&
                  ((cs == sizeof(long long) ? ((long long *)T)[(p + j)]
                                            : ((unsigned char *)T)[(p + j)]) ==
                   (cs == sizeof(long long) ? ((long long *)T)[(q + j)]
                                            : ((unsigned char *)T)[(q + j)]));
           ++j) {
      }
      if (j == plen) {
        diff = 0;
      }
    }
    if (diff != 0) {
      ++name, q = p, qlen = plen;
    }
    SA[m + (p >> 1)] = name;
  }
  return name;
}


x86 assembly (clang, -O0):
<LMSpostproc1_64>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
xor    %eax,%eax
cmp    -0x18(%rbp),%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movq   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jge    11a2 <LMSpostproc1_64+0x92>
mov    -0x40(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
cmp    -0x18(%rbp),%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    114a <LMSpostproc1_64+0x3a>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1255 <LMSpostproc1_64+0x145>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
cmp    $0x0,%rax
jge    123a <LMSpostproc1_64+0x12a>
mov    -0x40(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x38(%rbp)
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jne    1235 <LMSpostproc1_64+0x125>
jmp    1250 <LMSpostproc1_64+0x140>
jmp    123a <LMSpostproc1_64+0x12a>
jmp    123f <LMSpostproc1_64+0x12f>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11c4 <LMSpostproc1_64+0xb4>
jmp    1255 <LMSpostproc1_64+0x145>
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    1294 <LMSpostproc1_64+0x184>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x80(%rbp)
jmp    12a8 <LMSpostproc1_64+0x198>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x30(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %rdx,%rcx
mov    %al,-0x81(%rbp)
jg     1328 <LMSpostproc1_64+0x218>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    12fd <LMSpostproc1_64+0x1ed>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x90(%rbp)
jmp    1310 <LMSpostproc1_64+0x200>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    %rax,-0x68(%rbp)
cmp    -0x70(%rbp),%rax
setge  %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    12b0 <LMSpostproc1_64+0x1a0>
jmp    133b <LMSpostproc1_64+0x22b>
xor    %eax,%eax
cmp    -0x30(%rbp),%rax
jg     149d <LMSpostproc1_64+0x38d>
jmp    134c <LMSpostproc1_64+0x23c>
mov    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x30(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %rdx,%rcx
mov    %al,-0x91(%rbp)
jg     13c4 <LMSpostproc1_64+0x2b4>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    1399 <LMSpostproc1_64+0x289>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xa0(%rbp)
jmp    13ac <LMSpostproc1_64+0x29c>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xa0(%rbp)
mov    -0xa0(%rbp),%rax
mov    %rax,-0x68(%rbp)
cmp    -0x70(%rbp),%rax
setle  %al
mov    %al,-0x91(%rbp)
mov    -0x91(%rbp),%al
test   $0x1,%al
jne    134c <LMSpostproc1_64+0x23c>
xor    %eax,%eax
cmp    -0x30(%rbp),%rax
jg     1498 <LMSpostproc1_64+0x388>
mov    -0x38(%rbp),%rdx
sub    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rsi
add    $0x1,%rsi
sar    $0x1,%rsi
add    %rsi,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x30(%rbp),%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x30(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %rdx,%rcx
mov    %al,-0xa1(%rbp)
jg     1485 <LMSpostproc1_64+0x375>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    145a <LMSpostproc1_64+0x34a>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb0(%rbp)
jmp    146d <LMSpostproc1_64+0x35d>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xb0(%rbp)
mov    -0xb0(%rbp),%rax
mov    %rax,-0x68(%rbp)
cmp    -0x70(%rbp),%rax
setge  %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    140d <LMSpostproc1_64+0x2fd>
jmp    1498 <LMSpostproc1_64+0x388>
jmp    133b <LMSpostproc1_64+0x22b>
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    167d <LMSpostproc1_64+0x56d>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x40(%rbp),%rdx
sar    $0x1,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
movq   $0x1,-0x78(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x58(%rbp),%rax
jne    162a <LMSpostproc1_64+0x51a>
mov    -0x48(%rbp),%rax
add    -0x50(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    162a <LMSpostproc1_64+0x51a>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x50(%rbp),%rcx
mov    %al,-0xb1(%rbp)
jge    15e6 <LMSpostproc1_64+0x4d6>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    1566 <LMSpostproc1_64+0x456>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
jmp    157d <LMSpostproc1_64+0x46d>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rax
mov    %rax,-0xc8(%rbp)
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    15b5 <LMSpostproc1_64+0x4a5>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xd0(%rbp)
jmp    15cc <LMSpostproc1_64+0x4bc>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0xd0(%rbp)
mov    -0xc8(%rbp),%rax
mov    -0xd0(%rbp),%rcx
cmp    %rcx,%rax
sete   %al
mov    %al,-0xb1(%rbp)
mov    -0xb1(%rbp),%al
test   $0x1,%al
jne    15f9 <LMSpostproc1_64+0x4e9>
jmp    160f <LMSpostproc1_64+0x4ff>
jmp    15fe <LMSpostproc1_64+0x4ee>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1526 <LMSpostproc1_64+0x416>
mov    -0x38(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    1625 <LMSpostproc1_64+0x515>
movq   $0x0,-0x78(%rbp)
jmp    162a <LMSpostproc1_64+0x51a>
cmpq   $0x0,-0x78(%rbp)
je     1651 <LMSpostproc1_64+0x541>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x40(%rbp),%rsi
sar    $0x1,%rsi
add    %rsi,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    14bd <LMSpostproc1_64+0x3ad>
mov    -0x60(%rbp),%rax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LMSpostproc1_64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8d,0x4(%rsp)
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%r14
mov    %rdi,0x8(%rsp)
xor    %edi,%edi
test   %rdx,%rdx
setg   %dil
call   1030 <assert@plt>
mov    (%r14),%rax
test   %rax,%rax
js     1151 <LMSpostproc1_64+0x41>
xor    %r15d,%r15d
cmp    %r12,%r15
jl     118c <LMSpostproc1_64+0x7c>
jmp    11c7 <LMSpostproc1_64+0xb7>
mov    $0x1,%r15d
nopw   0x0(%rax,%rax,1)
not    %rax
mov    %rax,-0x8(%r14,%r15,8)
xor    %edi,%edi
cmp    %r13,%r15
setl   %dil
call   1030 <assert@plt>
mov    (%r14,%r15,8),%rax
add    $0x1,%r15
test   %rax,%rax
js     1160 <LMSpostproc1_64+0x50>
add    $0xffffffffffffffff,%r15
cmp    %r12,%r15
jge    11c7 <LMSpostproc1_64+0xb7>
mov    %r15,%rbx
nop
mov    %rbx,%rbp
add    $0x1,%rbx
xor    %edi,%edi
cmp    %r13,%rbx
setl   %dil
call   1030 <assert@plt>
mov    0x8(%r14,%rbp,8),%rax
test   %rax,%rax
jns    1190 <LMSpostproc1_64+0x80>
not    %rax
mov    %rax,(%r14,%r15,8)
add    $0x1,%r15
movq   $0x0,(%r14,%rbx,8)
cmp    %r12,%r15
jne    1190 <LMSpostproc1_64+0x80>
lea    -0x1(%r13),%rax
cmpl   $0x8,0x4(%rsp)
jne    11de <LMSpostproc1_64+0xce>
mov    0x8(%rsp),%r8
mov    -0x8(%r8,%r13,8),%rsi
jmp    11e8 <LMSpostproc1_64+0xd8>
mov    0x8(%rsp),%r8
movzbl (%r8,%rax,1),%esi
mov    %rax,%rcx
jmp    1202 <LMSpostproc1_64+0xf2>
nopl   (%rax)
movzbl -0x1(%r8,%rcx,1),%edx
add    $0xffffffffffffffff,%rcx
cmp    %rsi,%rdx
mov    %rdx,%rsi
jl     1220 <LMSpostproc1_64+0x110>
test   %rcx,%rcx
jle    12a5 <LMSpostproc1_64+0x195>
cmpl   $0x8,0x4(%rsp)
jne    11f0 <LMSpostproc1_64+0xe0>
mov    -0x8(%r8,%rcx,8),%rdx
jmp    11f6 <LMSpostproc1_64+0xe6>
nopl   0x0(%rax)
mov    %rcx,%rdi
jmp    1241 <LMSpostproc1_64+0x131>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x1(%r8,%rdi,1),%esi
mov    %rcx,%rdi
cmp    %rdx,%rsi
mov    %rsi,%rdx
jg     1260 <LMSpostproc1_64+0x150>
sub    $0x1,%rcx
jb     12a5 <LMSpostproc1_64+0x195>
cmpl   $0x8,0x4(%rsp)
jne    1230 <LMSpostproc1_64+0x120>
mov    (%r8,%rcx,8),%rsi
jmp    1236 <LMSpostproc1_64+0x126>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rax,%rdx
sub    %rcx,%rdx
lea    0x1(%rcx),%rax
mov    %rax,%rdi
shr    %rdi
add    %r12,%rdi
mov    %rdx,(%r14,%rdi,8)
jmp    1292 <LMSpostproc1_64+0x182>
nopl   0x0(%rax)
movzbl -0x1(%r8,%rcx,1),%edx
add    $0xffffffffffffffff,%rcx
cmp    %rsi,%rdx
mov    %rdx,%rsi
jl     1220 <LMSpostproc1_64+0x110>
test   %rcx,%rcx
jle    12a5 <LMSpostproc1_64+0x195>
cmpl   $0x8,0x4(%rsp)
jne    1280 <LMSpostproc1_64+0x170>
mov    -0x8(%r8,%rcx,8),%rdx
jmp    1286 <LMSpostproc1_64+0x176>
xor    %ebp,%ebp
test   %r12,%r12
jle    139e <LMSpostproc1_64+0x28e>
xor    %edi,%edi
xor    %ecx,%ecx
mov    %r13,%r10
mov    %r12,0x10(%rsp)
jmp    12db <LMSpostproc1_64+0x1cb>
xchg   %ax,%ax
add    $0x1,%rbp
mov    %rbp,(%r14,%r9,8)
add    $0x1,%rcx
mov    %rax,%rdi
mov    %rsi,%r10
cmp    %r12,%rcx
je     139e <LMSpostproc1_64+0x28e>
mov    (%r14,%rcx,8),%rsi
mov    %rsi,%r9
sar    %r9
add    %r12,%r9
mov    (%r14,%r9,8),%rax
cmp    %rdi,%rax
jne    12c0 <LMSpostproc1_64+0x1b0>
lea    (%rax,%r10,1),%rdx
cmp    %r13,%rdx
jge    12c0 <LMSpostproc1_64+0x1b0>
test   %rdi,%rdi
mov    %rsi,0x20(%rsp)
jle    1372 <LMSpostproc1_64+0x262>
mov    %rbp,0x18(%rsp)
lea    (%r8,%r10,1),%r11
lea    (%r8,%r10,8),%rdx
lea    (%r8,%rsi,1),%r12
mov    %r8,%rbp
lea    (%r8,%rsi,8),%rbp
xor    %ebx,%ebx
xchg   %ax,%ax
cmpl   $0x8,0x4(%rsp)
jne    1340 <LMSpostproc1_64+0x230>
mov    0x0(%rbp,%rbx,8),%r15
mov    (%rdx,%rbx,8),%r8
cmp    %r8,%r15
je     134f <LMSpostproc1_64+0x23f>
jmp    1376 <LMSpostproc1_64+0x266>
nopw   0x0(%rax,%rax,1)
movzbl (%r12,%rbx,1),%r15d
movzbl (%r11,%rbx,1),%r8d
cmp    %r8,%r15
jne    1376 <LMSpostproc1_64+0x266>
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1320 <LMSpostproc1_64+0x210>
mov    %r10,%rsi
mov    %rdi,%rax
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%rbp
jmp    12c4 <LMSpostproc1_64+0x1b4>
xor    %ebx,%ebx
jmp    1385 <LMSpostproc1_64+0x275>
mov    0x10(%rsp),%r12
mov    0x8(%rsp),%r8
mov    0x18(%rsp),%rbp
cmp    %rdi,%rbx
mov    0x20(%rsp),%rsi
jne    12c0 <LMSpostproc1_64+0x1b0>
mov    %r10,%rsi
mov    %rdi,%rax
jmp    12c4 <LMSpostproc1_64+0x1b4>
mov    %rbp,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i64 @LMSpostproc1_64(i8* nocapture %0, i64* nocapture %1, i64 %2, i64 %3, i32 %4) {
%6 = icmp sgt i64 %2, 0
%7 = zext i1 %6 to i32
%8 = tail call i32 @assert(i32 %7)
%9 = load i64, i64* %1
%10 = icmp slt i64 %9, 0
br i1 %10, label %11, label %23
11: ; preds = %5, %11
%12 = phi i64 [ %21, %11 ], [ %9, %5 ]
%13 = phi i64* [ %20, %11 ], [ %1, %5 ]
%14 = phi i64 [ %16, %11 ], [ 0, %5 ]
%15 = xor i64 %12, -1
store i64 %15, i64* %13
%16 = add nuw nsw i64 %14, 1
%17 = icmp slt i64 %16, %2
%18 = zext i1 %17 to i32
%19 = tail call i32 @assert(i32 %18)
%20 = getelementptr inbounds i64, i64* %1, i64 %16
%21 = load i64, i64* %20
%22 = icmp slt i64 %21, 0
br i1 %22, label %11, label %23
23: ; preds = %11, %5
%24 = phi i64 [ 0, %5 ], [ %16, %11 ]
%25 = icmp slt i64 %24, %3
br i1 %25, label %26, label %44
26: ; preds = %23, %38
%27 = phi i64 [ %41, %38 ], [ %24, %23 ]
%28 = phi i64 [ %31, %38 ], [ %24, %23 ]
br label %29
29: ; preds = %26, %29
%30 = phi i64 [ %31, %29 ], [ %28, %26 ]
%31 = add nuw nsw i64 %30, 1
%32 = icmp slt i64 %31, %2
%33 = zext i1 %32 to i32
%34 = tail call i32 @assert(i32 %33)
%35 = getelementptr inbounds i64, i64* %1, i64 %31
%36 = load i64, i64* %35
%37 = icmp slt i64 %36, 0
br i1 %37, label %38, label %29
38: ; preds = %29
%39 = getelementptr inbounds i64, i64* %1, i64 %31
%40 = xor i64 %36, -1
%41 = add nsw i64 %27, 1
%42 = getelementptr inbounds i64, i64* %1, i64 %27
store i64 %40, i64* %42
store i64 0, i64* %39
%43 = icmp eq i64 %41, %3
br i1 %43, label %44, label %26
44: ; preds = %38, %23
%45 = add i64 %2, -1
%46 = icmp eq i32 %4, 8
br i1 %46, label %47, label %51
47: ; preds = %44
%48 = bitcast i8* %0 to i64*
%49 = getelementptr inbounds i64, i64* %48, i64 %45
%50 = load i64, i64* %49
br label %55
51: ; preds = %44
%52 = getelementptr inbounds i8, i8* %0, i64 %45
%53 = load i8, i8* %52
%54 = zext i8 %53 to i64
br label %55
55: ; preds = %51, %47
%56 = phi i64 [ %50, %47 ], [ %54, %51 ]
%57 = bitcast i8* %0 to i64*
br label %58
58: ; preds = %71, %55
%59 = phi i64 [ %45, %55 ], [ %61, %71 ]
%60 = phi i64 [ %56, %55 ], [ %72, %71 ]
%61 = add nsw i64 %59, -1
%62 = icmp sgt i64 %59, 0
br i1 %62, label %63, label %78
63: ; preds = %58
br i1 %46, label %64, label %67
64: ; preds = %63
%65 = getelementptr inbounds i64, i64* %57, i64 %61
%66 = load i64, i64* %65
br label %71
67: ; preds = %63
%68 = getelementptr inbounds i8, i8* %0, i64 %61
%69 = load i8, i8* %68
%70 = zext i8 %69 to i64
br label %71
71: ; preds = %67, %64
%72 = phi i64 [ %66, %64 ], [ %70, %67 ]
%73 = icmp slt i64 %72, %60
br i1 %73, label %74, label %58
74: ; preds = %114, %71
%75 = phi i64 [ %72, %71 ], [ %115, %114 ]
%76 = phi i64 [ %61, %71 ], [ %104, %114 ]
%77 = phi i64 [ %45, %71 ], [ %81, %114 ]
br label %80
78: ; preds = %58, %80, %101
%79 = icmp sgt i64 %3, 0
br i1 %79, label %117, label %169
80: ; preds = %74, %93
%81 = phi i64 [ %83, %93 ], [ %76, %74 ]
%82 = phi i64 [ %94, %93 ], [ %75, %74 ]
%83 = add nsw i64 %81, -1
%84 = icmp eq i64 %81, 0
br i1 %84, label %78, label %85
85: ; preds = %80
br i1 %46, label %86, label %89
86: ; preds = %85
%87 = getelementptr inbounds i64, i64* %57, i64 %83
%88 = load i64, i64* %87
br label %93
89: ; preds = %85
%90 = getelementptr inbounds i8, i8* %0, i64 %83
%91 = load i8, i8* %90
%92 = zext i8 %91 to i64
br label %93
93: ; preds = %89, %86
%94 = phi i64 [ %88, %86 ], [ %92, %89 ]
%95 = icmp sgt i64 %94, %82
br i1 %95, label %96, label %80
96: ; preds = %93
%97 = sub nsw i64 %77, %83
%98 = lshr i64 %81, 1
%99 = add nsw i64 %98, %3
%100 = getelementptr inbounds i64, i64* %1, i64 %99
store i64 %97, i64* %100
br label %101
101: ; preds = %114, %96
%102 = phi i64 [ %83, %96 ], [ %104, %114 ]
%103 = phi i64 [ %94, %96 ], [ %115, %114 ]
%104 = add nsw i64 %102, -1
%105 = icmp sgt i64 %102, 0
br i1 %105, label %106, label %78
106: ; preds = %101
br i1 %46, label %107, label %110
107: ; preds = %106
%108 = getelementptr inbounds i64, i64* %57, i64 %104
%109 = load i64, i64* %108
br label %114
110: ; preds = %106
%111 = getelementptr inbounds i8, i8* %0, i64 %104
%112 = load i8, i8* %111
%113 = zext i8 %112 to i64
br label %114
114: ; preds = %110, %107
%115 = phi i64 [ %109, %107 ], [ %113, %110 ]
%116 = icmp slt i64 %115, %103
br i1 %116, label %74, label %101
117: ; preds = %78, %163
%118 = phi i64 [ %166, %163 ], [ 0, %78 ]
%119 = phi i64 [ %165, %163 ], [ 0, %78 ]
%120 = phi i64 [ %167, %163 ], [ 0, %78 ]
%121 = phi i64 [ %164, %163 ], [ %2, %78 ]
%122 = getelementptr inbounds i64, i64* %1, i64 %120
%123 = load i64, i64* %122
%124 = ashr i64 %123, 1
%125 = add nsw i64 %124, %3
%126 = getelementptr inbounds i64, i64* %1, i64 %125
%127 = load i64, i64* %126
%128 = icmp eq i64 %127, %119
%129 = add nsw i64 %127, %121
%130 = icmp slt i64 %129, %2
%131 = select i1 %128, i1 %130, i1 false
br i1 %131, label %132, label %161
132: ; preds = %117
%133 = icmp sgt i64 %119, 0
br i1 %133, label %134, label %158
134: ; preds = %132, %155
%135 = phi i64 [ %156, %155 ], [ 0, %132 ]
%136 = add nsw i64 %135, %123
br i1 %46, label %137, label %143
137: ; preds = %134
%138 = getelementptr inbounds i64, i64* %57, i64 %136
%139 = load i64, i64* %138
%140 = add nsw i64 %135, %121
%141 = getelementptr inbounds i64, i64* %57, i64 %140
%142 = load i64, i64* %141
br label %151
143: ; preds = %134
%144 = getelementptr inbounds i8, i8* %0, i64 %136
%145 = load i8, i8* %144
%146 = zext i8 %145 to i64
%147 = add nsw i64 %135, %121
%148 = getelementptr inbounds i8, i8* %0, i64 %147
%149 = load i8, i8* %148
%150 = zext i8 %149 to i64
br label %151
151: ; preds = %143, %137
%152 = phi i64 [ %139, %137 ], [ %146, %143 ]
%153 = phi i64 [ %142, %137 ], [ %150, %143 ]
%154 = icmp eq i64 %152, %153
br i1 %154, label %155, label %158
155: ; preds = %151
%156 = add nuw nsw i64 %135, 1
%157 = icmp eq i64 %156, %119
br i1 %157, label %163, label %134
158: ; preds = %151, %132
%159 = phi i64 [ 0, %132 ], [ %135, %151 ]
%160 = icmp eq i64 %159, %119
br i1 %160, label %163, label %161
161: ; preds = %117, %158
%162 = add nsw i64 %118, 1
br label %163
163: ; preds = %155, %161, %158
%164 = phi i64 [ %123, %161 ], [ %121, %158 ], [ %121, %155 ]
%165 = phi i64 [ %127, %161 ], [ %119, %158 ], [ %119, %155 ]
%166 = phi i64 [ %162, %161 ], [ %118, %158 ], [ %118, %155 ]
store i64 %166, i64* %126
%167 = add nuw nsw i64 %120, 1
%168 = icmp eq i64 %167, %3
br i1 %168, label %169, label %117
169: ; preds = %163, %78
%170 = phi i64 [ 0, %78 ], [ %166, %163 ]
ret i64 %170
}