#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 */
typedef size_t off_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
off_t LMSpostproc1(const void *T, off_t *SA, off_t n, off_t m, int cs) {
  off_t i, j, p, q, plen, qlen, name;
  off_t c0, c1;
  int 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(off_t) ? ((const off_t *)T)[(n - 1)]
                            : ((const unsigned char *)T)[(n - 1)]);
  do {
    c1 = c0;
  } while (
      (0 <= --i) &&
      ((c0 = (cs == sizeof(off_t) ? ((const off_t *)T)[(i)]
                                  : ((const unsigned char *)T)[(i)])) >= c1));
  for (; 0 <= i;) {
    do {
      c1 = c0;
    } while (
        (0 <= --i) &&
        ((c0 = (cs == sizeof(off_t) ? ((const off_t *)T)[(i)]
                                    : ((const 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(off_t)
                           ? ((const off_t *)T)[(i)]
                           : ((const 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(off_t) ? ((const off_t *)T)[(p + j)]
                                 : ((const unsigned char *)T)[(p + j)]) ==
            (cs == sizeof(off_t) ? ((const off_t *)T)[(q + j)]
                                 : ((const 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>:
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
setb   %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
jae    11a2 <LMSpostproc1+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
setb   %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+0x3a>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1255 <LMSpostproc1+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
setb   %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
jae    123a <LMSpostproc1+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+0x125>
jmp    1250 <LMSpostproc1+0x140>
jmp    123a <LMSpostproc1+0x12a>
jmp    123f <LMSpostproc1+0x12f>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11c4 <LMSpostproc1+0xb4>
jmp    1255 <LMSpostproc1+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+0x184>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x80(%rbp)
jmp    12a8 <LMSpostproc1+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)
ja     1328 <LMSpostproc1+0x218>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    12fd <LMSpostproc1+0x1ed>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x90(%rbp)
jmp    1310 <LMSpostproc1+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
setae  %al
mov    %al,-0x81(%rbp)
mov    -0x81(%rbp),%al
test   $0x1,%al
jne    12b0 <LMSpostproc1+0x1a0>
jmp    133b <LMSpostproc1+0x22b>
xor    %eax,%eax
cmp    -0x30(%rbp),%rax
ja     149d <LMSpostproc1+0x38d>
jmp    134c <LMSpostproc1+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)
ja     13c4 <LMSpostproc1+0x2b4>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    1399 <LMSpostproc1+0x289>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xa0(%rbp)
jmp    13ac <LMSpostproc1+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
setbe  %al
mov    %al,-0x91(%rbp)
mov    -0x91(%rbp),%al
test   $0x1,%al
jne    134c <LMSpostproc1+0x23c>
xor    %eax,%eax
cmp    -0x30(%rbp),%rax
ja     1498 <LMSpostproc1+0x388>
mov    -0x38(%rbp),%rdx
sub    -0x30(%rbp),%rdx
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rsi
add    $0x1,%rsi
shr    $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)
ja     1485 <LMSpostproc1+0x375>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    145a <LMSpostproc1+0x34a>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xb0(%rbp)
jmp    146d <LMSpostproc1+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
setae  %al
mov    %al,-0xa1(%rbp)
mov    -0xa1(%rbp),%al
test   $0x1,%al
jne    140d <LMSpostproc1+0x2fd>
jmp    1498 <LMSpostproc1+0x388>
jmp    133b <LMSpostproc1+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
jae    167a <LMSpostproc1+0x56a>
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
shr    $0x1,%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x50(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x58(%rbp),%rax
jne    1628 <LMSpostproc1+0x518>
mov    -0x48(%rbp),%rax
add    -0x50(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1628 <LMSpostproc1+0x518>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x50(%rbp),%rcx
mov    %al,-0xb1(%rbp)
jae    15e5 <LMSpostproc1+0x4d5>
movslq -0x24(%rbp),%rax
cmp    $0x8,%rax
jne    1565 <LMSpostproc1+0x455>
mov    -0x8(%rbp),%rax
mov    -0x40(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xc0(%rbp)
jmp    157c <LMSpostproc1+0x46c>
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    15b4 <LMSpostproc1+0x4a4>
mov    -0x8(%rbp),%rax
mov    -0x48(%rbp),%rcx
add    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xd0(%rbp)
jmp    15cb <LMSpostproc1+0x4bb>
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    15f8 <LMSpostproc1+0x4e8>
jmp    160e <LMSpostproc1+0x4fe>
jmp    15fd <LMSpostproc1+0x4ed>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1525 <LMSpostproc1+0x415>
mov    -0x38(%rbp),%rax
cmp    -0x50(%rbp),%rax
jne    1623 <LMSpostproc1+0x513>
movl   $0x0,-0x74(%rbp)
jmp    1628 <LMSpostproc1+0x518>
cmpl   $0x0,-0x74(%rbp)
je     164e <LMSpostproc1+0x53e>
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
shr    $0x1,%rsi
add    %rsi,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    14bd <LMSpostproc1+0x3ad>
mov    -0x60(%rbp),%rax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LMSpostproc1>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r8d,%ebp
mov    %rcx,%r12
mov    %rdx,%r15
mov    %rsi,%r14
mov    %rdi,%rbx
xor    %edi,%edi
test   %rdx,%rdx
setne  %dil
call   1030 <assert@plt>
test   %r12,%r12
je     1154 <LMSpostproc1+0x44>
mov    $0x1,%ebx
nop
xor    %edi,%edi
cmp    %r15,%rbx
setb   %dil
call   1030 <assert@plt>
add    $0x1,%rbx
jmp    1140 <LMSpostproc1+0x30>
lea    -0x1(%r15),%rax
cmp    $0x8,%ebp
jne    1164 <LMSpostproc1+0x54>
mov    -0x8(%rbx,%r15,8),%rsi
jmp    1168 <LMSpostproc1+0x58>
movzbl (%rbx,%rax,1),%esi
mov    %rax,%rdx
jmp    1181 <LMSpostproc1+0x71>
nopl   (%rax)
movzbl -0x1(%rbx,%rdx,1),%ecx
add    $0xffffffffffffffff,%rdx
cmp    %rsi,%rcx
mov    %rcx,%rsi
jb     1190 <LMSpostproc1+0x80>
cmp    $0x8,%ebp
jne    1170 <LMSpostproc1+0x60>
mov    -0x8(%rbx,%rdx,8),%rcx
jmp    1175 <LMSpostproc1+0x65>
nopl   (%rax)
sub    %rdx,%rax
add    $0x1,%rdx
mov    %rax,%rdi
mov    %rdx,%rax
jmp    11b5 <LMSpostproc1+0xa5>
nop
movzbl -0x2(%rbx,%rax,1),%esi
add    $0xffffffffffffffff,%rax
add    $0x1,%rdi
cmp    %rcx,%rsi
mov    %rsi,%rcx
ja     11d0 <LMSpostproc1+0xc0>
cmp    $0x8,%ebp
jne    11a0 <LMSpostproc1+0x90>
mov    -0x10(%rbx,%rax,8),%rsi
jmp    11a5 <LMSpostproc1+0x95>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rdi,(%r14,%rcx,4)
lea    -0x1(%rax),%rdx
jmp    1201 <LMSpostproc1+0xf1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rbx,%rdx,8),%rcx
add    $0xffffffffffffffff,%rdx
cmp    %rsi,%rcx
mov    %rcx,%rsi
jb     1190 <LMSpostproc1+0x80>
cmp    $0x8,%ebp
je     11f0 <LMSpostproc1+0xe0>
movzbl -0x1(%rbx,%rdx,1),%ecx
jmp    11f5 <LMSpostproc1+0xe5>

LLVM IR (-O0):
define i64 @LMSpostproc1(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 i32
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 ult 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 ult 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 i64 %37, 1
%39 = load i64, i64* %8
%40 = icmp ult 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 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 ult 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 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 ult 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 ult 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 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 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 i64 %86, 1
store i64 %87, i64* %11
%88 = load i64, i64* %8
%89 = sub 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 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 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 i64 %112, -1
store i64 %113, i64* %11
%114 = icmp ule 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 uge 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 ule 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 i64 %145, -1
store i64 %146, i64* %11
%147 = icmp ule 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 ule 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 ule 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 i64 %174, %175
%177 = load i64*, i64** %7
%178 = load i64, i64* %9
%179 = load i64, i64* %11
%180 = add i64 %179, 1
%181 = lshr i64 %180, 1
%182 = add i64 %178, %181
%183 = getelementptr inbounds i64, i64* %177, i64 %182
store i64 %176, i64* %183
%184 = load i64, i64* %11
%185 = add 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 i64 %189, -1
store i64 %190, i64* %11
%191 = icmp ule 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 uge 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 ult 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 = lshr i64 %229, 1
%231 = add i64 %228, %230
%232 = getelementptr inbounds i64, i64* %227, i64 %231
%233 = load i64, i64* %232
store i64 %233, i64* %15
store i32 1, i32* %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 i64 %238, %239
%241 = load i64, i64* %8
%242 = icmp ult 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 ult 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 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 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 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 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 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 i32 0, i32* %20
br label %303
303: ; preds = %302, %298
br label %304
304: ; preds = %303, %237, %222
%305 = load i32, i32* %20
%306 = icmp ne i32 %305, 0
br i1 %306, label %307, label %312
307: ; preds = %304
%308 = load i64, i64* %17
%309 = add 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 = lshr i64 %316, 1
%318 = add 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 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(i8* nocapture %0, i64* nocapture writeonly %1, i64 %2, i64 %3, i32 %4) {
%6 = icmp ne i64 %2, 0
%7 = zext i1 %6 to i32
%8 = tail call i32 @assert(i32 %7)
%9 = icmp eq i64 %3, 0
br i1 %9, label %16, label %10
10: ; preds = %5, %10
%11 = phi i64 [ %15, %10 ], [ 1, %5 ]
%12 = icmp ult i64 %11, %2
%13 = zext i1 %12 to i32
%14 = tail call i32 @assert(i32 %13)
%15 = add i64 %11, 1
br label %10
16: ; preds = %5
%17 = add i64 %2, -1
%18 = icmp eq i32 %4, 8
br i1 %18, label %19, label %23
19: ; preds = %16
%20 = bitcast i8* %0 to i64*
%21 = getelementptr inbounds i64, i64* %20, i64 %17
%22 = load i64, i64* %21
br label %27
23: ; preds = %16
%24 = getelementptr inbounds i8, i8* %0, i64 %17
%25 = load i8, i8* %24
%26 = zext i8 %25 to i64
br label %27
27: ; preds = %23, %19
%28 = phi i64 [ %22, %19 ], [ %26, %23 ]
%29 = bitcast i8* %0 to i64*
br label %30
30: ; preds = %41, %27
%31 = phi i64 [ %17, %27 ], [ %33, %41 ]
%32 = phi i64 [ %28, %27 ], [ %42, %41 ]
%33 = add i64 %31, -1
br i1 %18, label %34, label %37
34: ; preds = %30
%35 = getelementptr inbounds i64, i64* %29, i64 %33
%36 = load i64, i64* %35
br label %41
37: ; preds = %30
%38 = getelementptr inbounds i8, i8* %0, i64 %33
%39 = load i8, i8* %38
%40 = zext i8 %39 to i64
br label %41
41: ; preds = %37, %34
%42 = phi i64 [ %36, %34 ], [ %40, %37 ]
%43 = icmp ult i64 %42, %32
br i1 %43, label %44, label %30
44: ; preds = %77, %41
%45 = phi i64 [ %17, %41 ], [ %49, %77 ]
%46 = phi i64 [ %33, %41 ], [ %69, %77 ]
%47 = phi i64 [ %42, %41 ], [ %78, %77 ]
br label %48
48: ; preds = %44, %59
%49 = phi i64 [ %46, %44 ], [ %51, %59 ]
%50 = phi i64 [ %47, %44 ], [ %60, %59 ]
%51 = add i64 %49, -1
br i1 %18, label %52, label %55
52: ; preds = %48
%53 = getelementptr inbounds i64, i64* %29, i64 %51
%54 = load i64, i64* %53
br label %59
55: ; preds = %48
%56 = getelementptr inbounds i8, i8* %0, i64 %51
%57 = load i8, i8* %56
%58 = zext i8 %57 to i64
br label %59
59: ; preds = %55, %52
%60 = phi i64 [ %54, %52 ], [ %58, %55 ]
%61 = icmp ugt i64 %60, %50
br i1 %61, label %62, label %48
62: ; preds = %59
%63 = sub i64 %45, %51
%64 = lshr i64 %49, 1
%65 = getelementptr inbounds i64, i64* %1, i64 %64
store i64 %63, i64* %65
br label %66
66: ; preds = %77, %62
%67 = phi i64 [ %51, %62 ], [ %69, %77 ]
%68 = phi i64 [ %60, %62 ], [ %78, %77 ]
%69 = add i64 %67, -1
br i1 %18, label %70, label %73
70: ; preds = %66
%71 = getelementptr inbounds i64, i64* %29, i64 %69
%72 = load i64, i64* %71
br label %77
73: ; preds = %66
%74 = getelementptr inbounds i8, i8* %0, i64 %69
%75 = load i8, i8* %74
%76 = zext i8 %75 to i64
br label %77
77: ; preds = %73, %70
%78 = phi i64 [ %72, %70 ], [ %76, %73 ]
%79 = icmp ult i64 %78, %68
br i1 %79, label %44, label %66
}