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

```asm
<punycode_encode>:
  endbr64
  push   %r15
  mov    %rcx,%r10
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  test   %rsi,%rsi
  je     L155
  mov    %rdx,%r11
  mov    %rdi,%r13
  mov    (%rcx),%rdx
  mov    %rsi,%r14
  xor    %r15d,%r15d
  xor    %r12d,%r12d
  jmp    L111
  nopw   0x0(%rax,%rax,1)
L158:
  mov    0x0(%r13,%r12,4),%eax
  cmp    $0x7f,%eax
  jg     L130
  mov    %al,(%r11,%r15,1)
  mov    (%r10),%rdx
  add    $0x1,%r15
L130:
  add    $0x1,%r12
  cmp    %r12,%r14
  je     L148
L111:
  cmp    %r15,%rdx
  ja     L158
  mov    %r15,0x18(%rsp)
  test   %r15,%r15
  je     L37
L226:
  cmp    0x18(%rsp),%r14
  jbe    L128
  mov    (%r10),%rdx
L37:
  mov    %r11,0x28(%rsp)
  mov    0x18(%rsp),%r9
  lea    0x0(%r13,%r14,4),%r8
  xor    %esi,%esi
  mov    $0x80,%eax
  mov    $0x48,%edi
L51:
  cmp    %rdx,%r15
  jae    L128
  mov    D8(%rip),%rdx
  mov    (%rdx),%r12
  mov    %r13,%rdx
  mov    %r12,%rbx
  nopl   0x0(%rax,%rax,1)
L222:
  movslq (%rdx),%rcx
  cmp    %rcx,%rbx
  mov    %rcx,%r11
  cmovbe %rbx,%r11
  cmp    %rax,%rcx
  cmovae %r11,%rbx
  add    $0x4,%rdx
  cmp    %rdx,%r8
  jne    L222
  mov    %rbx,%rcx
  lea    0x1(%r9),%rbp
  xor    %edx,%edx
  sub    %rax,%rcx
  mov    %r12,%rax
  sub    %rsi,%rax
  div    %rbp
  cmp    %rcx,%rax
  jb     L43
  imul   %rcx,%rbp
  mov    %r14,%rax
  mov    %r8,0x20(%rsp)
  mov    %r15,%r14
  xor    %r12d,%r12d
  mov    %rax,%r15
  add    %rsi,%rbp
  jmp    L193
  nopl   (%rax)
L183:
  add    $0x1,%rbp
  je     L80
L245:
  add    $0x1,%r12
  cmp    %r12,%r15
  je     L72
L193:
  movslq 0x0(%r13,%r12,4),%rax
  cmp    %rbx,%rax
  jb     L183
  jne    L245
  mov    (%r10),%rcx
  mov    0x28(%rsp),%rax
  mov    %rbp,%rsi
  mov    %r10,0x10(%rsp)
  mov    %r9,0x8(%rsp)
  sub    %r14,%rcx
  lea    (%rax,%r14,1),%rdx
  call   <encode_var_int@plt>
  mov    0x8(%rsp),%r9
  xor    %edx,%edx
  mov    %rbp,%rdi
  add    %rax,%r14
  cmp    0x18(%rsp),%r9
  sete   %dl
  add    $0x1,%r9
  add    $0x1,%r12
  xor    %ebp,%ebp
  mov    %r9,%rsi
  mov    %r9,0x8(%rsp)
  call   <adapt_bias@plt>
  mov    0x10(%rsp),%r10
  mov    0x8(%rsp),%r9
  mov    %rax,%rdi
  cmp    %r12,%r15
  jne    L193
  cs nopw 0x0(%rax,%rax,1)
L72:
  mov    %r15,%rax
  mov    %r14,%r15
  mov    0x20(%rsp),%r8
  lea    0x1(%rbp),%rsi
  mov    %rax,%r14
  lea    0x1(%rbx),%rax
  cmp    %r14,%r9
  jae    L128
  mov    (%r10),%rdx
  jmp    L51
  nopl   0x0(%rax,%rax,1)
L80:
  xor    %edi,%edi
  mov    %r10,0x8(%rsp)
  mov    %r14,%r15
  call   <assert@plt>
  mov    0x8(%rsp),%r10
L128:
  mov    %r15,(%r10)
  add    $0x38,%rsp
  mov    %r12,%rax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L148:
  test   %r15,%r15
  je     L97
  cmp    %rdx,%r15
  jae    L247
  movb   $0x2d,(%r11,%r15,1)
  mov    %r15,0x18(%rsp)
  add    $0x1,%r15
  jmp    L226
L97:
  movq   $0x0,0x18(%rsp)
  jmp    L37
L43:
  xor    %edi,%edi
  mov    %r10,0x8(%rsp)
  mov    %r14,%r12
  call   <assert@plt>
  mov    0x8(%rsp),%r10
  jmp    L128
L155:
  xor    %r15d,%r15d
  xor    %r12d,%r12d
  jmp    L128
L247:
  mov    %r15,0x18(%rsp)
  jmp    L226
```

assistant: ```c
size_t punycode_encode(const uint32_t *const src, const size_t srclen, char *const dst, size_t *const dstlen) {
  size_t b, h;
  size_t delta, bias;
  size_t m, n;
  size_t si, di;
  for (si = 0, di = 0; si < srclen && di < *dstlen; si++) {
    if (src[si] < 128) {
      dst[di++] = src[si];
    }
  }
  b = h = di;
  if (di > 0 && di < *dstlen) {
    dst[di++] = '-';
  }
  n = 128;
  bias = 72;
  delta = 0;
  for (; h < srclen && di < *dstlen; n++, delta++) {
    for (m = SIZE_MAX, si = 0; si < srclen; si++) {
      if (src[si] >= n && src[si] < m) {
        m = src[si];
      }
    }
    if ((m - n) > (SIZE_MAX - delta) / (h + 1)) {
      assert(0 && "OVERFLOW");
      goto fail;
    }
    delta += (m - n) * (h + 1);
    n = m;
    for (si = 0; si < srclen; si++) {
      if (src[si] < n) {
        if (++delta == 0) {
          assert(0 && "OVERFLOW");
          goto fail;
        }
      } else if (src[si] == n) {
        di += encode_var_int(bias, delta, &dst[di], *dstlen - di);
        bias = adapt_bias(delta, h + 1, h == b);
        delta = 0;
        h++;
      }
    }
  }
fail:
  *dstlen = di;
  return si;
}
```