user: Please show me the C implementation that matches the assembly code listed below:

```asm
<arghandler>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  mov    %edi,%ebp
  mov    $0x28,%edi
  push   %rbx
  mov    %rsi,%rbx
  sub    $0x18,%rsp
  call   <malloc@plt>
  mov    $0x8,%edi
  mov    %rax,%r12
  call   <malloc@plt>
  mov    D7(%rip),%rcx
  mov    $0x8,%edi
  mov    %rax,(%r12)
  mov    %rcx,(%rax)
  call   <malloc@plt>
  mov    D54(%rip),%rcx
  mov    $0x4,%edi
  mov    %rax,0x8(%r12)
  mov    %rcx,(%rax)
  call   <malloc@plt>
  mov    $0x8,%edi
  mov    %rax,0x10(%r12)
  movl   $0x64,(%rax)
  call   <malloc@plt>
  mov    D55(%rip),%rcx
  mov    $0x8,%edi
  mov    %rax,0x18(%r12)
  mov    %rcx,(%rax)
  call   <malloc@plt>
  mov    D37(%rip),%rcx
  mov    %rax,0x20(%r12)
  mov    %rcx,(%rax)
  cmp    $0x1,%ebp
  jle    L213
  mov    $0x1,%r15d
  lea    D6(%rip),%r13
  jmp    L95
  nopl   0x0(%rax)
L52:
  cmpb   $0x68,0x1(%rdi)
  jne    L86
  cmpb   $0x0,0x2(%rdi)
  jne    L86
L241:
  mov    (%rbx),%rdi
  mov    %r15d,%r14d
  call   <usage@plt>
L1:
  lea    0x1(%r14),%r15d
  cmp    %r15d,%ebp
  jle    L213
L95:
  movslq %r15d,%rax
  mov    (%rbx,%rax,8),%rdi
  lea    0x0(,%rax,8),%r8
  movzbl (%rdi),%eax
  cmp    $0x2d,%eax
  je     L52
L86:
  lea    0x1(%r15),%r14d
  cmp    $0x2d,%eax
  je     L226
L27:
  lea    D75(%rip),%rsi
  mov    %r8,0x8(%rsp)
  mov    %rdi,(%rsp)
  call   <strcmp@plt>
  mov    (%rsp),%rdi
  mov    0x8(%rsp),%r8
  test   %eax,%eax
  jne    L7
  cmp    %r14d,%ebp
  je     L227
  mov    0x18(%r12),%rdx
  jmp    L192
  nopl   (%rax)
L226:
  cmpb   $0x4b,0x1(%rdi)
  je     L190
L134:
  cmp    $0x2d,%eax
  jne    L27
  cmpb   $0x4c,0x1(%rdi)
  je     L41
L10:
  cmp    $0x2d,%eax
  jne    L27
  cmpb   $0x4e,0x1(%rdi)
  jne    L27
  cmpb   $0x0,0x2(%rdi)
  jne    L27
  cmp    %r14d,%ebp
  je     L227
  mov    0x10(%r12),%rdx
  mov    0x8(%rbx,%r8,1),%rdi
  lea    D25(%rip),%rsi
  call   <sscanf@plt>
  test   %eax,%eax
  jne    L1
  mov    (%rbx),%rdi
  call   <usage@plt>
  jmp    L1
  nopw   0x0(%rax,%rax,1)
L190:
  cmpb   $0x0,0x2(%rdi)
  jne    L134
  cmp    %r14d,%ebp
  je     L227
  mov    0x8(%rbx,%r8,1),%rdi
  mov    (%r12),%rdx
  mov    %r13,%rsi
  call   <sscanf@plt>
  test   %eax,%eax
  jne    L1
  mov    (%rbx),%rdi
  call   <usage@plt>
  jmp    L1
  nopl   0x0(%rax)
L7:
  lea    D65(%rip),%rsi
  mov    %r8,(%rsp)
  call   <strcmp@plt>
  test   %eax,%eax
  jne    L241
  cmp    %r14d,%ebp
  jne    L57
  nopl   (%rax)
L227:
  mov    (%rbx),%rdi
  call   <usage@plt>
L213:
  add    $0x18,%rsp
  mov    %r12,%rax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopw   0x0(%rax,%rax,1)
L41:
  cmpb   $0x0,0x2(%rdi)
  jne    L10
  cmp    %r14d,%ebp
  je     L227
  mov    0x8(%r12),%rdx
L192:
  mov    0x8(%rbx,%r8,1),%rdi
  mov    %r13,%rsi
  call   <sscanf@plt>
  test   %eax,%eax
  jne    L1
  mov    (%rbx),%rdi
  call   <usage@plt>
  jmp    L1
  cs nopw 0x0(%rax,%rax,1)
L57:
  mov    0x20(%r12),%rdx
  mov    (%rsp),%r8
  jmp    L192
```

tool_calls: name: parse_data
arguments: tag: D7
datatype: f64
name: parse_data
arguments: tag: D54
datatype: byte[8]
name: parse_data
arguments: tag: D55
datatype: byte[8]
name: parse_data
arguments: tag: D37
datatype: byte[8]
name: parse_data
arguments: tag: D6
datatype: string
name: parse_data
arguments: tag: D75
datatype: string
name: parse_data
arguments: tag: D25
datatype: string
name: parse_data
arguments: tag: D65
datatype: string

tool: D7: 0.05

tool: {"D54": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: {"D55": [0x00,0x00,0x00,0x00,0x00,0x00,0x24,0x40]}

tool: {"D37": [0x00,0x00,0x00,0x00,0x00,0x00,0x59,0x40]}

tool: D6: %lf

tool: D75: -T0

tool: D25: %u

tool: D65: -T1

assistant: ```c
void *arghandler(int argc, const char *argv[]) {
  int i;
  void **a;
  a = malloc(5 * sizeof(void *));
  a[0] = malloc(sizeof(double));
  *(double *)a[0] = 0.05;
  a[1] = malloc(sizeof(double));
  *(double *)a[1] = 1;
  a[2] = malloc(sizeof(unsigned int));
  *(unsigned int *)a[2] = 100;
  a[3] = malloc(sizeof(double));
  *(double *)a[3] = 10;
  a[4] = malloc(sizeof(double));
  *(double *)a[4] = 100;
  for (i = 1; i < argc; i++) {
    if (!strcmp(argv[i], "-h"))
      usage(argv[0]);
    else if (!strcmp(argv[i], "-K")) {
      if (i + 1 == argc)
        usage(argv[0]);
      else {
        i++;
        if (!sscanf(argv[i], "%lf", a[0]))
          usage(argv[0]);
      }
    } else if (!strcmp(argv[i], "-L")) {
      if (i + 1 == argc)
        usage(argv[0]);
      else {
        i++;
        if (!sscanf(argv[i], "%lf", a[1]))
          usage(argv[0]);
      }
    } else if (!strcmp(argv[i], "-N")) {
      if (i + 1 == argc)
        usage(argv[0]);
      else {
        i++;
        if (!sscanf(argv[i], "%u", a[2]))
          usage(argv[0]);
      }
    } else if (!strcmp(argv[i], "-T0")) {
      if (i + 1 == argc)
        usage(argv[0]);
      else {
        i++;
        if (!sscanf(argv[i], "%lf", a[3]))
          usage(argv[0]);
      }
    } else if (!strcmp(argv[i], "-T1")) {
      if (i + 1 == argc)
        usage(argv[0]);
      else {
        i++;
        if (!sscanf(argv[i], "%lf", a[4]))
          usage(argv[0]);
      }
    } else
      usage(argv[0]);
  }
  return a;
}
```