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

```asm
<BASM_XCallGenRepackSigSysV>:
  endbr64
  push   %r15
  mov    %rdi,%r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x18,%rsp
  movzbl (%rdi),%eax
  cmp    $0x28,%al
  jne    L560
  movzbl 0x1(%rdi),%eax
  add    $0x1,%r15
L560:
  test   %al,%al
  je     L443
  cmp    $0x29,%al
  je     L443
  movl   $0x0,0xc(%rsp)
  xor    %ebx,%ebx
  xor    %ebp,%ebp
  xor    %r13d,%r13d
  lea    D253(%rip),%r14
  nopw   0x0(%rax,%rax,1)
L161:
  sub    $0x43,%eax
  lea    0x1(%r15),%r12
  cmp    $0x36,%al
  ja     L249
  movzbl %al,%eax
  movslq (%r14,%rax,4),%rax
  add    %r14,%rax
  notrack jmp *%rax
  nopl   0x0(%rax,%rax,1)
  mov    0xc(%rsp),%r15d
  mov    %r13d,%eax
  and    $0x1,%eax
  cmp    $0x7,%r15d
  jg     L50
  lea    0x2(%rax,%r13,1),%r13d
  movslq %r15d,%rsi
  lea    D256(%rip),%rax
  mov    (%rax,%rsi,8),%rsi
  lea    0x0(,%r13,8),%edx
  lea    D87(%rip),%rdi
L301:
  xor    %eax,%eax
  add    $0x1,%r15d
  call   <basm_print@plt>
  mov    %r15d,0xc(%rsp)
L249:
  mov    %r12,%r15
L595:
  movzbl (%r15),%eax
  test   %al,%al
  je     L157
  cmp    $0x29,%al
  jne    L161
L157:
  add    $0x18,%rsp
  mov    %r13d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
  lea    0x10(,%r13,8),%edx
  add    $0x1,%r13d
  cmp    $0x5,%ebp
  jg     L524
L85:
  movslq %ebp,%rsi
  lea    D73(%rip),%rax
  add    $0x1,%ebp
  mov    %r12,%r15
  mov    (%rax,%rsi,8),%rsi
  lea    D34(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  jmp    L595
  nopl   0x0(%rax)
  lea    0x10(,%r13,8),%edx
  add    $0x1,%r13d
  cmp    $0x5,%ebp
  jle    L85
  mov    %edx,%esi
  lea    D319(%rip),%rdi
  xor    %eax,%eax
  mov    %r12,%r15
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D171(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x1,%ebx
  jmp    L595
  nopl   0x0(%rax)
  mov    0xc(%rsp),%r15d
  lea    0x10(,%r13,8),%edx
  add    $0x1,%r13d
  cmp    $0x7,%r15d
  jg     L224
  movslq %r15d,%rsi
  lea    D256(%rip),%rax
  lea    D101(%rip),%rdi
  mov    (%rax,%rsi,8),%rsi
  jmp    L301
  nopl   (%rax)
  mov    0xc(%rsp),%r15d
  lea    0x10(,%r13,8),%edx
  add    $0x1,%r13d
  cmp    $0x7,%r15d
  jg     L570
  movslq %r15d,%rsi
  lea    D256(%rip),%rax
  lea    D200(%rip),%rdi
  mov    (%rax,%rsi,8),%rsi
  jmp    L301
  nopl   (%rax)
  lea    0x10(,%r13,8),%edx
  add    $0x1,%r13d
  cmp    $0x5,%ebp
  jle    L282
  mov    %edx,%esi
  lea    D319(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D171(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x1,%ebx
L128:
  movzbl 0x1(%r15),%eax
  cmp    $0x51,%al
  jne    L204
  xchg   %ax,%ax
L368:
  movzbl 0x1(%r12),%eax
  add    $0x1,%r12
  cmp    $0x51,%al
  je     L368
L204:
  lea    -0x61(%rax),%edx
  cmp    $0x19,%dl
  jbe    L59
  mov    %r12,%r15
  cmp    $0x4c,%al
  jne    L595
  movzbl (%r12),%eax
  cmp    $0x3b,%al
  je     L29
  test   %al,%al
  jne    L56
  jmp    L29
  nopl   0x0(%rax)
L568:
  cmp    $0x3b,%al
  je     L29
L56:
  movzbl 0x1(%r12),%eax
  add    $0x1,%r12
  test   %al,%al
  jne    L568
  nopw   0x0(%rax,%rax,1)
L29:
  xor    %r8d,%r8d
  cmp    $0x3b,%al
  sete   %r8b
  lea    (%r12,%r8,1),%r15
  jmp    L595
  nopw   0x0(%rax,%rax,1)
  lea    0x10(,%r13,8),%edx
  add    $0x1,%r13d
  cmp    $0x5,%ebp
  jle    L401
  mov    %edx,%esi
  lea    D319(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D171(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x1,%ebx
L567:
  movzbl 0x1(%r15),%eax
  cmp    $0x50,%al
  jne    L341
  xchg   %ax,%ax
L482:
  movzbl 0x1(%r12),%eax
  add    $0x1,%r12
  cmp    $0x50,%al
  je     L482
L341:
  lea    -0x61(%rax),%edx
  cmp    $0x19,%dl
  jbe    L59
  mov    %r12,%r15
  cmp    $0x58,%al
  jne    L595
  movzbl (%r12),%eax
  cmp    $0x3b,%al
  je     L29
  test   %al,%al
  jne    L144
  jmp    L29
  nopl   0x0(%rax,%rax,1)
L501:
  cmp    $0x3b,%al
  je     L29
L144:
  movzbl 0x1(%r12),%eax
  add    $0x1,%r12
  test   %al,%al
  jne    L501
  jmp    L29
  nopl   0x0(%rax,%rax,1)
  lea    0x10(,%r13,8),%edx
  add    $0x1,%r13d
  cmp    $0x5,%ebp
  jle    L252
  mov    %edx,%esi
  lea    D319(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D171(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x1,%ebx
L247:
  movzbl 0x1(%r15),%eax
  test   %al,%al
  jne    L72
  jmp    L29
  nopl   0x0(%rax,%rax,1)
L351:
  movzbl 0x1(%r12),%eax
  add    $0x1,%r12
  test   %al,%al
  je     L29
L72:
  cmp    $0x3b,%al
  jne    L351
  xor    %r8d,%r8d
  cmp    $0x3b,%al
  sete   %r8b
  lea    (%r12,%r8,1),%r15
  jmp    L595
  nopl   0x0(%rax,%rax,1)
  movzbl 0x1(%r15),%eax
  lea    0x2(%r15),%rdx
  sub    $0x64,%eax
  cmp    $0x7,%al
  ja     L461
  lea    D7(%rip),%rcx
  movzbl %al,%eax
  movslq (%rcx,%rax,4),%rax
  add    %rcx,%rax
  notrack jmp *%rax
  nopl   0x0(%rax,%rax,1)
  movzbl 0x1(%r15),%eax
  lea    0x2(%r15),%rdx
  sub    $0x64,%eax
  cmp    $0x7,%al
  ja     L461
  lea    D19(%rip),%rcx
  movzbl %al,%eax
  movslq (%rcx,%rax,4),%rax
  add    %rcx,%rax
  notrack jmp *%rax
  nopl   0x0(%rax,%rax,1)
L50:
  cmp    $0x1,%eax
  mov    %ebx,%eax
  lea    D37(%rip),%rdi
  mov    %r12,%r15
  sbb    $0xffffffff,%r13d
  and    $0x1,%eax
  cmp    $0x1,%eax
  sbb    $0xffffffff,%ebx
  add    $0x2,%r13d
  xor    %eax,%eax
  lea    0x0(,%r13,8),%esi
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D104(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x2,%ebx
  jmp    L595
  nopl   0x0(%rax)
L252:
  movslq %ebp,%rsi
  lea    D73(%rip),%rax
  add    $0x1,%ebp
  mov    (%rax,%rsi,8),%rsi
  lea    D34(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  jmp    L247
  nopl   0x0(%rax)
L401:
  movslq %ebp,%rsi
  lea    D73(%rip),%rax
  add    $0x1,%ebp
  mov    (%rax,%rsi,8),%rsi
  lea    D34(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  jmp    L567
  nopl   0x0(%rax)
L282:
  movslq %ebp,%rsi
  lea    D73(%rip),%rax
  add    $0x1,%ebp
  mov    (%rax,%rsi,8),%rsi
  lea    D34(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  jmp    L128
  nopl   0x0(%rax)
L570:
  mov    %edx,%esi
  lea    D297(%rip),%rdi
  xor    %eax,%eax
  mov    %r12,%r15
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D64(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x1,%ebx
  jmp    L595
  nopl   0x0(%rax,%rax,1)
L224:
  mov    %edx,%esi
  lea    D285(%rip),%rdi
  xor    %eax,%eax
  mov    %r12,%r15
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D63(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x1,%ebx
  jmp    L595
L524:
  mov    %edx,%esi
  lea    D117(%rip),%rdi
  xor    %eax,%eax
  mov    %r12,%r15
  call   <basm_print@plt>
  lea    0x0(,%rbx,8),%esi
  lea    D275(%rip),%rdi
  xor    %eax,%eax
  call   <basm_print@plt>
  add    $0x1,%ebx
  jmp    L595
  add    $0x4,%r13d
  mov    %rdx,%r15
  jmp    L595
  nopl   0x0(%rax)
  add    $0x20,%r13d
  mov    %rdx,%r15
  jmp    L595
  nopl   0x0(%rax)
L461:
  mov    %rdx,%r15
  jmp    L595
  nopl   0x0(%rax,%rax,1)
  add    $0x8,%r13d
  mov    %rdx,%r15
  jmp    L595
  nopl   0x0(%rax)
  add    $0x10,%r13d
  mov    %rdx,%r15
  jmp    L595
  nopl   0x0(%rax)
L59:
  lea    0x1(%r12),%r15
  jmp    L595
  add    $0xc,%r13d
  mov    %rdx,%r15
  jmp    L595
  cs nopw 0x0(%rax,%rax,1)
L443:
  xor    %r13d,%r13d
  jmp    L157
```

tool_calls: name: disassemble_data
arguments: tag: D87
data_type: string
name: disassemble_data
arguments: tag: D34
data_type: string
name: disassemble_data
arguments: tag: D319
data_type: string
name: disassemble_data
arguments: tag: D171
data_type: string
name: disassemble_data
arguments: tag: D101
data_type: string
name: disassemble_data
arguments: tag: D200
data_type: string
name: disassemble_data
arguments: tag: D37
data_type: string
name: disassemble_data
arguments: tag: D104
data_type: string
name: disassemble_data
arguments: tag: D297
data_type: string
name: disassemble_data
arguments: tag: D64
data_type: string
name: disassemble_data
arguments: tag: D285
data_type: string
name: disassemble_data
arguments: tag: D63
data_type: string
name: disassemble_data
arguments: tag: D117
data_type: string
name: disassemble_data
arguments: tag: D275
data_type: string

tool: D87: movdqa %s, [rbp+%d]


tool: D34: mov %s, [rbp+%d]


tool: D319: mov rax, [rbp+%d]


tool: D171: mov [rsp+%d], rax


tool: D101: movss %s, [rbp+%d]


tool: D200: movsd %s, [rbp+%d]


tool: D37: movdqa xmm8, [rbp+%d]


tool: D104: movdqa [rsp+%d], xmm8


tool: D297: movsd xmm8, [rbp+%d]


tool: D64: movsd [rsp+%d], xmm8


tool: D285: movss xmm8, [rbp+%d]


tool: D63: movss [rsp+%d], xmm8


tool: D117: mov eax, [rbp+%d]


tool: D275: mov [rsp+%d], eax


assistant: ```c
int BASM_XCallGenRepackSigSysV(char *sig) {
  static char *gregs[6] = {"rdi", "rsi", "rdx", "rcx", "r8", "r9"};
  static char *xregs[8] = {"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"};
  char *s;
  int i, j, ni, nx, ns;
  s = sig;
  i = 0;
  j = 0;
  ni = 0;
  nx = 0;
  ns = 0;
  if (*s == '(')
    s++;
  while (*s && (*s != ')')) {
    switch (*s++) {
    case 'a':
    case 'b':
    case 'c':
    case 'h':
    case 's':
    case 't':
    case 'w':
    case 'i':
    case 'j':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
        break;
      }
      basm_print("mov eax, [rbp+%d]\n", (i + 2) * 8);
      basm_print("mov [rsp+%d], eax\n", ns * 8);
      i++;
      ns++;
      break;
    case 'l':
    case 'm':
    case 'x':
    case 'y':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
        break;
      }
      basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
      basm_print("mov [rsp+%d], rax\n", ns * 8);
      i++;
      ns++;
      break;
    case 'r':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
        break;
      }
      basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
      basm_print("mov [rsp+%d], rax\n", ns * 8);
      i++;
      ns++;
      break;
    case 'P':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
        basm_print("mov [rsp+%d], rax\n", ns * 8);
        i++;
        ns++;
      }
      while (*s == 'P')
        s++;
      if ((*s >= 'a') && (*s <= 'z')) {
        s++;
        break;
      }
      if (*s == 'X') {
        while (*s && *s != ';')
          s++;
        if (*s == ';')
          s++;
      }
      break;
    case 'Q':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
        basm_print("mov [rsp+%d], rax\n", ns * 8);
        i++;
        ns++;
      }
      while (*s == 'Q')
        s++;
      if ((*s >= 'a') && (*s <= 'z')) {
        s++;
        break;
      }
      if (*s == 'L') {
        while (*s && *s != ';')
          s++;
        if (*s == ';')
          s++;
      }
      break;
    case 'L':
      if (ni < 6) {
        basm_print("mov %s, [rbp+%d]\n", gregs[ni], (i + 2) * 8);
        i++;
        ni++;
      } else {
        basm_print("mov rax, [rbp+%d]\n", (i + 2) * 8);
        basm_print("mov [rsp+%d], rax\n", ns * 8);
        i++;
        ns++;
      }
      while (*s && *s != ';')
        s++;
      if (*s == ';')
        s++;
      break;
    case 'd':
      if (nx < 8) {
        basm_print("movsd %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i++;
        nx++;
        break;
      }
      basm_print("movsd xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movsd [rsp+%d], xmm8\n", ns * 8);
      i++;
      ns++;
      break;
    case 'e':
      if (nx < 8) {
        if (i & 1)
          i++;
        basm_print("movdqa %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i += 2;
        nx++;
        break;
      }
      if (i & 1)
        i++;
      if (ns & 1)
        ns++;
      basm_print("movdqa xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movdqa [rsp+%d], xmm8\n", ns * 8);
      i += 2;
      ns += 2;
      break;
    case 'f':
    case 'k':
      if (nx < 8) {
        basm_print("movss %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i++;
        nx++;
        break;
      }
      basm_print("movss xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movss [rsp+%d], xmm8\n", ns * 8);
      i++;
      ns++;
      break;
    case 'g':
    case 'n':
    case 'o':
      if (nx < 8) {
        if (i & 1)
          i++;
        basm_print("movdqa %s, [rbp+%d]\n", xregs[nx], (i + 2) * 8);
        i += 2;
        nx++;
        break;
      }
      if (i & 1)
        i++;
      if (ns & 1)
        ns++;
      basm_print("movdqa xmm8, [rbp+%d]\n", (i + 2) * 8);
      basm_print("movdqa [rsp+%d], xmm8\n", ns * 8);
      i += 2;
      ns += 2;
      break;
    case 'C':
      switch (*s++) {
      case 'f':
        i += 8;
        break;
      case 'd':
        i += 16;
        break;
      case 'e':
        i += 32;
        break;
      case 'g':
        i += 32;
        break;
      case 'k':
        i += 4;
        break;
      }
      break;
    case 'G':
      switch (*s++) {
      case 'f':
        i += 4;
        break;
      case 'd':
        i += 8;
        break;
      case 'e':
        i += 12;
        break;
      case 'g':
        i += 16;
        break;
      case 'k':
        i += 4;
        break;
      }
      break;
    default:
      break;
    }
  }
  if (*s && *s == ')')
    s++;
  return (i);
}
```