user: What is the c source code of the assembly code below:

```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     L990
  ja     L1239
  test   %al,%al
  je     L703
  cmp    $0x40,%al
  jne    L1026
  cmp    %r14b,%r12b
  je     L742
  lea    D1219(%rip),%rsi
  mov    %rbp,%rdi
  and    $0x7,%r12d
  and    $0x7,%r14d
  call   <strcpy@plt>
  lea    D267(%rip),%rbx
  mov    %rbp,%rdi
  mov    (%rbx,%r12,8),%rsi
  call   <strcat@plt>
  lea    D1508(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    (%rbx,%r14,8),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  nopl   0x0(%rax,%rax,1)
L1026:
  mov    0x78(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L1250
  add    $0x88,%rsp
  mov    %r13d,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L1239:
  cmp    $0xc0,%al
  jne    L1026
  lea    D1338(%rip),%rcx
  movzbl %r14b,%r14d
  movslq (%rcx,%r14,4),%rax
  add    %rcx,%rax
  notrack jmp *%rax
  nopl   0x0(%rax)
L703:
  lea    D1522(%rip),%rcx
  movzbl %r14b,%r14d
  movslq (%rcx,%r14,4),%rax
  add    %rcx,%rax
  notrack jmp *%rax
  nopl   (%rax)
L990:
  and    $0x7,%r12d
  lea    D1298(%rip),%rax
  mov    %rbp,%rdi
  and    $0x7,%r14d
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  lea    D267(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r14,8),%rsi
  call   <strcat@plt>
  jmp    L1026
  nopl   0x0(%rax,%rax,1)
L742:
  lea    D478(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  nopl   0x0(%rax)
  lea    D241(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r15d,%edx
  and    $0x38,%edx
L545:
  lea    0x20(%rsp),%r12
  lea    D1290(%rip),%rsi
L1050:
  mov    %r12,%rdi
  call   <sprintf@plt>
  mov    %r12,%rsi
L1049:
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  nopl   0x0(%rax)
  shr    %r12b
  and    $0x8,%r15d
  movzbl %r12b,%r12d
  je     L1107
  mov    %rbp,%rdi
  lea    D1171(%rip),%rsi
  call   <strcpy@plt>
  lea    D649(%rip),%rdx
  mov    %rbp,%rdi
  mov    (%rdx,%r12,8),%rsi
  call   <strcat@plt>
  jmp    L1026
  nopl   0x0(%rax,%rax,1)
  lea    D1270(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  nopl   (%rax)
  lea    D1164(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
L995:
  and    $0x7,%r12d
  lea    D267(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  jmp    L1026
  nopl   0x0(%rax,%rax,1)
  lea    D1576(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L995
  nopl   0x0(%rax)
  and    $0x8,%r15d
  je     L459
  lea    D1576(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
L533:
  shr    %r12b
L625:
  and    $0x3,%r12d
  lea    D649(%rip),%rax
  mov    (%rax,%r12,8),%rsi
  jmp    L1049
  lea    D1219(%rip),%rsi
  mov    %rbp,%rdi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D267(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  lea    D1508(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzwl 0x4(%rsp),%eax
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L545
  nopl   0x0(%rax)
  lea    D954(%rip),%rsi
L603:
  mov    %rbp,%rdi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D1486(%rip),%rax
  mov    (%rax,%r12,8),%rsi
L483:
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcat@plt>
  lea    D1508(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzwl 0x4(%rsp),%eax
  lea    D1540(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L1050
  nopl   0x0(%rax,%rax,1)
  shr    %r12b
  testb  $0x1,0x8(%rsp)
  je     L169
  cmp    $0x2,%r12b
  je     L608
  cmp    $0x3,%r12b
  je     L593
  cmp    $0x1,%r12b
  je     L66
  lea    D57(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D1298(%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    L545
  cs nopw 0x0(%rax,%rax,1)
  shr    %r12b
  testb  $0x1,0x8(%rsp)
  je     L626
  test   %r12b,%r12b
  je     L1183
  cmp    $0x2,%r12b
  je     L337
  and    $0x20,%r15d
  lea    D853(%rip),%rax
  lea    0x1d(%rsp),%r14
  lea    D1014(%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     L1180
  cmp    $0x7d,%r12b
  ja     L880
  cmp    $0x36,%r12b
  ja     L1165
  cmp    $0x8,%r12b
  jbe    L1026
  sub    $0x9,%r12d
  cmp    $0x2d,%r12b
  ja     L1026
  lea    D138(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D535(%rip),%rsi
  jmp    L603
  nopl   0x0(%rax)
  and    $0x7,%r12d
  lea    D1524(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L1026
  nopl   0x0(%rax)
  lea    D475(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D803(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D724(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D940(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D415(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D565(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  movzbl 0x1(%rbx,%rax,1),%edx
L152:
  lea    D1290(%rip),%rsi
L536:
  mov    %r12,%rdi
  call   <sprintf@plt>
  mov    %r12,%rsi
L1005:
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D259(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  mov    %rbp,%rdi
  lea    D85(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  mov    %r12,%rdi
  lea    D1290(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D407(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  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     L1095
  ja     L184
  test   %al,%al
  je     L293
  cmp    $0x40,%al
  jne    L1026
  lea    D1026(%rip),%rsi
L1298:
  mov    %rbp,%rdi
  add    $0x30,%ebx
  call   <strcpy@plt>
  lea    0x20(%rsp),%rsi
  mov    %rbp,%rdi
  mov    %bl,0x20(%rsp)
  call   <strcat@plt>
  lea    D30(%rip),%rsi
L867:
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L995
  lea    D877(%rip),%rsi
L1188:
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  lea    D1540(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L536
  lea    D1228(%rip),%rsi
  jmp    L1188
  mov    %rbp,%rdi
  lea    D759(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  mov    %r12,%rdi
  lea    D1540(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1518(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  lea    D1423(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D1637(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D323(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  mov    %rbp,%rdi
  lea    D759(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  mov    %r12,%rdi
  lea    D1540(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1601(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  lea    D759(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  lea    D1290(%rip),%r14
  call   <strcat@plt>
  lea    D373(%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    D129(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x2(%rbx,%r15,1),%edx
  mov    %r14,%rsi
  jmp    L1050
  lea    D450(%rip),%rsi
L690:
  mov    %rbp,%rdi
  call   <strcpy@plt>
L1100:
  mov    %r14,%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcat@plt>
  lea    D373(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  jmp    L152
  lea    D1368(%rip),%rsi
  jmp    L690
  lea    D1576(%rip),%rsi
L116:
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  lea    D1219(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D753(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D1540(%rip),%rsi
  jmp    L536
  lea    D177(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D30(%rip),%rsi
L3:
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  lea    D1164(%rip),%rsi
  jmp    L116
  lea    D759(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D1540(%rip),%rsi
  mov    %r12,%rdi
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D631(%rip),%rsi
  jmp    L3
  lea    D1219(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D30(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D1540(%rip),%rsi
  jmp    L1050
  mov    %rbp,%rdi
  lea    D177(%rip),%rsi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1321(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  mov    %rbp,%rdi
  lea    D177(%rip),%rsi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1379(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  nopl   0x0(%rax)
  cmp    $0x2,%r12b
  je     L768
  ja     L841
  test   %r12b,%r12b
  je     L985
  cmp    $0x1,%r12b
  jne    L723
  lea    D784(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  mov    %rbp,%rdi
  lea    D168(%rip),%rsi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D1486(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  jmp    L1026
L841:
  lea    D1178(%rip),%rsi
  cmp    $0x3,%r12b
  jne    L723
L694:
  mov    %rbp,%rdi
  call   <strcpy@plt>
L600:
  mov    0x4(%rsp),%ecx
  lea    0x20(%rsp),%r12
  lea    D1540(%rip),%rsi
  movzwl %cx,%eax
  movzbl 0x1(%rbx,%rax,1),%edx
  mov    %ecx,%eax
  lea    0x2(%rdx,%rax,1),%edx
  movzbl %dl,%edx
  jmp    L1050
  nopl   (%rax)
L1107:
  lea    D1219(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  movslq %r12d,%rax
  lea    D649(%rip),%rdx
  mov    (%rdx,%rax,8),%rsi
  jmp    L483
  nopw   0x0(%rax,%rax,1)
L459:
  lea    D1164(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L533
L169:
  lea    D645(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  cmp    $0x3,%r12b
  jne    L625
  lea    D912(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
L626:
  lea    D1092(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  lea    D912(%rip),%rsi
  cmp    $0x3,%r12b
  jne    L625
  jmp    L1049
L1183:
  lea    D535(%rip),%rsi
L178:
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzwl 0x4(%rsp),%eax
  lea    D1540(%rip),%rsi
  movzbl 0x1(%rbx,%rax,1),%edx
  jmp    L1050
L1180:
  add    $0x35,%r12d
  cmp    $0x2e,%r12b
  ja     L1026
  lea    D1441(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D1260(%rip),%rsi
  jmp    L116
  lea    D479(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  jmp    L1005
  lea    D1092(%rip),%rsi
  jmp    L116
  lea    D315(%rip),%rsi
  jmp    L116
  lea    D645(%rip),%rsi
  jmp    L116
  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     L164
  ja     L477
  test   %al,%al
  je     L333
  lea    D1026(%rip),%rsi
  cmp    $0x40,%al
  jne    L172
L37:
  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    D30(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
L1:
  lea    D27(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D373(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  jmp    L152
  nopl   0x0(%rax)
L337:
  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     L446
  cmp    $0x80,%cl
  jne    L1026
  and    $0x1f,%edx
  lea    D517(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%rdx,8),%rsi
  call   <strcpy@plt>
  jmp    L1026
L1165:
  lea    -0x39(%r12),%ecx
  cmp    $0x3e,%cl
  ja     L1026
  movabs $0x5f80000000000000,%rdx
  mov    $0x1,%eax
  shl    %cl,%rax
  test   %rdx,%rax
  jne    L392
  movabs $0x20202020202000,%rdx
  test   %rdx,%rax
  jne    L310
  test   $0x1,%al
  je     L1026
  mov    %rbp,%rdi
  lea    D177(%rip),%rsi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D1627(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
  nopl   0x0(%rax,%rax,1)
L880:
  sub    $0x7e,%r12d
  cmp    $0x40,%r12b
  ja     L1026
  lea    D992(%rip),%rdx
  movzbl %r12b,%r12d
  movslq (%rdx,%r12,4),%rax
  add    %rdx,%rax
  notrack jmp *%rax
  lea    D818(%rip),%rsi
  jmp    L690
  lea    D237(%rip),%rsi
  jmp    L690
  lea    D1011(%rip),%rsi
  jmp    L690
  lea    D1624(%rip),%rsi
  jmp    L690
  lea    D977(%rip),%rsi
  jmp    L690
  lea    D915(%rip),%rsi
  jmp    L690
  lea    D1483(%rip),%rsi
  jmp    L690
  lea    D328(%rip),%rsi
  jmp    L690
  lea    D162(%rip),%rsi
  jmp    L690
  nop
L768:
  lea    D782(%rip),%rsi
  jmp    L694
L723:
  mov    %rbp,%rdi
  lea    D1178(%rip),%rsi
  call   <strcpy@plt>
  mov    0x8(%rsp),%r15
  lea    D1486(%rip),%rax
  mov    %rbp,%rdi
  and    $0x3,%r15d
  mov    (%rax,%r15,8),%rsi
  call   <strcat@plt>
  lea    D1508(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L600
L985:
  lea    D666(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
L608:
  lea    D114(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
L66:
  lea    D1127(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
L593:
  lea    D704(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
  lea    D954(%rip),%rsi
  jmp    L178
  lea    D53(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L1026
L184:
  lea    D488(%rip),%rsi
  cmp    $0xc0,%al
  je     L1298
  jmp    L1026
L446:
  mov    %edx,%ecx
  lea    D163(%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    D418(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L1026
  mov    %rbp,%rdi
  lea    D583(%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    L1026
  and    $0x7,%r12d
  lea    D136(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L1026
  and    $0x7,%r12d
  lea    D1285(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  jmp    L1026
  lea    0x1(%rbx,%rax,1),%r14
  mov    %r12d,%ebx
  shr    %bl
  and    $0x1,%cl
  movzbl %bl,%ebx
  je     L416
  lea    D1219(%rip),%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  lea    D649(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%rbx,8),%rsi
  call   <strcat@plt>
  lea    D470(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl (%r14),%edx
  lea    D1540(%rip),%rsi
  jmp    L536
  and    $0x1,%cl
  je     L134
  lea    D21(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
L325:
  mov    %rbp,%rdi
  lea    D106(%rip),%rsi
  call   <strcat@plt>
  mov    %r12d,%eax
  lea    D649(%rip),%rdx
  mov    %rbp,%rdi
  shr    %al
  and    $0x3,%eax
  mov    (%rdx,%rax,8),%rsi
  call   <strcat@plt>
  jmp    L1026
  lea    D1510(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L995
L293:
  lea    D531(%rip),%rax
  and    $0x7,%ebx
  mov    %rbp,%rdi
  mov    (%rax,%rbx,8),%rsi
  call   <strcpy@plt>
  lea    D394(%rip),%rsi
  jmp    L867
L1095:
  lea    D514(%rip),%rsi
  jmp    L1298
L1250:
  call   <__stack_chk_fail@plt>
  mov    %rbp,%rdi
  lea    D739(%rip),%rsi
  and    $0x7,%r12d
  call   <strcpy@plt>
  lea    D267(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcat@plt>
  lea    D1230(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1026
L310:
  mov    %rbp,%rdi
  lea    D1219(%rip),%rsi
  call   <strcpy@plt>
  mov    %r12d,%eax
  lea    D267(%rip),%rdx
  mov    %rbp,%rdi
  shr    $0x3,%al
  and    $0x7,%eax
  mov    (%rdx,%rax,8),%rsi
  call   <strcat@plt>
  lea    D470(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L1100
L392:
  lea    D759(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  lea    0x20(%rsp),%r14
  call   <strcat@plt>
  lea    D373(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  movzbl 0x1(%rbx,%r15,1),%edx
  lea    D1290(%rip),%rsi
  mov    %r14,%rdi
  call   <sprintf@plt>
  mov    %r14,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  lea    D129(%rip),%rsi
  jmp    L867
L477:
  lea    D488(%rip),%rsi
  cmp    $0xc0,%al
  je     L37
L172:
  lea    0x20(%rsp),%r12
  jmp    L1
L416:
  mov    %rbp,%rdi
  lea    D759(%rip),%rsi
  lea    0x20(%rsp),%r12
  call   <strcpy@plt>
  movzbl (%r14),%edx
  mov    %r12,%rdi
  lea    D1540(%rip),%rsi
  call   <sprintf@plt>
  mov    %r12,%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  mov    %rbp,%rdi
  lea    D129(%rip),%rsi
  call   <strcat@plt>
  lea    D649(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%rbx,8),%rsi
  call   <strcat@plt>
  jmp    L1026
L134:
  lea    D1580(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcpy@plt>
  jmp    L325
L164:
  lea    D514(%rip),%rsi
  jmp    L37
L333:
  and    $0x7,%r12d
  lea    D531(%rip),%rax
  mov    %rbp,%rdi
  mov    (%rax,%r12,8),%rsi
  call   <strcpy@plt>
  lea    D394(%rip),%rsi
  mov    %rbp,%rdi
  call   <strcat@plt>
  jmp    L172
```

tool_calls: name: unpack_data
arguments: data_label: D1219
type_infered: string
name: unpack_data
arguments: data_label: D1508
type_infered: string
name: unpack_data
arguments: data_label: D478
type_infered: string
name: unpack_data
arguments: data_label: D241
type_infered: string
name: unpack_data
arguments: data_label: D1290
type_infered: string
name: unpack_data
arguments: data_label: D1171
type_infered: string
name: unpack_data
arguments: data_label: D1164
type_infered: string
name: unpack_data
arguments: data_label: D1576
type_infered: string
name: unpack_data
arguments: data_label: D954
type_infered: string
name: unpack_data
arguments: data_label: D1540
type_infered: string
name: unpack_data
arguments: data_label: D57
type_infered: string
name: unpack_data
arguments: data_label: D853
type_infered: string
name: unpack_data
arguments: data_label: D1014
type_infered: string
name: unpack_data
arguments: data_label: D535
type_infered: string
name: unpack_data
arguments: data_label: D803
type_infered: string
name: unpack_data
arguments: data_label: D724
type_infered: string
name: unpack_data
arguments: data_label: D940
type_infered: string
name: unpack_data
arguments: data_label: D415
type_infered: string
name: unpack_data
arguments: data_label: D565
type_infered: string
name: unpack_data
arguments: data_label: D259
type_infered: string
name: unpack_data
arguments: data_label: D85
type_infered: string
name: unpack_data
arguments: data_label: D407
type_infered: string
name: unpack_data
arguments: data_label: D1026
type_infered: string
name: unpack_data
arguments: data_label: D30
type_infered: string
name: unpack_data
arguments: data_label: D877
type_infered: string
name: unpack_data
arguments: data_label: D1228
type_infered: string
name: unpack_data
arguments: data_label: D759
type_infered: string
name: unpack_data
arguments: data_label: D1518
type_infered: string
name: unpack_data
arguments: data_label: D1423
type_infered: string
name: unpack_data
arguments: data_label: D1637
type_infered: string
name: unpack_data
arguments: data_label: D323
type_infered: string
name: unpack_data
arguments: data_label: D1601
type_infered: string
name: unpack_data
arguments: data_label: D373
type_infered: string
name: unpack_data
arguments: data_label: D129
type_infered: string
name: unpack_data
arguments: data_label: D450
type_infered: string
name: unpack_data
arguments: data_label: D1368
type_infered: string
name: unpack_data
arguments: data_label: D753
type_infered: string
name: unpack_data
arguments: data_label: D177
type_infered: string
name: unpack_data
arguments: data_label: D631
type_infered: string
name: unpack_data
arguments: data_label: D1321
type_infered: string
name: unpack_data
arguments: data_label: D1379
type_infered: string
name: unpack_data
arguments: data_label: D784
type_infered: string
name: unpack_data
arguments: data_label: D168
type_infered: string
name: unpack_data
arguments: data_label: D1178
type_infered: string
name: unpack_data
arguments: data_label: D645
type_infered: string
name: unpack_data
arguments: data_label: D912
type_infered: string
name: unpack_data
arguments: data_label: D1092
type_infered: string
name: unpack_data
arguments: data_label: D1260
type_infered: string
name: unpack_data
arguments: data_label: D479
type_infered: string
name: unpack_data
arguments: data_label: D315
type_infered: string
name: unpack_data
arguments: data_label: D27
type_infered: string
name: unpack_data
arguments: data_label: D1627
type_infered: string
name: unpack_data
arguments: data_label: D818
type_infered: string
name: unpack_data
arguments: data_label: D237
type_infered: string
name: unpack_data
arguments: data_label: D1011
type_infered: string
name: unpack_data
arguments: data_label: D1624
type_infered: string
name: unpack_data
arguments: data_label: D977
type_infered: string
name: unpack_data
arguments: data_label: D915
type_infered: string
name: unpack_data
arguments: data_label: D1483
type_infered: string
name: unpack_data
arguments: data_label: D328
type_infered: string
name: unpack_data
arguments: data_label: D162
type_infered: string
name: unpack_data
arguments: data_label: D782
type_infered: string
name: unpack_data
arguments: data_label: D666
type_infered: string
name: unpack_data
arguments: data_label: D114
type_infered: string
name: unpack_data
arguments: data_label: D1127
type_infered: string
name: unpack_data
arguments: data_label: D704
type_infered: string
name: unpack_data
arguments: data_label: D53
type_infered: string
name: unpack_data
arguments: data_label: D488
type_infered: string
name: unpack_data
arguments: data_label: D583
type_infered: string
name: unpack_data
arguments: data_label: D470
type_infered: string
name: unpack_data
arguments: data_label: D21
type_infered: string
name: unpack_data
arguments: data_label: D106
type_infered: string
name: unpack_data
arguments: data_label: D1510
type_infered: string
name: unpack_data
arguments: data_label: D394
type_infered: string
name: unpack_data
arguments: data_label: D514
type_infered: string
name: unpack_data
arguments: data_label: D739
type_infered: string
name: unpack_data
arguments: data_label: D1230
type_infered: string
name: unpack_data
arguments: data_label: D1580
type_infered: string

tool: D1219: ld 

tool: D1508: , 

tool: D478: halt

tool: D241: rst 

tool: D1290: 0x%2.2X

tool: D1171: add hl, 

tool: D1164: inc 

tool: D1576: dec 

tool: D954: jp 

tool: D1540: 0x%4.4X

tool: D57: ret

tool: D853: ix

tool: D1014: iy

tool: D535: call 

tool: D803: ei

tool: D724: di

tool: D940: ex de, hl

tool: D415: ex (sp), hl

tool: D565: in a, (

tool: D259: )

tool: D85: out (

tool: D407: ),A

tool: D1026: bit 

tool: D30: ,

tool: D877: ld a,(

tool: D1228: ld hl, (

tool: D759: ld (

tool: D1518: ), hl

tool: D1423: ld a, (de)

tool: D1637: ld (de), a

tool: D323: ld a, (bc)

tool: D1601: ), a

tool: D373: +

tool: D129: ),

tool: D450: dec (

tool: D1368: inc (

tool: D753: , (

tool: D177: add 

tool: D631: ), 

tool: D1321: , de

tool: D1379: , bc

tool: D784: ex af, af'

tool: D168: ret 

tool: D1178: jr 

tool: D645: pop 

tool: D912: af

tool: D1092: push 

tool: D1260: ld sp, 

tool: D479: jp (

tool: D315: ex (sp), 

tool: D27: (

tool: D1627: , sp

tool: D818: cp a,(

tool: D237: or a,(

tool: D1011: xor a, (

tool: D1624: and a,(

tool: D977: sbc a, (

tool: D915: sub (

tool: D1483: adc a,(

tool: D328: add A, (

tool: D162: ld A,(

tool: D782: djnz 

tool: D666: nop

tool: D114: jp (hl)

tool: D1127: exx

tool: D704: ld sp,hl

tool: D53: ld (bc), a

tool: D488: set 

tool: D583: im 

tool: D470: ,(

tool: D21: adc

tool: D106:  HL, 

tool: D1510: out (c), 

tool: D394:  

tool: D514: res 

tool: D739: in 

tool: D1230: , (c)

tool: D1580: 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;
}
```