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

```asm
<unstargun>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x898,%rsp
  mov    %rdi,%r9
  mov    %rsi,%rbp
  mov    %rdx,%r12
  mov    %fs:0x28,%rax
  mov    %rax,0x888(%rsp)
  xor    %eax,%eax
  mov    $0x0,%ebx
  mov    $0x0,%ecx
  lea    0x80(%rsp),%rdx
  lea    0x480(%rsp),%r13
  mov    $0x0,%r14d
  test   %rsi,%rsi
  je     L127
L206:
  mov    $0x0,%eax
L92:
  mov    %eax,(%rdx,%rax,4)
  add    $0x1,%rax
  cmp    $0x100,%rax
  jne    L92
  mov    $0x0,%esi
L71:
  lea    0x1(%rcx),%eax
  mov    %ecx,%ecx
  mov    (%r9,%rcx,4),%r10d
  cmp    $0x7f,%r10d
  jle    L150
  lea    -0x7f(%r10,%rsi,1),%esi
  cmp    $0x100,%esi
  je     L113
  mov    %r14d,%r10d
L70:
  cmp    $0xff,%esi
  ja     L141
  mov    %esi,%r11d
  shl    $0x2,%r11
  lea    (%rdx,%r11,1),%r15
  add    %r13,%r11
  mov    %eax,%ecx
  mov    $0x0,%eax
  jmp    L168
L150:
  cmp    $0x100,%esi
  je     L113
  test   %r10d,%r10d
  jns    L70
  mov    %eax,%ecx
L66:
  cmp    $0xff,%esi
  jbe    L71
  mov    %ecx,%eax
L113:
  mov    %eax,%esi
  lea    0x2(%rax),%ecx
  lea    0x1(%rax),%eax
  mov    (%r9,%rax,4),%r8d
  shl    $0x8,%r8d
  or     (%r9,%rsi,4),%r8d
  mov    $0x0,%eax
  jmp    L110
L15:
  mov    %edi,%ecx
L115:
  add    $0x1,%esi
  lea    0x1(%rax),%edi
  cmp    %edi,%r10d
  jl     L66
  add    $0x1,%rax
  cmp    $0x100,%esi
  je     L141
L168:
  lea    0x1(%rcx),%edi
  mov    %ecx,%r8d
  mov    (%r9,%r8,4),%r8d
  mov    %r8d,(%r15,%rax,4)
  cmp    %esi,%r8d
  je     L15
  add    $0x2,%ecx
  mov    %edi,%edi
  mov    (%r9,%rdi,4),%edi
  mov    %edi,(%r11,%rax,4)
  jmp    L115
L34:
  sub    $0x1,%r8d
  cmp    $0xffffffff,%r8d
  je     L100
  lea    0x1(%rcx),%r10d
  mov    %ecx,%ecx
  mov    (%r9,%rcx,4),%esi
  movslq %esi,%rcx
  mov    0x80(%rsp,%rcx,4),%edi
  cmp    %esi,%edi
  je     L161
L31:
  lea    0x1(%rax),%ecx
  movslq %eax,%r11
  movslq %esi,%rsi
  mov    0x480(%rsp,%rsi,4),%esi
  mov    %esi,(%rsp,%r11,4)
  add    $0x2,%eax
  movslq %ecx,%rcx
  mov    %edi,(%rsp,%rcx,4)
  mov    %r10d,%ecx
L110:
  test   %eax,%eax
  je     L34
  sub    $0x1,%eax
  movslq %eax,%rsi
  mov    (%rsp,%rsi,4),%esi
  movslq %esi,%rdi
  mov    0x80(%rsp,%rdi,4),%edi
  cmp    %esi,%edi
  je     L210
  cmp    $0x7d,%eax
  jg     L141
  mov    %ecx,%r10d
  jmp    L31
L161:
  mov    %r10d,%ecx
L210:
  mov    %ebx,%edi
  mov    %esi,(%r12,%rdi,4)
  lea    0x1(%rbx),%ebx
  jmp    L110
L100:
  mov    %ebx,%eax
  cmp    %rbp,%rax
  jb     L206
L127:
  mov    %ebx,%eax
  sub    %ebp,%eax
  jmp    L4
L141:
  mov    $0xffffffff,%eax
L4:
  mov    0x888(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L87
  add    $0x898,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L87:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
unsigned int unstargun(const uint8_t *in, size_t expanded_size, uint8_t *out) {
  uint8_t tableA[256], tableB[256];
  unsigned int inpos = 0;
  unsigned int outpos = 0;
  int i;
  while (outpos < expanded_size) {
    for (i = 0; i < 256; i++)
      tableA[i] = i;
    uint8_t code;
    unsigned int tablepos = 0;
    do {
      code = in[inpos++];
      if (code > 127) {
        tablepos += code - 127;
        code = 0;
      }
      if (tablepos == 256)
        break;
      for (i = 0; i <= code; i++) {
        if (tablepos >= 256)
          return (-1);
        uint8_t data = in[inpos++];
        tableA[tablepos] = data;
        if (tablepos != data) {
          tableB[tablepos] = in[inpos++];
        }
        tablepos++;
      }
    } while (tablepos < 256);
    int len = in[inpos++];
    len |= in[inpos++] << 8;
    int expbufpos = 0;
    uint8_t expbuf[32];
    while (1) {
      if (expbufpos) {
        code = expbuf[--expbufpos];
      } else {
        if (--len == -1)
          break;
        code = in[inpos++];
      }
      if (code == tableA[code]) {
        out[outpos++] = code;
      } else {
        if (expbufpos >= (signed)sizeof(expbuf) - 2)
          return (-1);
        expbuf[expbufpos++] = tableB[code];
        expbuf[expbufpos++] = tableA[code];
      }
    }
  }
  return outpos - expanded_size;
}
```