user: 请显示与下面列出的汇编代码相匹配的C语言实现：

```asm
<PrintTypeTaggedArgs>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0x40,%rsp
  mov    %rdi,-0x38(%rbp)
  mov    %esi,-0x3c(%rbp)
  mov    %fs:0x28,%rax
  mov    %rax,-0x8(%rbp)
  xor    %eax,%eax
  mov    -0x38(%rbp),%rax
  mov    %rax,-0x18(%rbp)
  mov    -0x3c(%rbp),%eax
  movslq %eax,%rdx
  mov    -0x18(%rbp),%rax
  add    %rax,%rdx
  mov    -0x18(%rbp),%rax
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <IsNiceString@plt>
  test   %eax,%eax
  jne    L138
  mov    -0x3c(%rbp),%ecx
  mov    -0x38(%rbp),%rax
  mov    $0x0,%edx
  mov    %ecx,%esi
  mov    %rax,%rdi
  call   <PrintHeuristicallyTypeGuessedArgs@plt>
  jmp    L246
L138:
  mov    -0x3c(%rbp),%eax
  movslq %eax,%rdx
  mov    -0x18(%rbp),%rax
  add    %rax,%rdx
  mov    -0x18(%rbp),%rax
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <DataAfterAlignedString@plt>
  mov    %rax,-0x20(%rbp)
  mov    -0x18(%rbp),%rax
  add    $0x1,%rax
  mov    %rax,-0x28(%rbp)
  jmp    L168
L235:
  mov    -0x28(%rbp),%rax
  movzbl (%rax),%eax
  movsbl %al,%eax
  cmp    $0x66,%eax
  jg     L174
  cmp    $0x46,%eax
  jge    L219
  jmp    L45
L82:
  sub    $0x68,%eax
  mov    $0x1,%edx
  mov    %eax,%ecx
  shl    %cl,%rdx
  mov    %rdx,%rax
  mov    %rax,%rdx
  and    $0x422,%edx
  test   %rdx,%rdx
  setne  %dl
  test   %dl,%dl
  jne    L242
  mov    %rax,%rdx
  and    $0x1001,%edx
  test   %rdx,%rdx
  setne  %dl
  test   %dl,%dl
  jne    L111
  and    $0x800,%eax
  test   %rax,%rax
  setne  %al
  test   %al,%al
  jne    L97
  jmp    L45
L219:
  sub    $0x46,%eax
  cmp    $0x20,%eax
  ja     L45
  mov    %eax,%eax
  lea    0x0(,%rax,4),%rdx
  lea    D9(%rip),%rax
  mov    (%rdx,%rax,1),%eax
  cltq
  lea    D9(%rip),%rdx
  add    %rdx,%rax
  notrack jmp *%rax
L174:
  cmp    $0x74,%eax
  jg     L45
  cmp    $0x68,%eax
  jge    L82
  jmp    L45
L242:
  mov    -0x20(%rbp),%rax
  mov    (%rax),%eax
  mov    %eax,%edi
  call   <ntohl@plt>
  mov    %eax,%esi
  lea    D108(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  addq   $0x4,-0x20(%rbp)
  jmp    L21
  mov    -0x20(%rbp),%rax
  mov    (%rax),%eax
  mov    %eax,%edi
  call   <ntohl@plt>
  mov    %eax,-0x2c(%rbp)
  lea    -0x2c(%rbp),%rax
  mov    %rax,-0x10(%rbp)
  mov    -0x10(%rbp),%rax
  movss  (%rax),%xmm0
  pxor   %xmm1,%xmm1
  cvtss2sd %xmm0,%xmm1
  movq   %xmm1,%rax
  movq   %rax,%xmm0
  lea    D28(%rip),%rax
  mov    %rax,%rdi
  mov    $0x1,%eax
  call   <printf@plt>
  addq   $0x4,-0x20(%rbp)
  jmp    L21
L111:
  lea    D114(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  addq   $0x8,-0x20(%rbp)
  jmp    L21
  lea    D90(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  addq   $0x8,-0x20(%rbp)
  jmp    L21
L97:
  mov    -0x3c(%rbp),%eax
  movslq %eax,%rdx
  mov    -0x18(%rbp),%rax
  add    %rax,%rdx
  mov    -0x20(%rbp),%rax
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <IsNiceString@plt>
  test   %eax,%eax
  jne    L142
  lea    D118(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  jmp    L246
L142:
  mov    -0x20(%rbp),%rax
  mov    %rax,%rsi
  lea    D115(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x3c(%rbp),%eax
  movslq %eax,%rdx
  mov    -0x18(%rbp),%rax
  add    %rax,%rdx
  mov    -0x20(%rbp),%rax
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <DataAfterAlignedString@plt>
  mov    %rax,-0x20(%rbp)
  jmp    L21
  lea    D57(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L21
  lea    D13(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L21
  lea    D31(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L21
  lea    D127(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L21
L45:
  mov    -0x28(%rbp),%rax
  movzbl (%rax),%eax
  movsbl %al,%eax
  mov    %eax,%esi
  lea    D70(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L246
L21:
  addq   $0x1,-0x28(%rbp)
L168:
  mov    -0x28(%rbp),%rax
  movzbl (%rax),%eax
  test   %al,%al
  jne    L235
L246:
  mov    -0x8(%rbp),%rax
  sub    %fs:0x28,%rax
  je     L227
  call   <__stack_chk_fail@plt>
L227:
  leave
  ret
```

tool_calls: name: parse_data
arguments: data_tag: D108
data_type: string
name: parse_data
arguments: data_tag: D28
data_type: string
name: parse_data
arguments: data_tag: D114
data_type: string
name: parse_data
arguments: data_tag: D90
data_type: string
name: parse_data
arguments: data_tag: D118
data_type: string
name: parse_data
arguments: data_tag: D115
data_type: string
name: parse_data
arguments: data_tag: D57
data_type: string
name: parse_data
arguments: data_tag: D13
data_type: string
name: parse_data
arguments: data_tag: D31
data_type: string
name: parse_data
arguments: data_tag: D127
data_type: string
name: parse_data
arguments: data_tag: D70
data_type: string

tool: D108: %d 

tool: D28: %f 

tool: D114: [A 64-bit int] 

tool: D90: [A 64-bit float] 

tool: D118: Type tag said this arg is a string but it's not!

tool: D115: "%s" 

tool: D57: [True] 

tool: D13: [False] 

tool: D31: [Nil]

tool: D127: [Infinitum]

tool: D70: [Unrecognized type tag %c]

assistant: ```c
void PrintTypeTaggedArgs(void *v, int n) {
  char *typeTags, *thisType;
  char *p;
  typeTags = v;
  if (!IsNiceString(typeTags, typeTags + n)) {
    PrintHeuristicallyTypeGuessedArgs(v, n, 0);
    return;
  }
  p = DataAfterAlignedString(typeTags, typeTags + n);
  for (thisType = typeTags + 1; *thisType != 0; ++thisType) {
    switch (*thisType) {
    case 'i':
    case 'r':
    case 'm':
    case 'c':
      printf("%d ", ntohl(*((int *)p)));
      p += 4;
      break;
    case 'f': {
      int i = ntohl(*((int *)p));
      float *floatp = ((float *)(&i));
      printf("%f ", *floatp);
      p += 4;
    } break;
    case 'h':
    case 't':
      printf("[A 64-bit int] ");
      p += 8;
      break;
    case 'd':
      printf("[A 64-bit float] ");
      p += 8;
      break;
    case 's':
    case 'S':
      if (!IsNiceString(p, typeTags + n)) {
        printf("Type tag said this arg is a string but it's not!\n");
        return;
      } else {
        printf("\"%s\" ", p);
        p = DataAfterAlignedString(p, typeTags + n);
      }
      break;
    case 'T':
      printf("[True] ");
      break;
    case 'F':
      printf("[False] ");
      break;
    case 'N':
      printf("[Nil]");
      break;
    case 'I':
      printf("[Infinitum]");
      break;
    default:
      printf("[Unrecognized type tag %c]", *thisType);
      return;
    }
  }
}
```