user: 这段汇编代码用C语言表示是什么样的?

```asm
<Disassemble>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  mov    %rdx,%rbp
  push   %rbx
  mov    %rsi,%rbx
  sub    $0x88,%rsp
  movzbl (%rsi),%r15d
  mov    %edi,0x4(%rsp)
  xor    %edi,%edi
  mov    %r15d,%r14d
  and    $0x7,%r14d
  mov    %fs:0x28,%rax
  mov    %rax,0x78(%rsp)
  xor    %eax,%eax
  mov    %r15d,%eax
  shr    $0x3,%al
  mov    %eax,%r12d
  mov    %al,0x8(%rsp)
  call   <OpcodeLen@plt>
  and    $0x7,%r12d
  mov    %eax,%r13d
  mov    %r15d,%eax
  and    $0xffffffc0,%eax
  cmp    $0x80,%al
  je     L1290
  ja     L114
  test   %al,%al
  je     L848
  cmp    $0x40,%al
  jne    L721
  cmp    %r14b,%r12b
  je     L584
  lea    D1489(%rip),%rsi
  mov    %rbp,%rdi
  and    $0x7,%r12d
  and    $0x7,%r14d
  call   <strcpy@plt>
  lea    D1032(%rip),%rbx
  mov    %rbp,%rdi
  mov    (%rbx,%r12,8),%rsi
  call   <strcat@plt>
  lea    D104(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    (%rbx,%r14,8),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  nopl   0x0(%rax,%rax,1)
L721:
  mov    0x78(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L413
  add    $0x88,%rsp
  mov    %r13d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L114:
  cmp    $0xc0,%al
  jne    L721
  lea    D414(%rip),%rcx
  movzbl %r14b,%r14d
  movslq (%rcx,%r14,4),%rax
  add    %rcx,%rax
  notrack jmp *%rax
  nopl   0x0(%rax)
L848:
  lea    D226(%rip),%rcx
  movzbl %r14b,%r14d
  movslq (%rcx,%r14,4),%rax
  add    %rcx,%rax
  notrack jmp *%rax
  nopl   (%rax)
L1290:
  and    $0x7,%r12d
  lea    D276(%rip),%rax
  mov    %rbp,%rdi
  and    $0x7,%r14d
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  lea    D1032(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r14,8),%rsi
  call   <strcat@plt>
  jmp    L721
  nopl   0x0(%rax,%rax,1)
L584:
  lea    D1005(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  nopl   0x0(%rax)
  lea    D295(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r15d,%edx
  and    $0x38,%edx
L621:
  lea    0x20(%rsp),%r12
  lea    D974(%rip),%rsi
L487:
  mov    %r12,%rdi
  call   <sprintf@plt>
  mov    %r12,%rsi
L1356:
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  nopl   0x0(%rax)
  shr    %r12b
  and    $0x8,%r15d
  movzbl %r12b,%r12d
  je     L933
  mov    %rbp,%rdi
  lea    D997(%rip),%rsi
  call   <strcpy@plt>
  lea    D1146(%rip),%rdx
  mov    %rbp,%rdi
  mov    (%rdx,%r12,8),%rsi
  call   <strcat@plt>
  jmp    L721
  nopl   0x0(%rax,%rax,1)
  lea    D1235(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  nopl   (%rax)
  lea    D952(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
L642:
  and    $0x7,%r12d
  lea    D1032(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  jmp    L721
  nopl   0x0(%rax,%rax,1)
  lea    D1080(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L642
  nopl   0x0(%rax)
  and    $0x8,%r15d
  je     L222
  lea    D1080(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
L346:
  shr    %r12b
L359:
  and    $0x3,%r12d
  lea    D1146(%rip),%rax
  mov    (%rax,%r12,8),%rsi
  jmp    L1356
  lea    D1489(%rip),%rsi
  mov    %rbp,%rdi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D1032(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  lea    D104(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzwl 0x4(%rsp),%eax
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L621
  nopl   0x0(%rax)
  lea    D838(%rip),%rsi
L484:
  mov    %rbp,%rdi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D324(%rip),%rax
  mov    (%rax,%r12,8),%rsi
L869:
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcat@plt>
  lea    D104(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzwl 0x4(%rsp),%eax
  lea    D1006(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L487
  nopl   0x0(%rax,%rax,1)
  shr    %r12b
  testb  $0x1,0x8(%rsp)
  je     L157
  cmp    $0x2,%r12b
  je     L1306
  cmp    $0x3,%r12b
  je     L842
  cmp    $0x1,%r12b
  je     L331
  lea    D332(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D276(%rip),%rax
  and    $0x7,%r12d
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L621
  cs nopw 0x0(%rax,%rax,1)
  shr    %r12b
  testb  $0x1,0x8(%rsp)
  je     L1321
  test   %r12b,%r12b
  je     L885
  cmp    $0x2,%r12b
  je     L395
  and    $0x20,%r15d
  lea    D1578(%rip),%rax
  lea    0x1d(%rsp),%r14
  lea    D991(%rip),%rsi
  mov    %r14,%rdi
  cmove  %rax,%rsi
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  add    $0x1,%eax
  movzwl %ax,%r15d
  movzbl (%rbx,%r15,1),%r12d
  cmp    $0xbe,%r12b
  ja     L495
  cmp    $0x7d,%r12b
  ja     L590
  cmp    $0x36,%r12b
  ja     L284
  cmp    $0x8,%r12b
  jbe    L721
  sub    $0x9,%r12d
  cmp    $0x2d,%r12b
  ja     L721
  lea    D41(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D1100(%rip),%rsi
  jmp    L484
  nopl   0x0(%rax)
  and    $0x7,%r12d
  lea    D1066(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L721
  nopl   0x0(%rax)
  lea    D1396(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D514(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D1452(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D274(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D902(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D1572(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  movzbl 0x1(%rbx,%rax,1),%edx
L1175:
  lea    D974(%rip),%rsi
L1029:
  mov    %r12,%rdi
  call   <sprintf@plt>
  mov    %r12,%rsi
L839:
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1292(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  mov    %rbp,%rdi
  lea    D293(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  mov    %r12,%rdi
  lea    D974(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D436(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  movzwl 0x4(%rsp),%eax
  movb   $0x0,0x21(%rsp)
  add    $0x1,%eax
  movzwl %ax,%eax
  movzbl (%rbx,%rax,1),%eax
  mov    %eax,%ebx
  mov    %eax,%r12d
  and    $0xffffffc0,%eax
  shr    $0x3,%bl
  and    $0x7,%r12d
  and    $0x7,%ebx
  cmp    $0x80,%al
  je     L919
  ja     L1277
  test   %al,%al
  je     L977
  cmp    $0x40,%al
  jne    L721
  lea    D851(%rip),%rsi
L902:
  mov    %rbp,%rdi
  add    $0x30,%ebx
  call   <strcpy@plt>
  lea    0x20(%rsp),%rsi
  mov    %rbp,%rdi
  mov    %bl,0x20(%rsp)
  call   <strcat@plt>
  lea    D39(%rip),%rsi
L436:
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L642
  lea    D1245(%rip),%rsi
L1254:
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  lea    D1006(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L1029
  lea    D486(%rip),%rsi
  jmp    L1254
  mov    %rbp,%rdi
  lea    D717(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  mov    %r12,%rdi
  lea    D1006(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D409(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  lea    D975(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D1602(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D66(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  mov    %rbp,%rdi
  lea    D717(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  mov    %r12,%rdi
  lea    D1006(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D325(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  lea    D717(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  lea    D974(%rip),%r14
  call   <strcat@plt>
  lea    D1544(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  mov    %r14,%rsi
  mov    %r12,%rdi
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D177(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x2(%rbx,%r15,1),%edx
  mov    %r14,%rsi
  jmp    L487
  lea    D378(%rip),%rsi
L1123:
  mov    %rbp,%rdi
  call   <strcpy@plt>
L332:
  mov    %r14,%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcat@plt>
  lea    D1544(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  jmp    L1175
  lea    D1565(%rip),%rsi
  jmp    L1123
  lea    D1080(%rip),%rsi
L36:
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  lea    D1489(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D745(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D1006(%rip),%rsi
  jmp    L1029
  lea    D1601(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D39(%rip),%rsi
L1312:
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  lea    D952(%rip),%rsi
  jmp    L36
  lea    D717(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D1006(%rip),%rsi
  mov    %r12,%rdi
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D861(%rip),%rsi
  jmp    L1312
  lea    D1489(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D39(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D1006(%rip),%rsi
  jmp    L487
  mov    %rbp,%rdi
  lea    D1601(%rip),%rsi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1581(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  mov    %rbp,%rdi
  lea    D1601(%rip),%rsi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1107(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  nopl   0x0(%rax)
  cmp    $0x2,%r12b
  je     L683
  ja     L695
  test   %r12b,%r12b
  je     L780
  cmp    $0x1,%r12b
  jne    L29
  lea    D169(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  mov    %rbp,%rdi
  lea    D825(%rip),%rsi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D324(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  jmp    L721
L695:
  lea    D888(%rip),%rsi
  cmp    $0x3,%r12b
  jne    L29
L736:
  mov    %rbp,%rdi
  call   <strcpy@plt>
L1300:
  mov    0x4(%rsp),%ecx
  lea    0x20(%rsp),%r12
  lea    D1006(%rip),%rsi
  movzwl %cx,%eax
  movzbl 0x1(%rbx,%rax,1),%edx
  mov    %ecx,%eax
  lea    0x2(%rdx,%rax,1),%edx
  movzbl %dl,%edx
  jmp    L487
  nopl   (%rax)
L933:
  lea    D1489(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  movslq %r12d,%rax
  lea    D1146(%rip),%rdx
  mov    (%rdx,%rax,8),%rsi
  jmp    L869
  nopw   0x0(%rax,%rax,1)
L222:
  lea    D952(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L346
L157:
  lea    D662(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  cmp    $0x3,%r12b
  jne    L359
  lea    D592(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
L1321:
  lea    D1202(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  lea    D592(%rip),%rsi
  cmp    $0x3,%r12b
  jne    L359
  jmp    L1356
L885:
  lea    D1100(%rip),%rsi
L205:
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  lea    D1006(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L487
L495:
  add    $0x35,%r12d
  cmp    $0x2e,%r12b
  ja     L721
  lea    D1437(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D288(%rip),%rsi
  jmp    L36
  lea    D520(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  jmp    L839
  lea    D1202(%rip),%rsi
  jmp    L36
  lea    D1481(%rip),%rsi
  jmp    L36
  lea    D662(%rip),%rsi
  jmp    L36
  movzbl 0x2(%rbx,%r15,1),%eax
  movb   $0x0,0x21(%rsp)
  mov    %eax,%r12d
  and    $0xffffffc0,%eax
  shr    $0x3,%r12b
  and    $0x7,%r12d
  cmp    $0x80,%al
  je     L98
  ja     L203
  test   %al,%al
  je     L349
  lea    D851(%rip),%rsi
  cmp    $0x40,%al
  jne    L136
L960:
  mov    %rbp,%rdi
  add    $0x30,%r12d
  call   <strcpy@plt>
  mov    %r12b,0x20(%rsp)
  lea    0x20(%rsp),%r12
  mov    %rbp,%rdi
  mov    %r12,%rsi
  call   <strcat@plt>
  lea    D39(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
L326:
  lea    D1611(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1544(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  jmp    L1175
  nopl   0x0(%rax)
L395:
  movzwl 0x4(%rsp),%eax
  add    $0x1,%eax
  movzwl %ax,%eax
  movzbl (%rbx,%rax,1),%edx
  mov    %edx,%ecx
  and    $0xffffffc0,%ecx
  cmp    $0x40,%cl
  je     L17
  cmp    $0x80,%cl
  jne    L721
  and    $0x1f,%edx
  lea    D906(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%rdx,8),%rsi
  call   <strcpy@plt>
  jmp    L721
L284:
  lea    -0x39(%r12),%ecx
  cmp    $0x3e,%cl
  ja     L721
  movabs $0x5f80000000000000,%rdx
  mov    $0x1,%eax
  shl    %cl,%rax
  test   %rdx,%rax
  jne    L575
  movabs $0x20202020202000,%rdx
  test   %rdx,%rax
  jne    L418
  test   $0x1,%al
  je     L721
  mov    %rbp,%rdi
  lea    D1601(%rip),%rsi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1308(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
  nopl   0x0(%rax,%rax,1)
L590:
  sub    $0x7e,%r12d
  cmp    $0x40,%r12b
  ja     L721
  lea    D418(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D321(%rip),%rsi
  jmp    L1123
  lea    D631(%rip),%rsi
  jmp    L1123
  lea    D495(%rip),%rsi
  jmp    L1123
  lea    D1063(%rip),%rsi
  jmp    L1123
  lea    D1316(%rip),%rsi
  jmp    L1123
  lea    D470(%rip),%rsi
  jmp    L1123
  lea    D929(%rip),%rsi
  jmp    L1123
  lea    D901(%rip),%rsi
  jmp    L1123
  lea    D1530(%rip),%rsi
  jmp    L1123
  nop
L683:
  lea    D832(%rip),%rsi
  jmp    L736
L29:
  mov    %rbp,%rdi
  lea    D888(%rip),%rsi
  call   <strcpy@plt>
  mov    0x8(%rsp),%r15
  lea    D324(%rip),%rax
  mov    %rbp,%rdi
  and    $0x3,%r15d
  mov    (%rax,%r15,8),%rsi
  call   <strcat@plt>
  lea    D104(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1300
L780:
  lea    D628(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
L1306:
  lea    D56(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
L331:
  lea    D422(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
L842:
  lea    D1172(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
  lea    D838(%rip),%rsi
  jmp    L205
  lea    D165(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L721
L1277:
  lea    D577(%rip),%rsi
  cmp    $0xc0,%al
  je     L902
  jmp    L721
L17:
  mov    %edx,%ecx
  lea    D1636(%rip),%rsi
  and    $0x7,%edx
  movslq (%rsi,%rdx,4),%rdx
  shr    $0x3,%cl
  mov    %ecx,%r12d
  add    %rsi,%rdx
  and    $0x7,%r12d
  notrack jmp *%rdx
  and    $0x7,%r12d
  lea    D48(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L721
  mov    %rbp,%rdi
  lea    D1625(%rip),%rsi
  add    $0x2f,%r12d
  call   <strcpy@plt>
  lea    0x20(%rsp),%rsi
  mov    %rbp,%rdi
  mov    %r12b,0x20(%rsp)
  movb   $0x0,0x21(%rsp)
  call   <strcat@plt>
  jmp    L721
  and    $0x7,%r12d
  lea    D907(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L721
  and    $0x7,%r12d
  lea    D385(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L721
  lea    0x1(%rbx,%rax,1),%r14
  mov    %r12d,%ebx
  shr    %bl
  and    $0x1,%cl
  movzbl %bl,%ebx
  je     L1108
  lea    D1489(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  lea    D1146(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%rbx,8),%rsi
  call   <strcat@plt>
  lea    D1201(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl (%r14),%edx
  lea    D1006(%rip),%rsi
  jmp    L1029
  and    $0x1,%cl
  je     L1006
  lea    D800(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
L901:
  mov    %rbp,%rdi
  lea    D1064(%rip),%rsi
  call   <strcat@plt>
  mov    %r12d,%eax
  lea    D1146(%rip),%rdx
  mov    %rbp,%rdi
  shr    %al
  and    $0x3,%eax
  mov    (%rdx,%rax,8),%rsi
  call   <strcat@plt>
  jmp    L721
  lea    D1178(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L642
L977:
  lea    D554(%rip),%rax
  and    $0x7,%ebx
  mov    %rbp,%rdi
  mov    (%rax,%rbx,8),%rsi
  call   <strcpy@plt>
  lea    D187(%rip),%rsi
  jmp    L436
L919:
  lea    D695(%rip),%rsi
  jmp    L902
L413:
  call   <__stack_chk_fail@plt>
  mov    %rbp,%rdi
  lea    D1042(%rip),%rsi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D1032(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  lea    D198(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L721
L418:
  mov    %rbp,%rdi
  lea    D1489(%rip),%rsi
  call   <strcpy@plt>
  mov    %r12d,%eax
  lea    D1032(%rip),%rdx
  mov    %rbp,%rdi
  shr    $0x3,%al
  and    $0x7,%eax
  mov    (%rdx,%rax,8),%rsi
  call   <strcat@plt>
  lea    D1201(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L332
L575:
  lea    D717(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r14
  call   <strcat@plt>
  lea    D1544(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D974(%rip),%rsi
  mov    %r14,%rdi
  call   <sprintf@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D177(%rip),%rsi
  jmp    L436
L203:
  lea    D577(%rip),%rsi
  cmp    $0xc0,%al
  je     L960
L136:
  lea    0x20(%rsp),%r12
  jmp    L326
L1108:
  mov    %rbp,%rdi
  lea    D717(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzbl (%r14),%edx
  mov    %r12,%rdi
  lea    D1006(%rip),%rsi
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    %rbp,%rdi
  lea    D177(%rip),%rsi
  call   <strcat@plt>
  lea    D1146(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%rbx,8),%rsi
  call   <strcat@plt>
  jmp    L721
L1006:
  lea    D1335(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L901
L98:
  lea    D695(%rip),%rsi
  jmp    L960
L349:
  and    $0x7,%r12d
  lea    D554(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  lea    D187(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L136
```

tool_calls: name: read_data
arguments: tag: D1489
datatype: string
name: read_data
arguments: tag: D104
datatype: string
name: read_data
arguments: tag: D1005
datatype: string
name: read_data
arguments: tag: D295
datatype: string
name: read_data
arguments: tag: D974
datatype: string
name: read_data
arguments: tag: D997
datatype: string
name: read_data
arguments: tag: D952
datatype: string
name: read_data
arguments: tag: D1080
datatype: string
name: read_data
arguments: tag: D838
datatype: string
name: read_data
arguments: tag: D1006
datatype: string
name: read_data
arguments: tag: D332
datatype: string
name: read_data
arguments: tag: D1578
datatype: string
name: read_data
arguments: tag: D991
datatype: string
name: read_data
arguments: tag: D1100
datatype: string
name: read_data
arguments: tag: D514
datatype: string
name: read_data
arguments: tag: D1452
datatype: string
name: read_data
arguments: tag: D274
datatype: string
name: read_data
arguments: tag: D902
datatype: string
name: read_data
arguments: tag: D1572
datatype: string
name: read_data
arguments: tag: D1292
datatype: string
name: read_data
arguments: tag: D293
datatype: string
name: read_data
arguments: tag: D436
datatype: string
name: read_data
arguments: tag: D851
datatype: string
name: read_data
arguments: tag: D39
datatype: string
name: read_data
arguments: tag: D1245
datatype: string
name: read_data
arguments: tag: D486
datatype: string
name: read_data
arguments: tag: D717
datatype: string
name: read_data
arguments: tag: D409
datatype: string
name: read_data
arguments: tag: D975
datatype: string
name: read_data
arguments: tag: D1602
datatype: string
name: read_data
arguments: tag: D66
datatype: string
name: read_data
arguments: tag: D325
datatype: string
name: read_data
arguments: tag: D1544
datatype: string
name: read_data
arguments: tag: D177
datatype: string
name: read_data
arguments: tag: D378
datatype: string
name: read_data
arguments: tag: D1565
datatype: string
name: read_data
arguments: tag: D745
datatype: string
name: read_data
arguments: tag: D1601
datatype: string
name: read_data
arguments: tag: D861
datatype: string
name: read_data
arguments: tag: D1581
datatype: string
name: read_data
arguments: tag: D1107
datatype: string
name: read_data
arguments: tag: D169
datatype: string
name: read_data
arguments: tag: D825
datatype: string
name: read_data
arguments: tag: D888
datatype: string
name: read_data
arguments: tag: D662
datatype: string
name: read_data
arguments: tag: D592
datatype: string
name: read_data
arguments: tag: D1202
datatype: string
name: read_data
arguments: tag: D288
datatype: string
name: read_data
arguments: tag: D520
datatype: string
name: read_data
arguments: tag: D1481
datatype: string
name: read_data
arguments: tag: D1611
datatype: string
name: read_data
arguments: tag: D1308
datatype: string
name: read_data
arguments: tag: D321
datatype: string
name: read_data
arguments: tag: D631
datatype: string
name: read_data
arguments: tag: D495
datatype: string
name: read_data
arguments: tag: D1063
datatype: string
name: read_data
arguments: tag: D1316
datatype: string
name: read_data
arguments: tag: D470
datatype: string
name: read_data
arguments: tag: D929
datatype: string
name: read_data
arguments: tag: D901
datatype: string
name: read_data
arguments: tag: D1530
datatype: string
name: read_data
arguments: tag: D832
datatype: string
name: read_data
arguments: tag: D628
datatype: string
name: read_data
arguments: tag: D56
datatype: string
name: read_data
arguments: tag: D422
datatype: string
name: read_data
arguments: tag: D1172
datatype: string
name: read_data
arguments: tag: D165
datatype: string
name: read_data
arguments: tag: D577
datatype: string
name: read_data
arguments: tag: D1625
datatype: string
name: read_data
arguments: tag: D1201
datatype: string
name: read_data
arguments: tag: D800
datatype: string
name: read_data
arguments: tag: D1064
datatype: string
name: read_data
arguments: tag: D1178
datatype: string
name: read_data
arguments: tag: D187
datatype: string
name: read_data
arguments: tag: D695
datatype: string
name: read_data
arguments: tag: D1042
datatype: string
name: read_data
arguments: tag: D198
datatype: string
name: read_data
arguments: tag: D1335
datatype: string

tool: D1489: ld 

tool: D104: , 

tool: D1005: halt

tool: D295: rst 

tool: D974: 0x%2.2X

tool: D997: add hl, 

tool: D952: inc 

tool: D1080: dec 

tool: D838: jp 

tool: D1006: 0x%4.4X

tool: D332: ret

tool: D1578: ix

tool: D991: iy

tool: D1100: call 

tool: D514: ei

tool: D1452: di

tool: D274: ex de, hl

tool: D902: ex (sp), hl

tool: D1572: in a, (

tool: D1292: )

tool: D293: out (

tool: D436: ),A

tool: D851: bit 

tool: D39: ,

tool: D1245: ld a,(

tool: D486: ld hl, (

tool: D717: ld (

tool: D409: ), hl

tool: D975: ld a, (de)

tool: D1602: ld (de), a

tool: D66: ld a, (bc)

tool: D325: ), a

tool: D1544: +

tool: D177: ),

tool: D378: dec (

tool: D1565: inc (

tool: D745: , (

tool: D1601: add 

tool: D861: ), 

tool: D1581: , de

tool: D1107: , bc

tool: D169: ex af, af'

tool: D825: ret 

tool: D888: jr 

tool: D662: pop 

tool: D592: af

tool: D1202: push 

tool: D288: ld sp, 

tool: D520: jp (

tool: D1481: ex (sp), 

tool: D1611: (

tool: D1308: , sp

tool: D321: cp a,(

tool: D631: or a,(

tool: D495: xor a, (

tool: D1063: and a,(

tool: D1316: sbc a, (

tool: D470: sub (

tool: D929: adc a,(

tool: D901: add A, (

tool: D1530: ld A,(

tool: D832: djnz 

tool: D628: nop

tool: D56: jp (hl)

tool: D422: exx

tool: D1172: ld sp,hl

tool: D165: ld (bc), a

tool: D577: set 

tool: D1625: im 

tool: D1201: ,(

tool: D800: adc

tool: D1064:  HL, 

tool: D1178: out (c), 

tool: D187:  

tool: D695: res 

tool: D1042: in 

tool: D198: , (c)

tool: D1335: sbc

assistant: ```c
int Disassemble(unsigned short adr, const unsigned char *Opcodes, char *s, int olen) {
  unsigned char a = Opcodes[0];
  unsigned char d = (a >> 3) & 7;
  unsigned char e = a & 7;
  static char *reg[8] = {"b", "c", "d", "e", "h", "l", "(hl)", "a"};
  static char *dreg[4] = {"bc", "de", "hl", "sp"};
  static char *cond[8] = {"nz", "z", "nc", "c", "po", "pe", "p", "m"};
  static char *arith[8] = {"add a,", "adc a,", "sub ", "sbc a,", "and ", "xor ", "or ", "cp "};
  char stemp[80];
  char ireg[3];
  int len = OpcodeLen(0, Opcodes);
  switch (a & 0xC0) {
  case 0x00:
    switch (e) {
    case 0x00:
      switch (d) {
      case 0x00:
        strcpy(s, "nop");
        break;
      case 0x01:
        strcpy(s, "ex af, af'");
        break;
      case 0x02:
        strcpy(s, "djnz ");
        sprintf(stemp, "0x%4.4X", adr + 2 + (char)Opcodes[adr + 1]);
        strcat(s, stemp);
        break;
      case 0x03:
        strcpy(s, "jr ");
        sprintf(stemp, "0x%4.4X", adr + 2 + (char)Opcodes[adr + 1]);
        strcat(s, stemp);
        break;
      default:
        strcpy(s, "jr ");
        strcat(s, cond[d & 3]);
        strcat(s, ", ");
        sprintf(stemp, "0x%4.4X", adr + 2 + (char)Opcodes[adr + 1]);
        strcat(s, stemp);
        break;
      }
      break;
    case 0x01:
      if (a & 0x08) {
        strcpy(s, "add hl, ");
        strcat(s, dreg[d >> 1]);
      } else {
        strcpy(s, "ld ");
        strcat(s, dreg[d >> 1]);
        strcat(s, ", ");
        sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
        strcat(s, stemp);
      }
      break;
    case 0x02:
      switch (d) {
      case 0x00:
        strcpy(s, "ld (bc), a");
        break;
      case 0x01:
        strcpy(s, "ld a, (bc)");
        break;
      case 0x02:
        strcpy(s, "ld (de), a");
        break;
      case 0x03:
        strcpy(s, "ld a, (de)");
        break;
      case 0x04:
        strcpy(s, "ld (");
        sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
        strcat(s, stemp);
        strcat(s, "), hl");
        break;
      case 0x05:
        strcpy(s, "ld hl, (");
        sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
        strcat(s, stemp);
        strcat(s, ")");
        break;
      case 0x06:
        strcpy(s, "ld (");
        sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
        strcat(s, stemp);
        strcat(s, "), a");
        break;
      case 0x07:
        strcpy(s, "ld a,(");
        sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
        strcat(s, stemp);
        strcat(s, ")");
        break;
      }
      break;
    case 0x03:
      if (a & 0x08)
        strcpy(s, "dec ");
      else
        strcpy(s, "inc ");
      strcat(s, dreg[d >> 1]);
      break;
    case 0x04:
      strcpy(s, "inc ");
      strcat(s, reg[d]);
      break;
    case 0x05:
      strcpy(s, "dec ");
      strcat(s, reg[d]);
      break;
    case 0x06:
      strcpy(s, "ld ");
      strcat(s, reg[d]);
      strcat(s, ", ");
      sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
      strcat(s, stemp);
      break;
    case 0x07: {
      static const char *str[8] = {"rlcs", "rrca", "rla", "rra", "daa", "cpl", "scf", "ccf"};
      strcpy(s, str[d]);
    } break;
    }
    break;
  case 0x40:
    if (d == e) {
      strcpy(s, "halt");
    } else {
      strcpy(s, "ld ");
      strcat(s, reg[d]);
      strcat(s, ", ");
      strcat(s, reg[e]);
    }
    break;
  case 0x80:
    strcpy(s, arith[d]);
    strcat(s, reg[e]);
    break;
  case 0xC0:
    switch (e) {
    case 0x00:
      strcpy(s, "ret ");
      strcat(s, cond[d]);
      break;
    case 0x01:
      if (d & 1) {
        switch (d >> 1) {
        case 0x00:
          strcpy(s, "ret");
          break;
        case 0x01:
          strcpy(s, "exx");
          break;
        case 0x02:
          strcpy(s, "jp (hl)");
          break;
        case 0x03:
          strcpy(s, "ld sp,hl");
          break;
        }
      } else {
        strcpy(s, "pop ");
        if ((d >> 1) == 3)
          strcat(s, "af");
        else
          strcat(s, dreg[d >> 1]);
      }
      break;
    case 0x02:
      strcpy(s, "jp ");
      strcat(s, cond[d]);
      strcat(s, ", ");
      sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
      strcat(s, stemp);
      break;
    case 0x03:
      switch (d) {
      case 0x00:
        strcpy(s, "jp ");
        sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
        strcat(s, stemp);
        break;
      case 0x01:
        a = Opcodes[++adr];
        d = (a >> 3) & 7;
        e = a & 7;
        stemp[1] = 0;
        switch (a & 0xC0) {
        case 0x00: {
          static char *str[8] = {"rlc", "rrc", "rl", "rr", "sla", "sra", "???", "srl"};
          strcpy(s, str[d]);
        }
          strcat(s, " ");
          strcat(s, reg[e]);
          break;
        case 0x40:
          strcpy(s, "bit ");
          stemp[0] = d + '0';
          strcat(s, stemp);
          strcat(s, ",");
          strcat(s, reg[e]);
          break;
        case 0x80:
          strcpy(s, "res ");
          stemp[0] = d + '0';
          strcat(s, stemp);
          strcat(s, ",");
          strcat(s, reg[e]);
          break;
        case 0xC0:
          strcpy(s, "set ");
          stemp[0] = d + '0';
          strcat(s, stemp);
          strcat(s, ",");
          strcat(s, reg[e]);
          break;
        }
        break;
      case 0x02:
        strcpy(s, "out (");
        sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
        strcat(s, stemp);
        strcat(s, "),A");
        break;
      case 0x03:
        strcpy(s, "in a, (");
        sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
        strcat(s, stemp);
        strcat(s, ")");
        break;
      case 0x04:
        strcpy(s, "ex (sp), hl");
        break;
      case 0x05:
        strcpy(s, "ex de, hl");
        break;
      case 0x06:
        strcpy(s, "di");
        break;
      case 0x07:
        strcpy(s, "ei");
        break;
      }
      break;
    case 0x04:
      strcpy(s, "call ");
      strcat(s, cond[d]);
      strcat(s, ", ");
      sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
      strcat(s, stemp);
      break;
    case 0x05:
      if (d & 1) {
        switch (d >> 1) {
        case 0x00:
          strcpy(s, "call ");
          sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
          strcat(s, stemp);
          break;
        case 0x02:
          a = Opcodes[++adr];
          d = (a >> 3) & 7;
          e = a & 7;
          switch (a & 0xC0) {
          case 0x40:
            switch (e) {
            case 0x00:
              strcpy(s, "in ");
              strcat(s, reg[d]);
              strcat(s, ", (c)");
              break;
            case 0x01:
              strcpy(s, "out (c), ");
              strcat(s, reg[d]);
              break;
            case 0x02:
              if (d & 1)
                strcpy(s, "adc");
              else
                strcpy(s, "sbc");
              strcat(s, " HL, ");
              strcat(s, dreg[d >> 1]);
              break;
            case 0x03:
              if (d & 1) {
                strcpy(s, "ld ");
                strcat(s, dreg[d >> 1]);
                strcat(s, ",(");
                sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
                strcat(s, stemp);
                strcat(s, ")");
              } else {
                strcpy(s, "ld (");
                sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
                strcat(s, stemp);
                strcat(s, "),");
                strcat(s, dreg[d >> 1]);
              }
              break;
            case 0x04: {
              static char *str[8] = {"neg", "???", "???", "???", "???", "???", "???", "???"};
              strcpy(s, str[d]);
            } break;
            case 0x05: {
              static char *str[8] = {"retn", "reti", "???", "???", "???", "???", "???", "???"};
              strcpy(s, str[d]);
            } break;
            case 0x06:
              strcpy(s, "im ");
              stemp[0] = d + '0' - 1;
              stemp[1] = 0;
              strcat(s, stemp);
              break;
            case 0x07: {
              static char *str[8] = {"ld i, a", "???", "ld a, i", "???", "rrd", "rld", "???", "???"};
              strcpy(s, str[d]);
            } break;
            }
            break;
          case 0x80: {
            static char *str[32] = {"ldi", "cpi", "ini", "outi", "???", "???", "???", "???", "ldd", "cpd", "ind", "outd", "???", "???", "???", "???", "ldir", "cpir", "inir", "otir", "???", "???", "???", "???", "lddr", "cpdr", "indr", "otdr", "???", "???", "???", "???"};
            strcpy(s, str[a & 0x1F]);
          } break;
          }
          break;
        default:
          strcpy(ireg, (a & 0x20) ? "iy" : "ix");
          a = Opcodes[++adr];
          switch (a) {
          case 0x09:
            strcpy(s, "add ");
            strcat(s, ireg);
            strcat(s, ", bc");
            break;
          case 0x19:
            strcpy(s, "add ");
            strcat(s, ireg);
            strcat(s, ", de");
            break;
          case 0x21:
            strcpy(s, "ld ");
            strcat(s, ireg);
            strcat(s, ",");
            sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
            strcat(s, stemp);
            break;
          case 0x22:
            strcpy(s, "ld (");
            sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
            strcat(s, stemp);
            strcat(s, "), ");
            strcat(s, ireg);
            break;
          case 0x23:
            strcpy(s, "inc ");
            strcat(s, ireg);
            break;
          case 0x29:
            strcpy(s, "add ");
            strcat(s, ireg);
            strcat(s, ",");
            strcat(s, ireg);
            break;
          case 0x2A:
            strcpy(s, "ld ");
            strcat(s, ireg);
            strcat(s, ", (");
            sprintf(stemp, "0x%4.4X", Opcodes[adr + 1] + (Opcodes[adr + 2] << 8));
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x2B:
            strcpy(s, "dec ");
            strcat(s, ireg);
            break;
          case 0x34:
            strcpy(s, "inc (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x35:
            strcpy(s, "dec (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x36:
            strcpy(s, "ld (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, "),");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 2]);
            strcat(s, stemp);
            break;
          case 0x39:
            strcpy(s, "add ");
            strcat(s, ireg);
            strcat(s, ", sp");
            break;
          case 0x46:
          case 0x4E:
          case 0x56:
          case 0x5E:
          case 0x66:
          case 0x6E:
            strcpy(s, "ld ");
            strcat(s, reg[(a >> 3) & 7]);
            strcat(s, ",(");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x70:
          case 0x71:
          case 0x72:
          case 0x73:
          case 0x74:
          case 0x75:
          case 0x77:
            strcpy(s, "ld (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, "),");
            strcat(s, reg[a & 7]);
            break;
          case 0x7E:
            strcpy(s, "ld A,(");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x86:
            strcpy(s, "add A, (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x8E:
            strcpy(s, "adc a,(");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x96:
            strcpy(s, "sub (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0x9E:
            strcpy(s, "sbc a, (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0xA6:
            strcpy(s, "and a,(");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0xAE:
            strcpy(s, "xor a, (");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0xB6:
            strcpy(s, "or a,(");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0xBE:
            strcpy(s, "cp a,(");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          case 0xE1:
            strcpy(s, "pop ");
            strcat(s, ireg);
            break;
          case 0xE3:
            strcpy(s, "ex (sp), ");
            strcat(s, ireg);
            break;
          case 0xE5:
            strcpy(s, "push ");
            strcat(s, ireg);
            break;
          case 0xE9:
            strcpy(s, "jp (");
            strcat(s, ireg);
            strcat(s, ")");
            break;
          case 0xF9:
            strcpy(s, "ld sp, ");
            strcat(s, ireg);
            break;
          case 0xCB:
            a = Opcodes[adr + 2];
            d = (a >> 3) & 7;
            stemp[1] = 0;
            switch (a & 0xC0) {
            case 0x00: {
              static char *str[8] = {"rlc", "rrc", "rl", "rr", "sla", "sra", "???", "srl"};
              strcpy(s, str[d]);
            }
              strcat(s, " ");
              break;
            case 0x40:
              strcpy(s, "bit ");
              stemp[0] = d + '0';
              strcat(s, stemp);
              strcat(s, ",");
              break;
            case 0x80:
              strcpy(s, "res ");
              stemp[0] = d + '0';
              strcat(s, stemp);
              strcat(s, ",");
              break;
            case 0xC0:
              strcpy(s, "set ");
              stemp[0] = d + '0';
              strcat(s, stemp);
              strcat(s, ",");
              break;
            }
            strcat(s, "(");
            strcat(s, ireg);
            strcat(s, "+");
            sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
            strcat(s, stemp);
            strcat(s, ")");
            break;
          }
          break;
        }
      } else {
        strcpy(s, "push ");
        strcat(s, ((d >> 1) == 3) ? "af" : dreg[d >> 1]);
      }
      break;
    case 0x06:
      strcpy(s, arith[d]);
      sprintf(stemp, "0x%2.2X", Opcodes[adr + 1]);
      strcat(s, stemp);
      break;
    case 0x07:
      strcpy(s, "rst ");
      sprintf(stemp, "0x%2.2X", a & 0x38);
      strcat(s, stemp);
      break;
    }
    break;
  }
  return len;
}
```