user: Demonstrate the C code that generates the assembly output below:

```asm
<LMSpostproc1>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x18,%rsp
  mov    %rdi,%rbx
  mov    %rsi,%r14
  mov    %edx,%r15d
  mov    %ecx,0x8(%rsp)
  mov    %r8d,%ebp
  test   %edx,%edx
  setg   %dil
  movzbl %dil,%edi
  call   <assert@plt>
  mov    (%r14),%eax
  test   %eax,%eax
  jns    L60
  mov    %r14,%r12
  mov    $0x0,%r13d
L290:
  not    %eax
  mov    %eax,(%r12)
  add    $0x1,%r13d
  cmp    %r15d,%r13d
  setl   %dil
  movzbl %dil,%edi
  call   <assert@plt>
  add    $0x4,%r12
  mov    (%r12),%eax
  test   %eax,%eax
  js     L290
L155:
  mov    0x8(%rsp),%eax
  cmp    %r13d,%eax
  jle    L359
  lea    0x1(%r13),%r12d
  movslq %r12d,%r12
  mov    %rbx,(%rsp)
  mov    %eax,%ebx
  jmp    L49
L60:
  mov    $0x0,%r13d
  jmp    L155
L81:
  add    $0x1,%r12
L49:
  cmp    %r12d,%r15d
  setg   %dil
  movzbl %dil,%edi
  call   <assert@plt>
  mov    (%r14,%r12,4),%eax
  test   %eax,%eax
  jns    L81
  lea    0x1(%r13),%edx
  movslq %r13d,%r13
  not    %eax
  mov    %eax,(%r14,%r13,4)
  movl   $0x0,(%r14,%r12,4)
  cmp    %edx,%ebx
  je     L94
  mov    %edx,%r13d
  jmp    L81
L94:
  mov    (%rsp),%rbx
L359:
  lea    -0x1(%r15),%r8d
  cmp    $0x4,%ebp
  je     L4
  movslq %r15d,%rax
  movzbl -0x1(%rbx,%rax,1),%esi
L367:
  lea    -0x2(%r15),%eax
  cltq
  jmp    L340
L4:
  movslq %r15d,%rax
  mov    -0x4(%rbx,%rax,4),%esi
  jmp    L367
L168:
  mov    (%rbx,%rax,4),%ecx
L82:
  sub    $0x1,%rax
  cmp    %ecx,%esi
  jg     L9
  mov    %ecx,%esi
L340:
  mov    %eax,%edx
  test   %eax,%eax
  js     L187
  cmp    $0x4,%ebp
  je     L168
  movzbl (%rbx,%rax,1),%ecx
  jmp    L82
L9:
  mov    %ecx,%esi
  jmp    L187
L273:
  mov    (%rbx,%rax,4),%ecx
L343:
  sub    $0x1,%rax
  cmp    %ecx,%esi
  jl     L353
  mov    %ecx,%esi
L27:
  lea    0x1(%rax),%edi
  mov    %eax,%edx
  test   %eax,%eax
  js     L187
  cmp    $0x4,%ebp
  je     L273
  movzbl (%rbx,%rax,1),%ecx
  jmp    L343
L350:
  mov    (%rbx,%rax,4),%esi
L236:
  sub    $0x1,%rax
  cmp    %esi,%ecx
  jg     L371
  mov    %esi,%ecx
L122:
  mov    %eax,%edx
  test   %eax,%eax
  js     L24
  cmp    $0x4,%ebp
  je     L350
  movzbl (%rbx,%rax,1),%esi
  jmp    L236
L371:
  mov    %esi,%ecx
L24:
  mov    %ecx,%esi
  mov    %edi,%r8d
L187:
  test   %edx,%edx
  js     L191
  lea    -0x1(%rdx),%eax
  cltq
  jmp    L27
L191:
  mov    0x8(%rsp),%edx
  test   %edx,%edx
  jle    L323
  mov    %r14,%rax
  lea    -0x1(%rdx),%edx
  lea    0x4(%r14,%rdx,4),%rdi
  mov    %r15d,(%rsp)
  mov    $0x0,%ecx
  mov    $0x0,%edx
  mov    %r15d,0xc(%rsp)
  mov    %rdi,%r15
  jmp    L278
L193:
  movslq %r11d,%r12
  mov    (%rbx,%r12,4),%r13d
  movslq %r10d,%r12
  mov    (%rbx,%r12,4),%r12d
L345:
  cmp    %r12d,%r13d
  jne    L365
  add    $0x1,%r9d
  add    $0x1,%r11d
  add    $0x1,%r10d
  cmp    %edx,%r9d
  je     L16
L167:
  cmp    $0x4,%ebp
  je     L193
  movslq %r11d,%r12
  movzbl (%rbx,%r12,1),%r13d
  movslq %r10d,%r12
  movzbl (%rbx,%r12,1),%r12d
  jmp    L345
L310:
  mov    $0x0,%r9d
L365:
  cmp    %edx,%r9d
  je     L16
L44:
  add    $0x1,%ecx
  mov    %r8d,%edx
  mov    %esi,(%rsp)
L16:
  mov    %ecx,(%rdi)
  add    $0x4,%rax
  cmp    %r15,%rax
  je     L46
L278:
  mov    (%rax),%esi
  mov    %esi,%edi
  sar    %edi
  add    0x8(%rsp),%edi
  movslq %edi,%rdi
  lea    (%r14,%rdi,4),%rdi
  mov    (%rdi),%r8d
  cmp    %edx,%r8d
  jne    L44
  mov    (%rsp),%r10d
  lea    (%r10,%rdx,1),%r9d
  cmp    0xc(%rsp),%r9d
  jge    L44
  test   %edx,%edx
  jle    L310
  mov    %esi,%r11d
  mov    $0x0,%r9d
  jmp    L167
L323:
  mov    $0x0,%ecx
L46:
  mov    %ecx,%eax
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L353:
  mov    %edi,%eax
  sar    %eax
  add    0x8(%rsp),%eax
  cltq
  sub    %edx,%r8d
  mov    %r8d,(%r14,%rax,4)
  lea    -0x1(%rdx),%eax
  cltq
  jmp    L122
```

assistant: ```c
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;
}
```