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

```asm
<MHD_str_remove_tokens_caseless_>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  movl   $0x0,0x2c(%rsp)
  test   %rcx,%rcx
  je     L269
  mov    %rsi,%r9
  mov    %rdi,%r8
  mov    %rdx,%rbp
  mov    %rcx,%r12
  movabs $0xffffeffefffffdff,%r14
  mov    (%r9),%r11
  xor    %edi,%edi
  test   %r11,%r11
  je     L269
  nopw   0x0(%rax,%rax,1)
L46:
  movzbl 0x0(%rbp,%rdi,1),%eax
  lea    0x0(%rbp,%rdi,1),%rsi
  cmp    $0x2c,%al
  jbe    L201
L9:
  cmp    %rdi,%r12
  jbe    L269
  mov    %rdi,%rbx
  nopw   0x0(%rax,%rax,1)
L391:
  lea    0x1(%rbx),%rdx
  cmp    %rdx,%r12
  jbe    L367
  movzbl 0x1(%rbp,%rbx,1),%eax
  mov    %rdx,%rbx
  cmp    $0x2c,%al
  ja     L391
  bt     %rax,%r14
  jae    L61
  jmp    L391
  nopl   0x0(%rax)
L35:
  add    $0x1,%rbx
  cmp    %rbx,%r12
  jbe    L390
L61:
  movzbl 0x0(%rbp,%rbx,1),%eax
  cmp    $0x20,%al
  je     L35
  cmp    $0x9,%al
  je     L35
  cmp    %r12,%rbx
  jae    L390
  cmp    $0x2c,%al
  jne    L391
L390:
  sub    %rdi,%rdx
  cmp    %rdx,%r11
  je     L12
  nop
L175:
  lea    0x2(%rdx),%rax
  cmp    %r11,%rax
  jb     L30
L147:
  cmp    %r12,%rbx
  jae    L269
  mov    (%r9),%r11
  mov    %rbx,%rdi
  test   %r11,%r11
  jne    L46
L269:
  mov    0x2c(%rsp),%eax
  add    $0x38,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L201:
  bt     %rax,%r14
  jb     L9
  add    $0x1,%rdi
  cmp    %rdi,%r12
  ja     L46
  jmp    L269
  nopl   0x0(%rax)
L367:
  mov    %rdx,%rbx
  sub    %rdi,%rdx
  cmp    %rdx,%r11
  jne    L175
L12:
  mov    %r8,%rdi
  mov    %r11,%rdx
  mov    %r9,0x8(%rsp)
  mov    %r8,(%rsp)
  call   <MHD_str_equal_caseless_bin_n_@plt>
  mov    (%rsp),%r8
  mov    0x8(%rsp),%r9
  test   %rax,%rax
  je     L147
  movq   $0x0,(%r9)
  movl   $0x1,0x2c(%rsp)
  jmp    L147
L30:
  xor    %r15d,%r15d
  xor    %r13d,%r13d
  mov    %rdx,%r10
  jmp    L98
  nopl   0x0(%rax)
L249:
  lea    (%r8,%r13,1),%rdi
  mov    %r9,0x18(%rsp)
  mov    %r8,0x10(%rsp)
  mov    %rdx,0x8(%rsp)
  mov    %rsi,(%rsp)
  mov    %r10,0x20(%rsp)
  call   <MHD_str_equal_caseless_bin_n_@plt>
  mov    (%rsp),%rsi
  mov    0x8(%rsp),%rdx
  test   %rax,%rax
  mov    0x10(%rsp),%r8
  mov    0x18(%rsp),%r9
  je     L288
  mov    0x20(%rsp),%r10
  mov    (%r9),%r11
  movl   $0x1,0x2c(%rsp)
  lea    0x2(%r10),%r13
  lea    0x0(%r13,%rdx,1),%r10
  cmp    %r11,%r10
  ja     L414
L98:
  cmp    %r11,%r10
  je     L249
  cmpb   $0x2c,(%r8,%r10,1)
  je     L249
L288:
  test   %r15,%r15
  je     L302
  lea    0x2(%r15),%rax
  cmp    %r13,%rax
  je     L248
  movb   $0x2c,(%r8,%r15,1)
  movb   $0x20,0x1(%r8,%r15,1)
  mov    %rax,%r15
  jmp    L302
  nopl   (%rax)
L310:
  cmpb   $0x2c,0x1(%r8,%r13,1)
  je     L415
  mov    %rax,%r13
L302:
  cmp    %r15,%r13
  je     L153
  movzbl (%r8,%r13,1),%eax
  mov    %al,(%r8,%r15,1)
L153:
  mov    (%r9),%r11
  lea    0x1(%r13),%rax
  add    $0x1,%r15
  cmp    %rax,%r11
  ja     L310
L415:
  add    $0x3,%r13
  lea    0x0(%r13,%rdx,1),%r10
  cmp    %r11,%r10
  jbe    L98
L414:
  cmp    %r11,%r13
  jae    L402
  mov    %r11,%rdx
  sub    %r13,%rdx
  test   %r15,%r15
  je     L192
  lea    0x2(%r15),%rax
  cmp    %r13,%rax
  je     L157
  movb   $0x2c,(%r8,%r15,1)
  lea    (%r8,%rax,1),%rdi
  movb   $0x20,0x1(%r8,%r15,1)
  lea    (%rax,%rdx,1),%r15
L306:
  lea    (%r8,%r13,1),%rsi
  mov    %r9,0x8(%rsp)
  mov    %r8,(%rsp)
  call   <memmove@plt>
  mov    (%rsp),%r8
  mov    0x8(%rsp),%r9
L402:
  mov    %r15,(%r9)
  jmp    L147
L248:
  mov    %r13,%r15
  jmp    L302
L192:
  mov    %rdx,%r15
  test   %r13,%r13
  je     L402
  mov    %r8,%rdi
  jmp    L306
L157:
  mov    %r11,%r15
  mov    %r15,(%r9)
  jmp    L147
```

assistant: ```c
int MHD_str_remove_tokens_caseless_(char *str, size_t *str_len, const char *const tokens, const size_t tokens_len) {
  const char *const t = tokens;
  size_t pt;
  int token_removed;
  ((void)0);
  token_removed = 0;
  pt = 0;
  while (pt < tokens_len && *str_len != 0) {
    const char *tkn;
    size_t tkn_len;
    while ((pt < tokens_len) && ((' ' == t[pt]) || ('\t' == t[pt]) || (',' == t[pt])))
      pt++;
    if (pt >= tokens_len)
      break;
    tkn = t + pt;
    do {
      do {
        pt++;
      } while (pt < tokens_len && (' ' != t[pt] && '\t' != t[pt] && ',' != t[pt]));
      tkn_len = pt - (size_t)(tkn - t);
      while (pt < tokens_len && (' ' == t[pt] || '\t' == t[pt]))
        pt++;
    } while (pt < tokens_len && ',' != t[pt]);
    ((void)0);
    if (*str_len == tkn_len) {
      if (MHD_str_equal_caseless_bin_n_(str, tkn, tkn_len)) {
        *str_len = 0;
        token_removed = (!0);
      }
      continue;
    }
    if (*str_len > tkn_len + 2) {
      size_t pr;
      size_t pw;
      pr = 0;
      pw = 0;
      do {
        ((void)0);
        ((void)0);
        if ((((*str_len) == (pr + tkn_len)) || (',' == str[pr + tkn_len])) && MHD_str_equal_caseless_bin_n_(str + pr, tkn, tkn_len)) {
          ((void)0);
          token_removed = (!0);
          pr += tkn_len + 2;
        } else {
          if (0 != pw) {
            if (pr != pw + 2) {
              str[pw++] = ',';
              str[pw++] = ' ';
            } else
              pw += 2;
          }
          do {
            if (pr != pw)
              str[pw] = str[pr];
            pr++;
            pw++;
          } while (pr < *str_len && ',' != str[pr]);
          pr += 2;
        }
        if ((*str_len) < (pr + tkn_len)) {
          if ((*str_len) > pr) {
            size_t copy_size;
            copy_size = *str_len - pr;
            if (0 != pw) {
              if (pr != pw + 2) {
                str[pw++] = ',';
                str[pw++] = ' ';
              } else
                pw += 2;
            }
            if (pr != pw)
              memmove(str + pw, str + pr, copy_size);
            pw += copy_size;
          }
          *str_len = pw;
          break;
        }
        ((void)0);
        ((void)0);
        ((void)0);
        ((void)0);
      } while (1);
    }
  }
  return token_removed;
}
```