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

```asm
<pdb_command>:
  endbr64
  push   %r15
  mov    %rdi,%rsi
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x358,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x348(%rsp)
  xor    %eax,%eax
  lea    0x1d0(%rsp),%rbp
  lea    0x190(%rsp),%r14
  mov    %rbp,%rdi
  lea    0x150(%rsp),%r15
  lea    0x10(%rsp),%r12
  call   <strcpy@plt>
  lea    0x110(%rsp),%r13
  mov    %rbp,%rdi
  call   <help_scanner@plt>
  xor    %eax,%eax
  mov    %r14,%r9
  mov    %r15,%r8
  mov    %r13,%rcx
  mov    %r12,%rdx
  lea    D26(%rip),%rsi
  mov    %rbp,%rdi
  call   <sscanf@plt>
  cmp    $0x4,%eax
  je     L174
  xor    %eax,%eax
  mov    %r14,%r9
  mov    %r15,%r8
  mov    %r13,%rcx
  mov    %r12,%rdx
  lea    D83(%rip),%rsi
  mov    %rbp,%rdi
  call   <sscanf@plt>
  cmp    $0x4,%eax
  je     L110
  xor    %eax,%eax
  mov    %r14,%r9
  mov    %r15,%r8
  mov    %r13,%rcx
  mov    %r12,%rdx
  lea    D10(%rip),%rsi
  mov    %rbp,%rdi
  call   <sscanf@plt>
  cmp    $0x4,%eax
  je     L92
  xor    %eax,%eax
  mov    %r14,%r8
  mov    %r13,%rcx
  mov    %r12,%rdx
  lea    D9(%rip),%rsi
  mov    %rbp,%rdi
  call   <sscanf@plt>
  cmp    $0x3,%eax
  je     L127
  lea    0x50(%rsp),%rbx
  lea    0xd0(%rsp),%r8
  xor    %eax,%eax
  mov    %rbp,%rdi
  lea    0x90(%rsp),%rcx
  mov    %rbx,%rdx
  mov    %r8,0x8(%rsp)
  lea    D70(%rip),%rsi
  mov    %rcx,(%rsp)
  call   <sscanf@plt>
  mov    0x8(%rsp),%r8
  cmp    $0x3,%eax
  je     L156
  mov    (%rsp),%rcx
  xor    %eax,%eax
  mov    %rbx,%rdx
  lea    D16(%rip),%rsi
  mov    %rbp,%rdi
  mov    %r8,0x8(%rsp)
  call   <sscanf@plt>
  mov    0x8(%rsp),%r8
  cmp    $0x3,%eax
  je     L67
  mov    (%rsp),%rcx
  xor    %eax,%eax
  mov    %rbx,%rdx
  lea    D65(%rip),%rsi
  mov    %rbp,%rdi
  mov    %r8,0x8(%rsp)
  call   <sscanf@plt>
  cmp    $0x3,%eax
  je     L21
  mov    %r12,%rdx
  mov    %r14,%r9
  mov    %r15,%r8
  mov    %r13,%rcx
  lea    D72(%rip),%rsi
  mov    %rbp,%rdi
  xor    %eax,%eax
  call   <sscanf@plt>
  mov    %eax,%edx
  cmp    $0x4,%eax
  je     L180
  xor    %eax,%eax
  cmp    $0x2,%edx
  jne    L190
  mov    %rbx,%rdi
  call   <protected_set@plt>
  test   %rax,%rax
  jne    L32
  mov    (%rsp),%rsi
  mov    %rbx,%rdi
  call   <simple_set_copy@plt>
  mov    $0x1,%eax
  jmp    L190
  nopl   (%rax)
L110:
  mov    %r12,%rdi
  call   <protected_set@plt>
  test   %rax,%rax
  je     L107
L32:
  lea    0x240(%rsp),%rbp
  lea    D61(%rip),%rsi
  mov    %rbp,%rdi
  call   <sprintf@plt>
  mov    %rbp,%rdi
  call   <set_error1@plt>
  xor    %eax,%eax
L190:
  mov    0x348(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L249
  add    $0x358,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
L174:
  mov    %r14,%rcx
  mov    %r15,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  call   <times_equals@plt>
  mov    $0x1,%eax
  jmp    L190
L92:
  mov    %r12,%rdi
  call   <protected_set@plt>
  test   %rax,%rax
  jne    L32
  mov    %r14,%rcx
  mov    %r15,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  call   <minus_equals@plt>
  mov    $0x1,%eax
  jmp    L190
  nopl   (%rax)
L107:
  mov    %r14,%rcx
  mov    %r15,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  call   <plus_equals@plt>
  mov    $0x1,%eax
  jmp    L190
  nopl   0x0(%rax,%rax,1)
L156:
  mov    %rbx,%rdi
  call   <protected_set@plt>
  test   %rax,%rax
  jne    L32
  mov    0x8(%rsp),%rdx
  mov    (%rsp),%rsi
  mov    %rbx,%rdi
  call   <handle_intersection@plt>
  mov    $0x1,%eax
  jmp    L190
  nopl   0x0(%rax)
L127:
  mov    %r14,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  call   <field_assignment@plt>
  mov    $0x1,%eax
  jmp    L190
L67:
  mov    %rbx,%rdi
  call   <protected_set@plt>
  test   %rax,%rax
  jne    L32
  mov    0x8(%rsp),%rdx
  mov    (%rsp),%rsi
  mov    %rbx,%rdi
  call   <handle_union@plt>
  mov    $0x1,%eax
  jmp    L190
  nopl   0x0(%rax)
L21:
  mov    %rbx,%rdi
  call   <protected_set@plt>
  test   %rax,%rax
  jne    L32
  mov    0x8(%rsp),%rdx
  mov    (%rsp),%rsi
  mov    %rbx,%rdi
  call   <handle_subtraction@plt>
  mov    $0x1,%eax
  jmp    L190
  nopl   0x0(%rax)
L180:
  mov    %r12,%rdi
  call   <protected_set@plt>
  test   %rax,%rax
  jne    L32
  mov    %r14,%rcx
  mov    %r15,%rdx
  mov    %r13,%rsi
  mov    %r12,%rdi
  call   <assignment@plt>
  mov    $0x1,%eax
  jmp    L190
L249:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: tag: D26
data_type: string
name: read_data
arguments: tag: D83
data_type: string
name: read_data
arguments: tag: D10
data_type: string
name: read_data
arguments: tag: D9
data_type: string
name: read_data
arguments: tag: D70
data_type: string
name: read_data
arguments: tag: D16
data_type: string
name: read_data
arguments: tag: D65
data_type: string
name: read_data
arguments: tag: D72
data_type: string
name: read_data
arguments: tag: D61
data_type: string

tool: D26: %s *= %s %s %s

tool: D83: %s += %s %s %s

tool: D10: %s -= %s %s %s

tool: D9: %s %s = %s

tool: D70: %s = %s * %s

tool: D16: %s = %s + %s

tool: D65: %s = %s - %s

tool: D72: %s = %s %s %s

tool: D61: pdb_command: user not allowed to modify protected set

assistant: ```c
int pdb_command(char command_line[255]) {
  int nw;
  char command__line[100];
  char setname[64], setname1[64];
  char setname2[64], setname3[64];
  char field[64], operator[64];
  char value[64];
  char message[255];
  strcpy(command__line, command_line);
  help_scanner(command__line);
  nw = sscanf(command__line, "%s *= %s %s %s", setname, field, operator, value);
  if (nw == 4) {
    times_equals(setname, field, operator, value);
    return (1);
  }
  nw = sscanf(command__line, "%s += %s %s %s", setname, field, operator, value);
  if (nw == 4) {
    if (protected_set(setname)) {
      sprintf(message, "pdb_command: user not allowed to modify protected set");
      set_error1(message);
      return (0);
    }
    plus_equals(setname, field, operator, value);
    return (1);
  }
  nw = sscanf(command__line, "%s -= %s %s %s", setname, field, operator, value);
  if (nw == 4) {
    if (protected_set(setname)) {
      sprintf(message, "pdb_command: user not allowed to modify protected set");
      set_error1(message);
      return (0);
    }
    minus_equals(setname, field, operator, value);
    return (1);
  }
  nw = sscanf(command__line, "%s %s = %s", setname, field, value);
  if (nw == 3) {
    field_assignment(setname, field, value);
    return (1);
  }
  nw = sscanf(command__line, "%s = %s * %s", setname1, setname2, setname3);
  if (nw == 3) {
    if (protected_set(setname1)) {
      sprintf(message, "pdb_command: user not allowed to modify protected set");
      set_error1(message);
      return (0);
    }
    handle_intersection(setname1, setname2, setname3);
    return (1);
  }
  nw = sscanf(command__line, "%s = %s + %s", setname1, setname2, setname3);
  if (nw == 3) {
    if (protected_set(setname1)) {
      sprintf(message, "pdb_command: user not allowed to modify protected set");
      set_error1(message);
      return (0);
    }
    handle_union(setname1, setname2, setname3);
    return (1);
  }
  nw = sscanf(command__line, "%s = %s - %s", setname1, setname2, setname3);
  if (nw == 3) {
    if (protected_set(setname1)) {
      sprintf(message, "pdb_command: user not allowed to modify protected set");
      set_error1(message);
      return (0);
    }
    handle_subtraction(setname1, setname2, setname3);
    return (1);
  }
  nw = sscanf(command__line, "%s = %s %s %s", setname, field, operator, value);
  if (nw == 4) {
    if (protected_set(setname)) {
      sprintf(message, "pdb_command: user not allowed to modify protected set");
      set_error1(message);
      return (0);
    }
    assignment(setname, field, operator, value);
    return (1);
  } else if (nw == 2) {
    if (protected_set(setname1)) {
      sprintf(message, "pdb_command: user not allowed to modify protected set");
      set_error1(message);
      return (0);
    }
    simple_set_copy(setname1, setname2);
    return (1);
  }
  return (0);
}
```