user: 下面的汇编指令对应的C源代码是什么:

```asm
<runcmd_cmd2strv>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x8,%rsp
  test   %rdi,%rdi
  je     L67
  mov    %rdi,%rbx
  mov    %rsi,%r15
  mov    %rdx,%r14
  cmpb   $0x0,(%rdi)
  je     L311
  test   %rsi,%rsi
  je     L500
  test   %rdx,%rdx
  je     L500
  call   <strlen@plt>
  mov    %rax,%r13
  lea    0x1(%rax),%rdi
  call   <malloc@plt>
  mov    %rax,%r8
  test   %rax,%rax
  je     L449
  mov    %rax,(%r14)
  movq   $0x0,0x8(%r14)
  test   %r13,%r13
  je     L231
  mov    $0x0,%r12d
  mov    $0x0,%edx
  mov    $0x0,%ecx
  mov    $0x0,%esi
  mov    $0x0,%ebp
  mov    $0x0,%eax
  lea    D3(%rip),%r9
  movabs $0x4400000000000005,%r10
  jmp    L292
  test   %ebp,%ebp
  je     L505
L127:
  movslq %ebp,%rax
  movq   $0x0,(%r14,%rax,8)
  mov    %ebp,(%r15)
L16:
  mov    %r12d,%eax
  add    $0x8,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L505:
  mov    (%r14),%rdi
  call   <free@plt>
  jmp    L127
  cmp    $0x2,%edx
  je     L106
  test   $0xc,%dl
  jne    L458
  jmp    L234
L106:
  movslq %esi,%rax
  movb   $0x0,(%r8,%rax,1)
  lea    0x1(%rsi),%esi
  mov    $0x0,%edx
  jmp    L234
  test   $0x24,%dl
  jne    L458
  test   $0x8,%dl
  je     L120
  lea    0x1(%rcx),%eax
  movzbl (%rbx,%rax,1),%eax
  sub    $0x22,%eax
  cmp    $0x3e,%al
  ja     L458
  bt     %rax,%r10
  jae    L458
  or     $0x20,%edx
  jmp    L234
L120:
  add    $0x1,%ecx
  jmp    L458
  test   $0x8,%dl
  jne    L458
  test   $0x4,%dl
  jne    L72
  test   $0xfffffffd,%edx
  je     L64
L235:
  test   $0xfffffffd,%edx
  jne    L458
  test   %edx,%edx
  jne    L214
  movslq %ebp,%rdx
  movslq %esi,%rax
  add    %r8,%rax
  mov    %rax,(%r14,%rdx,8)
  lea    0x1(%rbp),%ebp
  mov    $0xa,%edx
  jmp    L234
L72:
  and    $0xfffffffb,%edx
  jmp    L234
L64:
  test   %edx,%edx
  jne    L130
  movslq %ebp,%rdx
  movslq %esi,%rax
  add    %r8,%rax
  mov    %rax,(%r14,%rdx,8)
  lea    0x1(%rbp),%ebp
  mov    $0x6,%edx
  jmp    L234
  test   $0x4,%dl
  jne    L458
  test   $0x8,%dl
  je     L235
  and    $0xfffffff7,%edx
  jmp    L234
  mov    %r12d,%eax
  or     $0x1,%eax
  test   $0xc,%dl
  cmove  %eax,%r12d
L458:
  and    $0xffffffdf,%edx
  jne    L63
  movslq %ebp,%rdx
  movslq %esi,%rax
  add    %r8,%rax
  mov    %rax,(%r14,%rdx,8)
  lea    0x1(%rbp),%ebp
  mov    $0x2,%edx
L63:
  movslq %esi,%rax
  mov    %ecx,%edi
  movzbl (%rbx,%rdi,1),%edi
  mov    %dil,(%r8,%rax,1)
  lea    0x1(%rsi),%esi
L234:
  add    $0x1,%ecx
  mov    %ecx,%eax
  cmp    %r13,%rax
  jae    L182
L292:
  add    %rbx,%rax
  cmpb   $0x7c,(%rax)
  ja     L458
  movzbl (%rax),%edi
  movslq (%r9,%rdi,4),%rdi
  add    %r9,%rdi
  notrack jmp *%rdi
  test   $0xc,%dl
  jne    L458
  or     $0x8,%r12d
  mov    $0x10,%edx
  jmp    L63
  mov    %r12d,%eax
  or     $0x2,%eax
  test   $0x24,%dl
  cmove  %eax,%r12d
  jmp    L458
  mov    %r12d,%eax
  or     $0x4,%eax
  test   $0xc,%dl
  cmove  %eax,%r12d
  jmp    L458
  test   $0x24,%dl
  jne    L458
  cmpb   $0x28,0x1(%rax)
  je     L372
  or     $0x80,%r12b
  jmp    L458
L372:
  or     $0x2,%r12d
  jmp    L458
  mov    %r12d,%eax
  or     $0x40,%eax
  test   $0xc,%dl
  cmove  %eax,%r12d
  jmp    L458
L130:
  mov    $0x6,%edx
  jmp    L234
L214:
  mov    $0xa,%edx
  jmp    L234
L182:
  movslq %esi,%rsi
  movb   $0x0,(%r8,%rsi,1)
  mov    %r12d,%eax
  or     $0x10,%eax
  test   $0x4,%dl
  cmovne %eax,%r12d
  mov    %r12d,%eax
  or     $0x20,%eax
  test   $0x8,%dl
  cmovne %eax,%r12d
L429:
  movslq %ebp,%rax
  movq   $0x0,(%r14,%rax,8)
  mov    %ebp,(%r15)
  jmp    L16
L67:
  mov    $0xfffffffb,%r12d
  jmp    L16
L311:
  mov    $0xfffffffb,%r12d
  jmp    L16
L500:
  mov    $0xfffffffb,%r12d
  jmp    L16
L449:
  mov    $0xfffffffe,%r12d
  jmp    L16
L231:
  movb   $0x0,(%rax)
  mov    $0x0,%ebp
  mov    $0x0,%r12d
  jmp    L429
```

assistant: ```c
int runcmd_cmd2strv(const char *str, int *out_argc, char **out_argv) {
  int arg = 0;
  int a = 0;
  unsigned int i;
  int state;
  int ret = 0;
  size_t len;
  char *argz;
  (state = 0);
  if (!str || !*str || !out_argc || !out_argv)
    return (-5);
  len = strlen(str);
  argz = malloc(len + 1);
  if (!argz)
    return (-2);
  out_argv[0] = argz;
  out_argv[1] = NULL;
  for (i = 0; i < len; i++) {
    const char *p = &str[i];
    switch (*p) {
    case 0:
      if (arg == 0)
        free(out_argv[0]);
      out_argv[arg] = NULL;
      *out_argc = arg;
      return ret;
    case ' ':
    case '\t':
    case '\r':
    case '\n':
      if ((state == (1 << 1))) {
        (state = 0);
        argz[a++] = 0;
        continue;
      }
      if (!(state & ((1 << 2) | (1 << 3))))
        continue;
      break;
    case '\\':
      if (((state & (1 << 2)) == (1 << 2)) || ((state & (1 << 5)) == (1 << 5))) {
        break;
      }
      if (((state & (1 << 3)) == (1 << 3))) {
        const char next = str[i + 1];
        switch (next) {
        case '"':
        case '\\':
        case '$':
        case '`':
          (state |= (1 << 5));
          continue;
        }
        break;
      }
      i++;
      break;
    case '\'':
      if (((state & (1 << 3)) == (1 << 3)))
        break;
      if (((state & (1 << 2)) == (1 << 2))) {
        (state &= ~(1 << 2));
        continue;
      }
      if ((state == 0) || (state == (1 << 1))) {
        if ((state == 0)) {
          out_argv[arg++] = &argz[a];
        }
        (state = (1 << 2) | (1 << 1));
        continue;
      }
    case '"':
      if (((state & (1 << 2)) == (1 << 2)))
        break;
      if (((state & (1 << 3)) == (1 << 3))) {
        (state &= ~(1 << 3));
        continue;
      }
      if ((state == 0) || (state == (1 << 1))) {
        if ((state == 0)) {
          out_argv[arg++] = &argz[a];
        }
        (state = (1 << 3) | (1 << 1));
        continue;
      }
      break;
    case '|':
    case '<':
    case '>':
      if (!(state & ((1 << 2) | (1 << 3)))) {
        (ret |= (1 << 0));
      }
      break;
    case '&':
    case ';':
      if (!(state & ((1 << 2) | (1 << 3)))) {
        (state = (1 << 4));
        (ret |= (1 << 3));
      }
      break;
    case '`':
      if (!((state & (1 << 2)) == (1 << 2)) && !((state & (1 << 5)) == (1 << 5))) {
        (ret |= (1 << 1));
      }
      break;
    case '(':
    case ')':
      if (!(state & ((1 << 2) | (1 << 3)))) {
        (ret |= (1 << 2));
      }
      break;
    case '$':
      if (!((state & (1 << 2)) == (1 << 2)) && !((state & (1 << 5)) == (1 << 5))) {
        if (p[1] == '(')
          (ret |= (1 << 1));
        else
          (ret |= (1 << 7));
      }
      break;
    case '*':
    case '?':
      if (!(state & ((1 << 2) | (1 << 3)))) {
        (ret |= (1 << 6));
      }
      break;
    default:
      break;
    }
    (state &= ~(1 << 5));
    if ((state == 0)) {
      (state = (1 << 1));
      out_argv[arg++] = &argz[a];
    }
    argz[a++] = str[i];
  }
  argz[a++] = 0;
  if (((state & (1 << 2)) == (1 << 2)))
    (ret |= (1 << 4));
  if (((state & (1 << 3)) == (1 << 3)))
    (ret |= (1 << 5));
  out_argv[arg] = NULL;
  *out_argc = arg;
  return ret;
}
```