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

```asm
<HandleInstruction>:
  endbr64
  sub    $0x10,%edi
  push   %r14
  push   %r13
  push   %r12
  mov    %r8d,%r12d
  push   %rbp
  push   %rbx
  mov    %rcx,%rbx
  cmp    $0x51,%dil
  ja     L18
  mov    %edx,%r13d
  movzbl %dil,%edi
  lea    D8(%rip),%rdx
  mov    %esi,%ebp
  movslq (%rdx,%rdi,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  nopl   (%rax)
  mov    %rcx,%rsi
  mov    $0x17,%edi
  call   <LoadRegister@plt>
  test   %eax,%eax
  jne    L18
L204:
  lea    -0x3(%rbp,%rbp,2),%r12d
  mov    %rbx,%rdx
  mov    $0x16,%edi
  mov    %r12d,%esi
  call   <StoreRegister@plt>
L18:
  mov    %r12b,0x1b(%rbx)
  mov    %r12d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  xchg   %ax,%ax
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    $0x17,%edi
  sub    %r13d,%eax
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  xchg   %ax,%ax
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%ebp
  call   <LoadRegister@plt>
  mov    %ebp,%esi
  mov    %rbx,%rdx
  mov    $0x17,%edi
  sub    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopw   0x0(%rax,%rax,1)
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    %ebp,%edi
  xor    %r13d,%eax
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   0x0(%rax,%rax,1)
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%r14d
  call   <LoadRegister@plt>
  mov    %r14d,%esi
  mov    %rbx,%rdx
  mov    %ebp,%edi
  xor    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   0x0(%rax)
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    %ebp,%edi
  or     %r13d,%eax
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  xchg   %ax,%ax
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%r14d
  call   <LoadRegister@plt>
  mov    %r14d,%esi
  mov    %rbx,%rdx
  mov    %ebp,%edi
  or     %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   0x0(%rax)
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    %ebp,%edi
  and    %r13d,%eax
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  xchg   %ax,%ax
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%r14d
  call   <LoadRegister@plt>
  mov    %r14d,%esi
  mov    %rbx,%rdx
  mov    %ebp,%edi
  and    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   0x0(%rax)
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %r13d,%ecx
  mov    %rbx,%rdx
  mov    %ebp,%edi
  sar    %cl,%eax
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%r14d
  call   <LoadRegister@plt>
  mov    %r14d,%esi
  mov    %rbx,%rdx
  mov    %ebp,%edi
  mov    %eax,%ecx
  sar    %cl,%esi
  call   <StoreRegister@plt>
  jmp    L18
  xchg   %ax,%ax
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %r13d,%ecx
  mov    %rbx,%rdx
  mov    %ebp,%edi
  shl    %cl,%eax
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%r14d
  call   <LoadRegister@plt>
  mov    %r14d,%esi
  mov    %rbx,%rdx
  mov    %ebp,%edi
  mov    %eax,%ecx
  shl    %cl,%esi
  call   <StoreRegister@plt>
  jmp    L18
  xchg   %ax,%ax
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    %ebp,%edi
  sub    %r13d,%eax
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  xchg   %ax,%ax
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%r14d
  call   <LoadRegister@plt>
  mov    %r14d,%esi
  mov    %rbx,%rdx
  mov    %ebp,%edi
  sub    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   0x0(%rax)
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    %ebp,%edi
  lea    (%rax,%r13,1),%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   (%rax)
  mov    %rcx,%rsi
  mov    %ebp,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rsi
  mov    %r13d,%edi
  mov    %eax,%r14d
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    %ebp,%edi
  lea    (%r14,%rax,1),%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   0x0(%rax,%rax,1)
  mov    %rcx,%rdx
  mov    %r13d,%esi
  mov    %ebp,%edi
  call   <StoreRegister@plt>
  jmp    L18
  nopw   0x0(%rax,%rax,1)
  mov    %rcx,%rsi
  mov    %r13d,%edi
  call   <LoadRegister@plt>
  mov    %rbx,%rdx
  mov    %ebp,%edi
  mov    %eax,%esi
  call   <StoreRegister@plt>
  jmp    L18
  nopl   0x0(%rax)
  mov    %rcx,%rsi
  mov    $0x17,%edi
  call   <LoadRegister@plt>
  cmp    $0x7f,%eax
  jle    L18
  jmp    L204
  nopl   0x0(%rax,%rax,1)
  mov    %rcx,%rsi
  mov    $0x17,%edi
  call   <LoadRegister@plt>
  cmp    $0x7f,%eax
  jg     L18
  jmp    L204
  nopl   0x0(%rax,%rax,1)
  mov    %rcx,%rsi
  mov    $0x17,%edi
  call   <LoadRegister@plt>
  test   %eax,%eax
  je     L18
  jmp    L204
```

tool_calls: name: extract_symbolic_data
arguments: label: D8
type: string

tool: 

assistant: ```c
int HandleInstruction(char instruction, int arg1, int arg2, char *registers, int i) {
  switch (instruction) {
  case 0b01100000:
    StoreRegister(arg1, LoadRegister(arg2, registers), registers);
    break;
  case 0b01100001:
    StoreRegister(arg1, arg2, registers);
    break;
  case 0b001000000:
    StoreRegister(0b00010111, (LoadRegister(arg1, registers) - LoadRegister(arg2, registers)), registers);
    break;
  case 0b001000001:
    StoreRegister(0b00010111, (LoadRegister(arg1, registers) - arg2), registers);
    break;
  case 0b001010000:
    i = (arg1 * 3) - 3;
    StoreRegister(0b00010110, i, registers);
    break;
  case 0b00010000:
    StoreRegister(arg1, (LoadRegister(arg1, registers) + LoadRegister(arg2, registers)), registers);
    break;
  case 0b00010001:
    StoreRegister(arg1, (LoadRegister(arg1, registers) + arg2), registers);
    break;
  case 0b00010010:
    StoreRegister(arg1, (LoadRegister(arg1, registers) - LoadRegister(arg2, registers)), registers);
    break;
  case 0b00010011:
    StoreRegister(arg1, (LoadRegister(arg1, registers) - arg2), registers);
    break;
  case 0b00100000:
    StoreRegister(arg1, (LoadRegister(arg1, registers) << LoadRegister(arg2, registers)), registers);
    break;
  case 0b00100001:
    StoreRegister(arg1, (LoadRegister(arg1, registers) << arg2), registers);
    break;
  case 0b00100010:
    StoreRegister(arg1, (LoadRegister(arg1, registers) >> LoadRegister(arg2, registers)), registers);
    break;
  case 0b00100011:
    StoreRegister(arg1, (LoadRegister(arg1, registers) >> arg2), registers);
    break;
  case 0b00110000:
    StoreRegister(arg1, (LoadRegister(arg1, registers) & LoadRegister(arg2, registers)), registers);
    break;
  case 0b00110001:
    StoreRegister(arg1, (LoadRegister(arg1, registers) & arg2), registers);
    break;
  case 0b00110010:
    StoreRegister(arg1, (LoadRegister(arg1, registers) | LoadRegister(arg2, registers)), registers);
    break;
  case 0b00110011:
    StoreRegister(arg1, (LoadRegister(arg1, registers) | arg2), registers);
    break;
  case 0b00110100:
    StoreRegister(arg1, (LoadRegister(arg1, registers) ^ LoadRegister(arg2, registers)), registers);
    break;
  case 0b00110101:
    StoreRegister(arg1, (LoadRegister(arg1, registers) ^ arg2), registers);
    break;
  case 0b01010010:
    if (LoadRegister(0b00010111, registers) == 0) {
      i = (arg1 * 3) - 3;
      StoreRegister(0b00010110, i, registers);
    }
    break;
  case 0b01010100:
    if (LoadRegister(0b00010111, registers) != 0) {
      i = (arg1 * 3) - 3;
      StoreRegister(0b00010110, i, registers);
    }
    break;
  case 0b01010110:
    if (LoadRegister(0b00010111, registers) < 128) {
      i = (arg1 * 3) - 3;
      StoreRegister(0b00010110, i, registers);
    }
    break;
  case 0b01011000:
    if (LoadRegister(0b00010111, registers) > 127) {
      i = (arg1 * 3) - 3;
      StoreRegister(0b00010110, i, registers);
    }
    break;
  }
  registers[27] = i;
  return i;
}
```