#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 LMSpostproc1(const void *T, int *SA, int n, int m, int cs) {
  int i, j, p, q, plen, qlen, name;
  int 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(int) ? ((int *)T)[(n - 1)] : ((unsigned char *)T)[(n - 1)]);
  do {
    c1 = c0;
  } while ((0 <= --i) &&
           ((c0 = (cs == sizeof(int) ? ((int *)T)[(i)]
                                     : ((unsigned char *)T)[(i)])) >= c1));
  for (; 0 <= i;) {
    do {
      c1 = c0;
    } while ((0 <= --i) &&
             ((c0 = (cs == sizeof(int) ? ((int *)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(int) ? ((int *)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(int) ? ((int *)T)[(p + j)]
                                             : ((unsigned char *)T)[(p + j)]) ==
                          (cs == sizeof(int) ? ((int *)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>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
xor    %eax,%eax
cmp    -0x14(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
cmp    $0x0,%eax
jge    118f <LMSpostproc1+0x7f>
mov    -0x28(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
cmp    -0x14(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1143 <LMSpostproc1+0x33>
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    122c <LMSpostproc1+0x11c>
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
and    $0x1,%al
movzbl %al,%edi
call   1030 <assert@plt>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
cmp    $0x0,%eax
jge    1214 <LMSpostproc1+0x104>
mov    -0x28(%rbp),%edx
xor    $0xffffffff,%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    120f <LMSpostproc1+0xff>
jmp    1227 <LMSpostproc1+0x117>
jmp    1214 <LMSpostproc1+0x104>
jmp    1219 <LMSpostproc1+0x109>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11aa <LMSpostproc1+0x9a>
jmp    122c <LMSpostproc1+0x11c>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
movslq -0x1c(%rbp),%rax
cmp    $0x4,%rax
jne    1264 <LMSpostproc1+0x154>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
jmp    1278 <LMSpostproc1+0x168>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%edx
add    $0xffffffff,%edx
mov    %edx,-0x20(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %edx,%ecx
mov    %al,-0x49(%rbp)
jg     12db <LMSpostproc1+0x1cb>
movslq -0x1c(%rbp),%rax
cmp    $0x4,%rax
jne    12bd <LMSpostproc1+0x1ad>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
jmp    12cc <LMSpostproc1+0x1bc>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmp    -0x40(%rbp),%eax
setge  %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    127e <LMSpostproc1+0x16e>
jmp    12eb <LMSpostproc1+0x1db>
xor    %eax,%eax
cmp    -0x20(%rbp),%eax
jg     1407 <LMSpostproc1+0x2f7>
jmp    12fb <LMSpostproc1+0x1eb>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%edx
add    $0xffffffff,%edx
mov    %edx,-0x20(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %edx,%ecx
mov    %al,-0x51(%rbp)
jg     1358 <LMSpostproc1+0x248>
movslq -0x1c(%rbp),%rax
cmp    $0x4,%rax
jne    133a <LMSpostproc1+0x22a>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x58(%rbp)
jmp    1349 <LMSpostproc1+0x239>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmp    -0x40(%rbp),%eax
setle  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    12fb <LMSpostproc1+0x1eb>
xor    %eax,%eax
cmp    -0x20(%rbp),%eax
jg     1402 <LMSpostproc1+0x2f2>
mov    -0x24(%rbp),%edx
sub    -0x20(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%esi
add    $0x1,%esi
sar    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%edx
add    $0xffffffff,%edx
mov    %edx,-0x20(%rbp)
xor    %eax,%eax
xor    %ecx,%ecx
cmp    %edx,%ecx
mov    %al,-0x59(%rbp)
jg     13f2 <LMSpostproc1+0x2e2>
movslq -0x1c(%rbp),%rax
cmp    $0x4,%rax
jne    13d4 <LMSpostproc1+0x2c4>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
jmp    13e3 <LMSpostproc1+0x2d3>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmp    -0x40(%rbp),%eax
setge  %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    1395 <LMSpostproc1+0x285>
jmp    1402 <LMSpostproc1+0x2f2>
jmp    12eb <LMSpostproc1+0x1db>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1596 <LMSpostproc1+0x486>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x28(%rbp),%edx
sar    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x34(%rbp),%eax
jne    1551 <LMSpostproc1+0x441>
mov    -0x2c(%rbp),%eax
add    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1551 <LMSpostproc1+0x441>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
xor    %eax,%eax
cmp    -0x30(%rbp),%ecx
mov    %al,-0x61(%rbp)
jge    1516 <LMSpostproc1+0x406>
movslq -0x1c(%rbp),%rax
cmp    $0x4,%rax
jne    14b4 <LMSpostproc1+0x3a4>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x68(%rbp)
jmp    14c8 <LMSpostproc1+0x3b8>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
movslq -0x1c(%rbp),%rax
cmp    $0x4,%rax
jne    14f4 <LMSpostproc1+0x3e4>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
jmp    1508 <LMSpostproc1+0x3f8>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    1526 <LMSpostproc1+0x416>
jmp    1539 <LMSpostproc1+0x429>
jmp    152b <LMSpostproc1+0x41b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    147d <LMSpostproc1+0x36d>
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    154c <LMSpostproc1+0x43c>
movl   $0x0,-0x44(%rbp)
jmp    1551 <LMSpostproc1+0x441>
cmpl   $0x0,-0x44(%rbp)
je     1570 <LMSpostproc1+0x460>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    -0x28(%rbp),%esi
sar    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1422 <LMSpostproc1+0x312>
mov    -0x38(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LMSpostproc1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r8d,0x4(%rsp)
mov    %ecx,%ebx
mov    %edx,%r13d
mov    %rsi,%r12
mov    %rdi,0x8(%rsp)
xor    %edi,%edi
test   %edx,%edx
setg   %dil
call   1030 <assert@plt>
mov    (%r12),%eax
xor    %ebp,%ebp
test   %eax,%eax
mov    %ebx,(%rsp)
js     1150 <LMSpostproc1+0x40>
cmp    %ebx,%ebp
jl     118b <LMSpostproc1+0x7b>
jmp    11c7 <LMSpostproc1+0xb7>
movslq %r13d,%r14
mov    $0x1,%ebp
nopl   0x0(%rax,%rax,1)
not    %eax
mov    %eax,-0x4(%r12,%rbp,4)
xor    %edi,%edi
cmp    %r14,%rbp
setl   %dil
call   1030 <assert@plt>
mov    (%r12,%rbp,4),%eax
add    $0x1,%rbp
test   %eax,%eax
js     1160 <LMSpostproc1+0x50>
add    $0xffffffff,%ebp
mov    (%rsp),%ebx
cmp    %ebx,%ebp
jge    11c7 <LMSpostproc1+0xb7>
mov    %ebp,%r14d
xchg   %ax,%ax
mov    %r14,%rbx
add    $0x1,%r14
xor    %edi,%edi
cmp    %r13d,%r14d
setl   %dil
call   1030 <assert@plt>
mov    0x4(%r12,%rbx,4),%eax
test   %eax,%eax
jns    1190 <LMSpostproc1+0x80>
not    %eax
movslq %ebp,%rcx
add    $0x1,%ebp
mov    %eax,(%r12,%rcx,4)
movl   $0x0,(%r12,%r14,4)
cmp    (%rsp),%ebp
jne    1190 <LMSpostproc1+0x80>
lea    -0x1(%r13),%r11d
cmpl   $0x4,0x4(%rsp)
jne    11df <LMSpostproc1+0xcf>
movslq %r11d,%rax
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,4),%ecx
jmp    11eb <LMSpostproc1+0xdb>
movslq %r11d,%rax
mov    0x8(%rsp),%rcx
movzbl (%rcx,%rax,1),%ecx
mov    %r11d,%eax
jmp    11ff <LMSpostproc1+0xef>
mov    0x8(%rsp),%rsi
movzbl (%rsi,%rdx,1),%edi
cmp    %ecx,%edi
mov    %edi,%ecx
jl     121e <LMSpostproc1+0x10e>
test   %eax,%eax
jle    12d8 <LMSpostproc1+0x1c8>
add    $0xffffffffffffffff,%rax
mov    %eax,%edx
cmpl   $0x4,0x4(%rsp)
jne    11f0 <LMSpostproc1+0xe0>
mov    0x8(%rsp),%rsi
mov    (%rsi,%rdx,4),%edi
jmp    11f9 <LMSpostproc1+0xe9>
mov    0x8(%rsp),%rcx
lea    -0x4(%rcx),%r8
lea    -0x1(%rcx),%r9
mov    %eax,%edx
lea    (%r8,%rdx,4),%r10
lea    (%r9,%rdx,1),%r14
lea    -0x1(%rax),%ecx
xor    %esi,%esi
jmp    1252 <LMSpostproc1+0x142>
nopl   0x0(%rax)
movzbl (%r14,%rsi,1),%ebp
add    $0xffffffffffffffff,%rsi
add    $0xffffffff,%ecx
cmp    %edi,%ebp
mov    %ebp,%edi
jg     1270 <LMSpostproc1+0x160>
mov    %rdx,%rbx
add    %rsi,%rbx
je     12d8 <LMSpostproc1+0x1c8>
cmpl   $0x4,0x4(%rsp)
jne    1240 <LMSpostproc1+0x130>
mov    (%r10,%rsi,4),%ebp
jmp    1245 <LMSpostproc1+0x135>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rax),%r10d
add    %rsi,%r10
sub    %eax,%r11d
sub    %esi,%r11d
mov    %r10d,%eax
shr    %eax
add    (%rsp),%eax
cltq
mov    %r11d,(%r12,%rax,4)
add    %esi,%edx
mov    %rdx,%rax
jmp    12af <LMSpostproc1+0x19f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x8(%rsp),%rdx
movzbl (%rdx,%rcx,1),%edi
cmp    %ebp,%edi
mov    %edi,%ebp
jl     12ca <LMSpostproc1+0x1ba>
test   %eax,%eax
jle    12d8 <LMSpostproc1+0x1c8>
add    $0xffffffffffffffff,%rax
mov    %eax,%ecx
cmpl   $0x4,0x4(%rsp)
jne    12a0 <LMSpostproc1+0x190>
mov    0x8(%rsp),%rdx
mov    (%rdx,%rcx,4),%edi
jmp    12a9 <LMSpostproc1+0x199>
mov    %r10d,%r11d
test   $0x80000000,%eax
je     122b <LMSpostproc1+0x11b>
mov    (%rsp),%edi
test   %edi,%edi
jle    13f5 <LMSpostproc1+0x2e5>
mov    %edi,%ebp
xor    %edx,%edx
xor    %eax,%eax
xor    %ecx,%ecx
mov    %r13d,%r14d
mov    %rbp,0x18(%rsp)
jmp    131a <LMSpostproc1+0x20a>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%eax
mov    %eax,(%r12,%rbx,4)
add    $0x1,%rdx
mov    %r11d,%ecx
mov    %r10d,%r14d
cmp    %rbp,%rdx
je     13f7 <LMSpostproc1+0x2e7>
mov    (%r12,%rdx,4),%r10d
mov    %r10d,%esi
sar    %esi
add    %edi,%esi
movslq %esi,%rbx
mov    (%r12,%rbx,4),%r11d
cmp    %ecx,%r11d
jne    1300 <LMSpostproc1+0x1f0>
lea    (%r11,%r14,1),%esi
cmp    %r13d,%esi
jge    1300 <LMSpostproc1+0x1f0>
mov    %ecx,%ecx
test   %ecx,%ecx
jle    13c5 <LMSpostproc1+0x2b5>
mov    %rbx,0x20(%rsp)
mov    %eax,0x14(%rsp)
movslq %r10d,%rsi
movslq %r14d,%rdi
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,1),%rbp
lea    (%rax,%rdi,4),%rdi
lea    (%rax,%rsi,1),%rbx
lea    (%rax,%rsi,4),%r8
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
cmpl   $0x4,0x4(%rsp)
jne    1390 <LMSpostproc1+0x280>
mov    (%r8,%rsi,4),%r15d
mov    (%rdi,%rsi,4),%r9d
cmp    %r9d,%r15d
je     13a0 <LMSpostproc1+0x290>
jmp    13d1 <LMSpostproc1+0x2c1>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rbx,%rsi,1),%r15d
movzbl 0x0(%rbp,%rsi,1),%r9d
cmp    %r9d,%r15d
jne    13d1 <LMSpostproc1+0x2c1>
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1370 <LMSpostproc1+0x260>
mov    %r14d,%r10d
mov    %ecx,%r11d
mov    (%rsp),%edi
mov    0x18(%rsp),%rbp
mov    0x14(%rsp),%eax
mov    0x20(%rsp),%rbx
jmp    1303 <LMSpostproc1+0x1f3>
xor    %esi,%esi
cmp    %ecx,%esi
jne    1300 <LMSpostproc1+0x1f0>
jmp    13ea <LMSpostproc1+0x2da>
mov    (%rsp),%edi
mov    0x18(%rsp),%rbp
mov    0x14(%rsp),%eax
mov    0x20(%rsp),%rbx
cmp    %ecx,%esi
jne    1300 <LMSpostproc1+0x1f0>
mov    %r14d,%r10d
mov    %ecx,%r11d
jmp    1303 <LMSpostproc1+0x1f3>
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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