#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ sprintf(char *, char *, unsigned char);
int /*<<< orphan*/ strcat(char *, char *);
int /*<<< orphan*/ strcpy(char *, char *);
void z80_Disassemble(unsigned char *Opcodes, unsigned short adr, char *s) {
  unsigned char a = Opcodes[adr];
  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];
  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 char *str[8] = {"rlca", "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\t\t(");
                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 ");
        if ((d >> 1) == 3)
          strcat(s, "af");
        else
          strcat(s, 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;
  }
}


x86 assembly (clang, -O0):
<z80_Disassemble>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %si,%ax
mov    %rdi,-0x8(%rbp)
mov    %ax,-0xa(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1a(%rbp)
mov    -0x19(%rbp),%al
and    $0x7,%al
mov    %al,-0x1b(%rbp)
movzbl -0x19(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0x78(%rbp)
je     11b9 <z80_Disassemble+0x89>
jmp    1182 <z80_Disassemble+0x52>
mov    -0x78(%rbp),%eax
sub    $0x40,%eax
je     179d <z80_Disassemble+0x66d>
jmp    1193 <z80_Disassemble+0x63>
mov    -0x78(%rbp),%eax
sub    $0x80,%eax
je     181b <z80_Disassemble+0x6eb>
jmp    11a6 <z80_Disassemble+0x76>
mov    -0x78(%rbp),%eax
sub    $0xc0,%eax
je     1854 <z80_Disassemble+0x724>
jmp    2f1f <z80_Disassemble+0x1def>
movzbl -0x1b(%rbp),%eax
mov    %rax,-0x80(%rbp)
sub    $0x7,%rax
ja     1798 <z80_Disassemble+0x668>
mov    -0x80(%rbp),%rax
lea    0x225e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl -0x1a(%rbp),%eax
mov    %rax,-0x88(%rbp)
sub    $0x3,%rax
ja     12d5 <z80_Disassemble+0x1a5>
mov    -0x88(%rbp),%rax
lea    0x2272(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x22ab(%rip),%rsi
call   1030 <strcpy@plt>
jmp    134e <z80_Disassemble+0x21e>
mov    -0x18(%rbp),%rdi
lea    0x229a(%rip),%rsi
call   1030 <strcpy@plt>
jmp    134e <z80_Disassemble+0x21e>
mov    -0x18(%rbp),%rdi
lea    0x228f(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzwl -0xa(%rbp),%eax
add    $0x2,%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
lea    0x226a(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    134e <z80_Disassemble+0x21e>
mov    -0x18(%rbp),%rdi
lea    0x224d(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzwl -0xa(%rbp),%eax
add    $0x2,%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
lea    0x221a(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    134e <z80_Disassemble+0x21e>
mov    -0x18(%rbp),%rdi
lea    0x21fd(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0x3da6(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x23df(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
movzwl -0xa(%rbp),%eax
add    $0x2,%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
lea    0x219c(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    1798 <z80_Disassemble+0x668>
movzbl -0x19(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     1396 <z80_Disassemble+0x266>
mov    -0x18(%rbp),%rdi
lea    0x2173(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3cf8(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    141d <z80_Disassemble+0x2ed>
mov    -0x18(%rbp),%rdi
lea    0x2148(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3cc5(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x231e(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x20cd(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    1798 <z80_Disassemble+0x668>
movzbl -0x1a(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0x7,%rax
ja     1655 <z80_Disassemble+0x525>
mov    -0x90(%rbp),%rax
lea    0x200f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2094(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1655 <z80_Disassemble+0x525>
mov    -0x18(%rbp),%rdi
lea    0x2089(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1655 <z80_Disassemble+0x525>
mov    -0x18(%rbp),%rdi
lea    0x207f(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1655 <z80_Disassemble+0x525>
mov    -0x18(%rbp),%rdi
lea    0x2075(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1655 <z80_Disassemble+0x525>
mov    -0x18(%rbp),%rdi
lea    0x206b(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1fef(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x20c7(%rip),%rsi
call   1040 <strcat@plt>
jmp    1655 <z80_Disassemble+0x525>
mov    -0x18(%rbp),%rdi
lea    0x2002(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1f81(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x207a(%rip),%rsi
call   1040 <strcat@plt>
jmp    1655 <z80_Disassemble+0x525>
mov    -0x18(%rbp),%rdi
lea    0x1f8f(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1f13(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f26(%rip),%rsi
call   1040 <strcat@plt>
jmp    1655 <z80_Disassemble+0x525>
mov    -0x18(%rbp),%rdi
lea    0x1f2f(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1ea5(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f9e(%rip),%rsi
call   1040 <strcat@plt>
jmp    1798 <z80_Disassemble+0x668>
movzbl -0x19(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     167f <z80_Disassemble+0x54f>
mov    -0x18(%rbp),%rdi
lea    0x1eb9(%rip),%rsi
call   1030 <strcpy@plt>
jmp    168f <z80_Disassemble+0x55f>
mov    -0x18(%rbp),%rdi
lea    0x1ea9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x39dc(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    1798 <z80_Disassemble+0x668>
mov    -0x18(%rbp),%rdi
lea    0x1e76(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x396d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    1798 <z80_Disassemble+0x668>
mov    -0x18(%rbp),%rdi
lea    0x1e42(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x393e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    1798 <z80_Disassemble+0x668>
mov    -0x18(%rbp),%rdi
lea    0x1dce(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x390f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1fa8(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x1dd5(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    1798 <z80_Disassemble+0x668>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x3991(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2f1f <z80_Disassemble+0x1def>
movzbl -0x1a(%rbp),%eax
movzbl -0x1b(%rbp),%ecx
cmp    %ecx,%eax
jne    17c2 <z80_Disassemble+0x692>
mov    -0x18(%rbp),%rdi
lea    0x1daa(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1816 <z80_Disassemble+0x6e6>
mov    -0x18(%rbp),%rdi
lea    0x1d1c(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x385d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1ef6(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    %eax,%ecx
lea    0x3833(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    2f1f <z80_Disassemble+0x1def>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x38b4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    %eax,%ecx
lea    0x37fa(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    2f1f <z80_Disassemble+0x1def>
movzbl -0x1b(%rbp),%eax
mov    %rax,-0x98(%rbp)
sub    $0x7,%rax
ja     2f1a <z80_Disassemble+0x1dea>
mov    -0x98(%rbp),%rax
lea    0x1789(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1cdc(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x37ff(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    2f1a <z80_Disassemble+0x1dea>
movzbl -0x1a(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1942 <z80_Disassemble+0x812>
movzbl -0x1a(%rbp),%eax
shr    %eax
mov    %eax,%ecx
mov    %rcx,-0xa0(%rbp)
sub    $0x3,%eax
ja     193d <z80_Disassemble+0x80d>
mov    -0xa0(%rbp),%rax
lea    0x1b3f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1c73(%rip),%rsi
call   1030 <strcpy@plt>
jmp    193d <z80_Disassemble+0x80d>
mov    -0x18(%rbp),%rdi
lea    0x1c62(%rip),%rsi
call   1030 <strcpy@plt>
jmp    193d <z80_Disassemble+0x80d>
mov    -0x18(%rbp),%rdi
lea    0x1c51(%rip),%rsi
call   1030 <strcpy@plt>
jmp    193d <z80_Disassemble+0x80d>
mov    -0x18(%rbp),%rdi
lea    0x1c44(%rip),%rsi
call   1030 <strcpy@plt>
jmp    199a <z80_Disassemble+0x86a>
mov    -0x18(%rbp),%rdi
lea    0x1c39(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    1977 <z80_Disassemble+0x847>
mov    -0x18(%rbp),%rdi
lea    0x1b5f(%rip),%rsi
call   1040 <strcat@plt>
jmp    1995 <z80_Disassemble+0x865>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x36f4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    199a <z80_Disassemble+0x86a>
jmp    2f1a <z80_Disassemble+0x1dea>
mov    -0x18(%rbp),%rdi
lea    0x1be1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x36e0(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1d19(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1ac8(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2f1a <z80_Disassemble+0x1dea>
movzbl -0x1a(%rbp),%eax
mov    %rax,-0xa8(%rbp)
sub    $0x7,%rax
ja     1d81 <z80_Disassemble+0xc51>
mov    -0xa8(%rbp),%rax
lea    0x19ba(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1b2d(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1a3e(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    1d81 <z80_Disassemble+0xc51>
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%edx
add    $0x1,%edx
mov    %dx,%cx
mov    %cx,-0xa(%rbp)
mov    %edx,%ecx
movzwl %cx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1a(%rbp)
mov    -0x19(%rbp),%al
and    $0x7,%al
mov    %al,-0x1b(%rbp)
movb   $0x0,-0x6f(%rbp)
movzbl -0x19(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0xac(%rbp)
je     1b3f <z80_Disassemble+0xa0f>
jmp    1aff <z80_Disassemble+0x9cf>
mov    -0xac(%rbp),%eax
sub    $0x40,%eax
je     1b88 <z80_Disassemble+0xa58>
jmp    1b13 <z80_Disassemble+0x9e3>
mov    -0xac(%rbp),%eax
sub    $0x80,%eax
je     1bde <z80_Disassemble+0xaae>
jmp    1b29 <z80_Disassemble+0x9f9>
mov    -0xac(%rbp),%eax
sub    $0xc0,%eax
je     1c34 <z80_Disassemble+0xb04>
jmp    1c85 <z80_Disassemble+0xb55>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x3610(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x1b8a(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    %eax,%ecx
lea    0x34c6(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    1c85 <z80_Disassemble+0xb55>
mov    -0x18(%rbp),%rdi
lea    0x1a17(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1b33(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    %eax,%ecx
lea    0x3470(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    1c85 <z80_Disassemble+0xb55>
mov    -0x18(%rbp),%rdi
lea    0x19c6(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1add(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    %eax,%ecx
lea    0x341a(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    1c85 <z80_Disassemble+0xb55>
mov    -0x18(%rbp),%rdi
lea    0x1975(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1a87(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    %eax,%ecx
lea    0x33c4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    1d81 <z80_Disassemble+0xc51>
mov    -0x18(%rbp),%rdi
lea    0x1924(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x1885(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1834(%rip),%rsi
call   1040 <strcat@plt>
jmp    1d81 <z80_Disassemble+0xc51>
mov    -0x18(%rbp),%rdi
lea    0x18d6(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x1831(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x18c6(%rip),%rsi
call   1040 <strcat@plt>
jmp    1d81 <z80_Disassemble+0xc51>
mov    -0x18(%rbp),%rdi
lea    0x188a(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1d81 <z80_Disassemble+0xc51>
mov    -0x18(%rbp),%rdi
lea    0x1881(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1d81 <z80_Disassemble+0xc51>
mov    -0x18(%rbp),%rdi
lea    0x18d0(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1d81 <z80_Disassemble+0xc51>
mov    -0x18(%rbp),%rdi
lea    0x1861(%rip),%rsi
call   1030 <strcpy@plt>
jmp    2f1a <z80_Disassemble+0x1dea>
mov    -0x18(%rbp),%rdi
lea    0x184f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x32f9(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1932(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x16e1(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2f1a <z80_Disassemble+0x1dea>
movzbl -0x1a(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2e38 <z80_Disassemble+0x1d08>
movzbl -0x1a(%rbp),%eax
shr    %eax
mov    %eax,-0xb0(%rbp)
test   %eax,%eax
je     1e4b <z80_Disassemble+0xd1b>
jmp    1e37 <z80_Disassemble+0xd07>
mov    -0xb0(%rbp),%eax
sub    $0x2,%eax
je     1ea9 <z80_Disassemble+0xd79>
jmp    21f7 <z80_Disassemble+0x10c7>
mov    -0x18(%rbp),%rdi
lea    0x178a(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1646(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e33 <z80_Disassemble+0x1d03>
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%edx
add    $0x1,%edx
mov    %dx,%cx
mov    %cx,-0xa(%rbp)
mov    %edx,%ecx
movzwl %cx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1a(%rbp)
mov    -0x19(%rbp),%al
and    $0x7,%al
mov    %al,-0x1b(%rbp)
movzbl -0x19(%rbp),%eax
and    $0xffffffc0,%eax
mov    %eax,-0xb4(%rbp)
sub    $0x40,%eax
je     1f0a <z80_Disassemble+0xdda>
jmp    1ef4 <z80_Disassemble+0xdc4>
mov    -0xb4(%rbp),%eax
sub    $0x80,%eax
je     21d4 <z80_Disassemble+0x10a4>
jmp    21f2 <z80_Disassemble+0x10c2>
movzbl -0x1b(%rbp),%eax
mov    %rax,-0xc0(%rbp)
sub    $0x7,%rax
ja     21cf <z80_Disassemble+0x109f>
mov    -0xc0(%rbp),%rax
lea    0x10f3(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x16a5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x30e9(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x167f(%rip),%rsi
call   1040 <strcat@plt>
jmp    21cf <z80_Disassemble+0x109f>
mov    -0x18(%rbp),%rdi
lea    0x1670(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x30aa(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    21cf <z80_Disassemble+0x109f>
movzbl -0x1a(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1fc9 <z80_Disassemble+0xe99>
mov    -0x18(%rbp),%rdi
lea    0x163a(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1fd9 <z80_Disassemble+0xea9>
mov    -0x18(%rbp),%rdi
lea    0x1629(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x161d(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3082(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    21cf <z80_Disassemble+0x109f>
movzbl -0x1a(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     20b8 <z80_Disassemble+0xf88>
mov    -0x18(%rbp),%rdi
lea    0x14c2(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x303f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1673(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1447(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1540(%rip),%rsi
call   1040 <strcat@plt>
jmp    213f <z80_Disassemble+0x100f>
mov    -0x18(%rbp),%rdi
lea    0x1544(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x13d9(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x14da(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x2f4a(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    21cf <z80_Disassemble+0x109f>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x304b(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    21cf <z80_Disassemble+0x109f>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x306c(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    21cf <z80_Disassemble+0x109f>
mov    -0x18(%rbp),%rdi
lea    0x148e(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
add    $0x30,%eax
sub    $0x1,%eax
mov    %al,-0x70(%rbp)
movb   $0x0,-0x6f(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    21cf <z80_Disassemble+0x109f>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x305a(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    21f2 <z80_Disassemble+0x10c2>
mov    -0x18(%rbp),%rdi
movzbl -0x19(%rbp),%eax
and    $0x1f,%eax
movslq %eax,%rcx
lea    0x3077(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2e33 <z80_Disassemble+0x1d03>
movzbl -0x19(%rbp),%eax
mov    %al,%cl
lea    0x147c(%rip),%rax
lea    0x1478(%rip),%rsi
test   $0x20,%cl
cmovne %rax,%rsi
lea    -0x73(%rbp),%rdi
call   1030 <strcpy@plt>
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%edx
add    $0x1,%edx
mov    %dx,%cx
mov    %cx,-0xa(%rbp)
mov    %edx,%ecx
movzwl %cx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
add    $0xfffffff7,%eax
mov    %eax,%ecx
mov    %rcx,-0xc8(%rbp)
sub    $0xf0,%eax
ja     2e2e <z80_Disassemble+0x1cfe>
mov    -0xc8(%rbp),%rax
lea    0xddf(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1411(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x13f9(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x13df(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x13cc(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x1210(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x13f7(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x11a6(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x11c4(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1148(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x133f(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x1164(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x1295(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x12df(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x10b9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x127b(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzwl -0xa(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x104f(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1148(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x1073(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x11b8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x11a1(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x1020(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x10b5(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x114f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1130(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xfaf(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1044(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xf59(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x10bf(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xf3e(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xfdb(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
lea    0xeff(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x1027(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1027(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xe58(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x19(%rbp),%eax
sar    $0x3,%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x2992(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xfe6(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xfbc(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xe3b(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xed0(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xde5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xf4b(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xdca(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xe67(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x19(%rbp),%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x2897(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xd64(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xebc(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xd3b(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xdd0(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xe78(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xe4b(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xcca(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xd5f(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xe10(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xdda(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xc59(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xcee(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xda8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xd69(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xbe8(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc7d(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xd3d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xcf8(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xb77(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc0c(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xcd5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc87(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xb06(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb9b(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xc6d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc16(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xa95(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb2a(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xbfd(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xba5(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xa24(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xab9(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xb94(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb34(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x9b3(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xa48(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0x9cb(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xb09(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xaf1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xad5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x9b0(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x18(%rbp),%rdi
lea    0xaa8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2e2e <z80_Disassemble+0x1cfe>
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x2,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x19(%rbp)
mov    -0x19(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1a(%rbp)
movb   $0x0,-0x6f(%rbp)
movzbl -0x19(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0xcc(%rbp)
je     2ce4 <z80_Disassemble+0x1bb4>
jmp    2ca4 <z80_Disassemble+0x1b74>
mov    -0xcc(%rbp),%eax
sub    $0x40,%eax
je     2d13 <z80_Disassemble+0x1be3>
jmp    2cb8 <z80_Disassemble+0x1b88>
mov    -0xcc(%rbp),%eax
sub    $0x80,%eax
je     2d4f <z80_Disassemble+0x1c1f>
jmp    2cce <z80_Disassemble+0x1b9e>
mov    -0xcc(%rbp),%eax
sub    $0xc0,%eax
je     2d8b <z80_Disassemble+0x1c5b>
jmp    2dc2 <z80_Disassemble+0x1c92>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x266b(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x9e5(%rip),%rsi
call   1040 <strcat@plt>
jmp    2dc2 <z80_Disassemble+0x1c92>
mov    -0x18(%rbp),%rdi
lea    0x88c(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x9a8(%rip),%rsi
call   1040 <strcat@plt>
jmp    2dc2 <z80_Disassemble+0x1c92>
mov    -0x18(%rbp),%rdi
lea    0x9c0(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x96c(%rip),%rsi
call   1040 <strcat@plt>
jmp    2dc2 <z80_Disassemble+0x1c92>
mov    -0x18(%rbp),%rdi
lea    0x81e(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x930(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x83e(%rip),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x8b1(%rip),%rsi
call   1040 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x730(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x7c5(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e33 <z80_Disassemble+0x1d03>
jmp    2e90 <z80_Disassemble+0x1d60>
mov    -0x18(%rbp),%rdi
lea    0x8ad(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    2e6d <z80_Disassemble+0x1d3d>
mov    -0x18(%rbp),%rdi
lea    0x669(%rip),%rsi
call   1040 <strcat@plt>
jmp    2e8b <z80_Disassemble+0x1d5b>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x21fe(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1040 <strcat@plt>
jmp    2e90 <z80_Disassemble+0x1d60>
jmp    2f1a <z80_Disassemble+0x1dea>
mov    -0x18(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    %eax,%ecx
lea    0x223a(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x8(%rbp),%rax
movzwl -0xa(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x670(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2f1a <z80_Disassemble+0x1dea>
mov    -0x18(%rbp),%rdi
lea    0x830(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzbl -0x19(%rbp),%eax
and    $0x38,%eax
lea    0x633(%rip),%rsi
movzbl %al,%edx
call   1050 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <strcat@plt>
jmp    2f1f <z80_Disassemble+0x1def>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<z80_Disassemble>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %esi,%r12d
mov    %rdi,%r15
mov    %esi,%r13d
movzbl (%rdi,%r13,1),%ebp
mov    %ebp,%r14d
shr    $0x3,%r14d
and    $0x7,%r14d
mov    %ebp,%ebx
and    $0x7,%ebx
mov    %rbp,%rax
shr    $0x6,%rax
lea    0xe96(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    %ebx,%eax
lea    0x1308(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmp    $0x3,%r14d
ja     154f <z80_Disassemble+0x41f>
mov    %r14d,%eax
lea    0x132b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x14a8(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
cmp    %bl,%r14b
jne    1224 <z80_Disassemble+0xf4>
lea    0x1538(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
movzbl %r14b,%eax
lea    0x2c16(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl %bl,%eax
lea    0x2b5d(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %rbp,%rdi
jmp    14e6 <z80_Disassemble+0x3b6>
movzbl %bl,%eax
lea    0xe17(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x14ee(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x2b81(%rip),%rcx
jmp    14df <z80_Disassemble+0x3af>
lea    0x144e(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x2aff(%rip),%r14
mov    (%r14,%rax,8),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
lea    0x1629(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
mov    (%r14,%rbx,8),%rsi
mov    %rbp,%rdi
jmp    14e6 <z80_Disassemble+0x3b6>
test   $0x8,%bpl
jne    14bf <z80_Disassemble+0x38f>
lea    0x1400(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
shr    %r14b
movzbl %r14b,%eax
lea    0x2aee(%rip),%rcx
jmp    13da <z80_Disassemble+0x2aa>
movzbl %r14b,%eax
lea    0x1202(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x13cb(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
test   $0x8,%bpl
lea    0x1401(%rip),%rax
lea    0x13f5(%rip),%rsi
cmove  %rax,%rsi
jmp    14c6 <z80_Disassemble+0x396>
lea    0x13ea(%rip),%rsi
jmp    12e2 <z80_Disassemble+0x1b2>
lea    0x13dc(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x2a48(%rip),%rcx
jmp    14df <z80_Disassemble+0x3af>
lea    0x1375(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x2a26(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
lea    0x1550(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
jmp    1458 <z80_Disassemble+0x328>
movzbl %r14b,%eax
lea    0x118f(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %rdx,%rdi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <strcpy@plt>
movzbl %r14b,%ebx
test   $0x1,%r14b
jne    14f9 <z80_Disassemble+0x3c9>
lea    0x139f(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
shr    %ebx
cmp    $0x3,%ebx
je     142f <z80_Disassemble+0x2ff>
mov    %ebx,%eax
jmp    1543 <z80_Disassemble+0x413>
lea    0x1380(%rip),%rsi
jmp    13c4 <z80_Disassemble+0x294>
movzbl %r14b,%eax
lea    0x109c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x1363(%rip),%rsi
jmp    1531 <z80_Disassemble+0x401>
lea    0x13ac(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x29c6(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
lea    0x1490(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r13,%r15,1),%edx
lea    0x1263(%rip),%rsi
jmp    1465 <z80_Disassemble+0x335>
movzbl %r14b,%ebx
test   $0x1,%r14b
jne    1517 <z80_Disassemble+0x3e7>
lea    0x1467(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
shr    %ebx
cmp    $0x3,%ebx
jne    1541 <z80_Disassemble+0x411>
lea    0x1226(%rip),%rsi
mov    %rbp,%rdi
jmp    14e6 <z80_Disassemble+0x3b6>
movzbl %r14b,%eax
lea    0x2997(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%r13,%r15,1),%edx
lea    0x1263(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x141b(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
and    $0x38,%ebp
lea    0x1220(%rip),%rsi
lea    0x10(%rsp),%r15
mov    %r15,%rdi
mov    %ebp,%edx
call   1050 <sprintf@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
jmp    1478 <z80_Disassemble+0x348>
lea    0x11ab(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
shr    %r14b
movzbl %r14b,%eax
lea    0x28a1(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %rbx,%rdi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <strcat@plt>
shr    %ebx
lea    0xf72(%rip),%rax
movslq (%rax,%rbx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
lea    0x11ea(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
shr    %ebx
cmp    $0x2,%ebx
je     15c2 <z80_Disassemble+0x492>
test   %ebx,%ebx
jne    1632 <z80_Disassemble+0x502>
lea    0x123f(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
jmp    13f5 <z80_Disassemble+0x2c5>
mov    %ebx,%eax
lea    0x2836(%rip),%rcx
jmp    11e3 <z80_Disassemble+0xb3>
lea    0x1117(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
and    $0x3,%r14d
lea    0x2834(%rip),%rax
mov    (%rax,%r14,8),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
lea    0x12fe(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
jmp    15b0 <z80_Disassemble+0x480>
lea    0x10c5(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0x10c3(%rip),%rsi
jmp    15a5 <z80_Disassemble+0x475>
lea    0x10c8(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
mov    0x1(%r13,%r15,1),%al
add    %r12b,%al
add    $0x2,%al
movzbl %al,%edx
jmp    13fb <z80_Disassemble+0x2cb>
lea    0x1(%r12),%eax
movzwl %ax,%ebx
movzbl (%r15,%rbx,1),%eax
mov    %eax,%ecx
and    $0xc0,%cl
cmp    $0x80,%cl
je     18d5 <z80_Disassemble+0x7a5>
cmp    $0x40,%cl
jne    147d <z80_Disassemble+0x34d>
mov    %eax,%ebp
shr    $0x3,%ebp
and    $0x7,%ebp
and    $0x7,%eax
lea    0xa38(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x116e(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
lea    0x2726(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0x114d(%rip),%rsi
jmp    14e3 <z80_Disassemble+0x3b3>
test   $0x20,%bpl
lea    0x11d6(%rip),%rax
lea    0x11cc(%rip),%rsi
cmove  %rax,%rsi
lea    0xd(%rsp),%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
lea    0x1(%r12),%eax
movzwl %ax,%r12d
movzbl (%r15,%r12,1),%ebp
lea    0x7a(%rbp),%eax
cmp    $0xf8,%al
ja     147d <z80_Disassemble+0x34d>
movzbl %al,%eax
lea    0x9d8(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x1020(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0x1187(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r12,%r15,1),%edx
lea    0x100f(%rip),%rsi
lea    0x10(%rsp),%r14
mov    %r14,%rdi
call   1050 <sprintf@plt>
mov    %rbx,%rdi
mov    %r14,%rsi
call   1040 <strcat@plt>
lea    0x10ae(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
and    $0x7,%ebp
lea    0x2656(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %rbx,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xf8a(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xf89(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xf88(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xf87(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%r13,%r15,1),%edx
lea    0xf2c(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
lea    0x1005(%rip),%rsi
mov    %rbp,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xf46(%rip),%rsi
jmp    1794 <z80_Disassemble+0x664>
lea    0xf38(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%r13,%r15,1),%edx
lea    0xedd(%rip),%rsi
jmp    183d <z80_Disassemble+0x70d>
lea    0xf22(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%r13,%r15,1),%edx
lea    0xeb9(%rip),%rsi
jmp    1deb <z80_Disassemble+0xcbb>
lea    0x1(%r12),%eax
movzwl %ax,%eax
movzbl (%r15,%rax,1),%ebp
movzbl %bpl,%eax
mov    %ebp,%ebx
shr    $0x3,%ebx
and    $0x7,%ebx
and    $0x7,%ebp
movb   $0x0,0x11(%rsp)
shr    $0x6,%rax
lea    0xc87(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0xd07(%rip),%rax
movslq (%rax,%rbx,4),%rsi
add    %rax,%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
lea    0x1078(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0x252b(%rip),%rax
mov    (%rax,%rbp,8),%rsi
jmp    14e3 <z80_Disassemble+0x3b3>
lea    0xf24(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%r13,%r15,1),%edx
lea    0xe8b(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
lea    0xe3c(%rip),%rsi
mov    %rbp,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xee4(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%r13,%r15,1),%edx
jmp    1de4 <z80_Disassemble+0xcb4>
lea    0xecf(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xecf(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xf27(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xec1(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xe48(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xe40(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
lea    0xe3c(%rip),%rsi
jmp    134c <z80_Disassemble+0x21c>
and    $0x1f,%eax
lea    0xc95(%rip),%rcx
jmp    1345 <z80_Disassemble+0x215>
lea    0xe4f(%rip),%rsi
jmp    18fd <z80_Disassemble+0x7cd>
lea    0xe4b(%rip),%rsi
jmp    18fd <z80_Disassemble+0x7cd>
lea    0xe47(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%r14
call   1030 <strcpy@plt>
lea    0x30(%rbx),%eax
mov    %al,0x10(%rsp)
lea    0x10(%rsp),%rsi
mov    %r14,%rdi
call   1040 <strcat@plt>
lea    0xf5a(%rip),%rsi
mov    %r14,%rdi
call   1040 <strcat@plt>
movzbl %bpl,%eax
lea    0x240a(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r14,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xd30(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
and    $0x38,%ebp
lea    0x23e5(%rip),%rax
mov    0x0(%rbp,%rax,1),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xec9(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xea0(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r12,%r15,1),%edx
lea    0xd28(%rip),%rsi
lea    0x10(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <sprintf@plt>
mov    %rbx,%rdi
mov    %rbp,%rsi
call   1040 <strcat@plt>
lea    0xdbf(%rip),%rsi
mov    %rbx,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xdb2(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
movzbl %bpl,%eax
jmp    12f1 <z80_Disassemble+0x1c1>
movzbl %bpl,%ebx
test   $0x1,%bpl
lea    0xd9c(%rip),%rax
lea    0xd91(%rip),%rsi
cmove  %rax,%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
lea    0xd83(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
and    $0x6,%ebx
lea    0x2360(%rip),%rax
mov    (%rax,%rbx,4),%rsi
mov    %rbp,%rdi
jmp    14e6 <z80_Disassemble+0x3b6>
movzbl %bpl,%r14d
test   $0x1,%bpl
jne    1e84 <z80_Disassemble+0xd54>
lea    0xd56(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%rbx,%r15,1),%edx
lea    0xc0c(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
lea    0xd0e(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
shr    %r14d
lea    0x22f6(%rip),%rax
mov    (%rax,%r14,8),%rsi
mov    %rbp,%rdi
jmp    1478 <z80_Disassemble+0x348>
movzbl %bpl,%eax
lea    0xa73(%rip),%rcx
jmp    1345 <z80_Disassemble+0x215>
movzbl %bpl,%eax
lea    0xa83(%rip),%rcx
jmp    1345 <z80_Disassemble+0x215>
lea    0xcee(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbx
call   1030 <strcpy@plt>
lea    0x2f(%rbp),%eax
mov    %al,0x10(%rsp)
movb   $0x0,0x11(%rsp)
lea    0x10(%rsp),%rsi
mov    %rbx,%rdi
jmp    1478 <z80_Disassemble+0x348>
movzbl %bpl,%eax
lea    0xa68(%rip),%rcx
jmp    1345 <z80_Disassemble+0x215>
lea    0xd43(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xd40(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xd3d(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xd37(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xd34(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xd31(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xd26(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xd22(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
movzbl 0x2(%r12,%r15,1),%ebp
movzbl %bpl,%eax
shr    $0x3,%ebp
and    $0x7,%ebp
movb   $0x0,0x11(%rsp)
shr    $0x6,%rax
lea    0x8c3(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0xa73(%rip),%rax
movslq (%rax,%rbp,4),%rsi
add    %rax,%rsi
mov    %rbx,%rdi
mov    %rbx,%r14
call   1030 <strcpy@plt>
lea    0xce4(%rip),%rsi
jmp    1f05 <z80_Disassemble+0xdd5>
lea    0xb70(%rip),%rsi
jmp    1cda <z80_Disassemble+0xbaa>
lea    0xcc4(%rip),%rsi
jmp    1cda <z80_Disassemble+0xbaa>
lea    0xcc2(%rip),%rsi
jmp    1cda <z80_Disassemble+0xbaa>
lea    0xcbc(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
jmp    19b3 <z80_Disassemble+0x883>
lea    0xca5(%rip),%rsi
jmp    1cda <z80_Disassemble+0xbaa>
lea    0xc24(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xc0d(%rip),%rsi
mov    %rbx,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xbf9(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xbe7(%rip),%rsi
mov    %rbx,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xa60(%rip),%rsi
mov    %rbx,%rdi
mov    %rbx,%rbp
call   1030 <strcpy@plt>
movzbl 0x1(%r12,%r15,1),%edx
lea    0xa05(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
lea    0xbfd(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
lea    0xd(%rsp),%rsi
mov    %rbp,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xa28(%rip),%rsi
jmp    1cda <z80_Disassemble+0xbaa>
lea    0xb72(%rip),%rsi
mov    %rbx,%rdi
mov    %rbx,%rbp
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rbx
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
lea    0xbb7(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
jmp    1472 <z80_Disassemble+0x342>
lea    0x9e4(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0xb2f(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0xb2b(%rip),%rsi
jmp    1db7 <z80_Disassemble+0xc87>
lea    0x99a(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xb01(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r12,%r15,1),%edx
lea    0x989(%rip),%rbp
lea    0x10(%rsp),%r13
mov    %r13,%rdi
mov    %rbp,%rsi
call   1050 <sprintf@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
call   1040 <strcat@plt>
lea    0xa25(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
movzbl 0x2(%r12,%r15,1),%edx
mov    %r13,%rdi
mov    %rbp,%rsi
call   1050 <sprintf@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
jmp    1478 <z80_Disassemble+0x348>
lea    0xa8a(%rip),%rsi
mov    %rbx,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xa8b(%rip),%rsi
mov    %rbx,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0x8ff(%rip),%rsi
mov    %rbx,%rdi
mov    %rbx,%rbp
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xa55(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r12,%r15,1),%edx
lea    0x8dd(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %rbp,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
lea    0x974(%rip),%rsi
mov    %rbp,%rdi
jmp    1478 <z80_Disassemble+0x348>
lea    0x860(%rip),%rsi
mov    %rbx,%rdi
mov    %rbx,%rbp
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0xa45(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r12,%r15,1),%edx
jmp    13fb <z80_Disassemble+0x2cb>
lea    0x827(%rip),%rsi
mov    %rbx,%rdi
mov    %rbx,%rbp
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0x9e7(%rip),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r12,%r15,1),%edx
jmp    17a5 <z80_Disassemble+0x675>
lea    0x7ee(%rip),%rsi
mov    %rdx,%rdi
mov    %rdx,%rbp
call   1030 <strcpy@plt>
shr    %r14d
lea    0x1ee0(%rip),%rax
mov    (%rax,%r14,8),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
lea    0x9a5(%rip),%rsi
mov    %rbp,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%rbx,%r15,1),%edx
jmp    17a5 <z80_Disassemble+0x675>
lea    0x86d(%rip),%rsi
jmp    1edf <z80_Disassemble+0xdaf>
lea    0x9d4(%rip),%rsi
jmp    1edf <z80_Disassemble+0xdaf>
lea    0x865(%rip),%rsi
mov    %rbx,%rdi
mov    %rbx,%r14
call   1030 <strcpy@plt>
lea    0x30(%rbp),%eax
mov    %al,0x10(%rsp)
lea    0x10(%rsp),%rsi
mov    %rbx,%rdi
call   1040 <strcat@plt>
lea    0x978(%rip),%rsi
mov    %r14,%rdi
call   1040 <strcat@plt>
lea    0x887(%rip),%rsi
mov    %r14,%rdi
call   1040 <strcat@plt>
lea    0xd(%rsp),%rsi
mov    %r14,%rdi
call   1040 <strcat@plt>
lea    0x8fb(%rip),%rsi
mov    %r14,%rdi
call   1040 <strcat@plt>
movzbl 0x1(%r12,%r15,1),%edx
lea    0x783(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <sprintf@plt>
mov    %r14,%rdi
mov    %rbx,%rsi
call   1040 <strcat@plt>
lea    0x81a(%rip),%rsi
mov    %r14,%rdi
jmp    1478 <z80_Disassemble+0x348>

LLVM IR (-O0):
@z80_Disassemble.reg = internal global [8 x i8*] [i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i32 0, i32 0)]
@.str = [2 x i8] c"b\00"
@.str.1 = [2 x i8] c"c\00"
@.str.2 = [2 x i8] c"d\00"
@.str.3 = [2 x i8] c"e\00"
@.str.4 = [2 x i8] c"h\00"
@.str.5 = [2 x i8] c"l\00"
@.str.6 = [5 x i8] c"(hl)\00"
@.str.7 = [2 x i8] c"a\00"
@z80_Disassemble.dreg = internal global [4 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i32 0, i32 0)]
@.str.8 = [3 x i8] c"bc\00"
@.str.9 = [3 x i8] c"de\00"
@.str.10 = [3 x i8] c"hl\00"
@.str.11 = [3 x i8] c"sp\00"
@z80_Disassemble.cond = internal global [8 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i32 0, i32 0)]
@.str.12 = [3 x i8] c"nz\00"
@.str.13 = [2 x i8] c"z\00"
@.str.14 = [3 x i8] c"nc\00"
@.str.15 = [3 x i8] c"po\00"
@.str.16 = [3 x i8] c"pe\00"
@.str.17 = [2 x i8] c"p\00"
@.str.18 = [2 x i8] c"m\00"
@z80_Disassemble.arith = internal global [8 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.20, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.23, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.24, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.25, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i32 0, i32 0)]
@.str.19 = [8 x i8] c"add a, \00"
@.str.20 = [8 x i8] c"adc a, \00"
@.str.21 = [5 x i8] c"sub \00"
@.str.22 = [8 x i8] c"sbc a, \00"
@.str.23 = [5 x i8] c"and \00"
@.str.24 = [5 x i8] c"xor \00"
@.str.25 = [4 x i8] c"or \00"
@.str.26 = [4 x i8] c"cp \00"
@.str.27 = [4 x i8] c"nop\00"
@.str.28 = [10 x i8] c"ex af, af\00"
@.str.29 = [6 x i8] c"djnz \00"
@.str.30 = [8 x i8] c"0x%4.4x\00"
@.str.31 = [4 x i8] c"jr \00"
@.str.32 = [3 x i8] c", \00"
@.str.33 = [8 x i8] c"add hl,\00"
@.str.34 = [4 x i8] c"ld \00"
@.str.35 = [10 x i8] c"ld (bc),a\00"
@.str.36 = [11 x i8] c"ld a, (bc)\00"
@.str.37 = [11 x i8] c"ld (de), a\00"
@.str.38 = [11 x i8] c"ld a, (de)\00"
@.str.39 = [5 x i8] c"ld (\00"
@.str.40 = [6 x i8] c"), hl\00"
@.str.41 = [9 x i8] c"ld hl, (\00"
@.str.42 = [2 x i8] c")\00"
@.str.43 = [5 x i8] c"), a\00"
@.str.44 = [8 x i8] c"ld a, (\00"
@.str.45 = [5 x i8] c"dec \00"
@.str.46 = [5 x i8] c"inc \00"
@.str.47 = [8 x i8] c"0x%2.2x\00"
@z80_Disassemble.str = internal global [8 x i8*] [i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.48, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.49, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.50, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.51, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.52, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.53, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.54, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.55, i32 0, i32 0)]
@.str.48 = [5 x i8] c"rlca\00"
@.str.49 = [5 x i8] c"rrca\00"
@.str.50 = [4 x i8] c"rla\00"
@.str.51 = [4 x i8] c"rra\00"
@.str.52 = [4 x i8] c"daa\00"
@.str.53 = [4 x i8] c"cpl\00"
@.str.54 = [4 x i8] c"scf\00"
@.str.55 = [4 x i8] c"ccf\00"
@.str.56 = [5 x i8] c"halt\00"
@.str.57 = [5 x i8] c"ret \00"
@.str.58 = [4 x i8] c"ret\00"
@.str.59 = [4 x i8] c"exx\00"
@.str.60 = [8 x i8] c"jp (hl)\00"
@.str.61 = [10 x i8] c"ld sp, hl\00"
@.str.62 = [5 x i8] c"pop \00"
@.str.63 = [3 x i8] c"af\00"
@.str.64 = [4 x i8] c"jp \00"
@z80_Disassemble.str.65 = internal global [8 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.66, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.67, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.68, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.69, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.70, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.71, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.73, i32 0, i32 0)]
@.str.66 = [4 x i8] c"rlc\00"
@.str.67 = [4 x i8] c"rrc\00"
@.str.68 = [3 x i8] c"rl\00"
@.str.69 = [3 x i8] c"rr\00"
@.str.70 = [4 x i8] c"sla\00"
@.str.71 = [4 x i8] c"sra\00"
@.str.72 = [4 x i8] c"???\00"
@.str.73 = [4 x i8] c"srl\00"
@.str.74 = [2 x i8] c" \00"
@.str.75 = [5 x i8] c"bit \00"
@.str.76 = [5 x i8] c"res \00"
@.str.77 = [5 x i8] c"set \00"
@.str.78 = [6 x i8] c"out (\00"
@.str.79 = [8 x i8] c"in a, (\00"
@.str.80 = [12 x i8] c"ex (sp), hl\00"
@.str.81 = [10 x i8] c"ex de, hl\00"
@.str.82 = [3 x i8] c"di\00"
@.str.83 = [3 x i8] c"ei\00"
@.str.84 = [6 x i8] c"call \00"
@.str.85 = [4 x i8] c"in \00"
@.str.86 = [6 x i8] c", (c)\00"
@.str.87 = [9 x i8] c"out (c),\00"
@.str.88 = [4 x i8] c"adc\00"
@.str.89 = [4 x i8] c"sbc\00"
@.str.90 = [6 x i8] c" hl, \00"
@.str.91 = [4 x i8] c", (\00"
@.str.92 = [6 x i8] c"LD\09\09(\00"
@.str.93 = [3 x i8] c"),\00"
@z80_Disassemble.str.94 = internal global [8 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.95, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0)]
@.str.95 = [4 x i8] c"neg\00"
@z80_Disassemble.str.96 = internal global [8 x i8*] [i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.97, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.98, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0)]
@.str.97 = [5 x i8] c"retn\00"
@.str.98 = [5 x i8] c"reti\00"
@.str.99 = [4 x i8] c"im \00"
@z80_Disassemble.str.100 = internal global [8 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.101, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.102, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.103, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.104, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0)]
@.str.101 = [8 x i8] c"ld i, a\00"
@.str.102 = [7 x i8] c"ld a,i\00"
@.str.103 = [4 x i8] c"rrd\00"
@.str.104 = [4 x i8] c"rld\00"
@z80_Disassemble.str.105 = internal global [32 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.106, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.107, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.108, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.109, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.110, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.111, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.112, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.113, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.114, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.115, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.116, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.117, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.118, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.119, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.120, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.121, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0)]
@.str.106 = [4 x i8] c"ldi\00"
@.str.107 = [4 x i8] c"cpi\00"
@.str.108 = [4 x i8] c"ini\00"
@.str.109 = [5 x i8] c"outi\00"
@.str.110 = [4 x i8] c"ldd\00"
@.str.111 = [4 x i8] c"cpd\00"
@.str.112 = [4 x i8] c"ind\00"
@.str.113 = [5 x i8] c"outd\00"
@.str.114 = [5 x i8] c"ldir\00"
@.str.115 = [5 x i8] c"cpir\00"
@.str.116 = [5 x i8] c"inir\00"
@.str.117 = [5 x i8] c"otir\00"
@.str.118 = [5 x i8] c"lddr\00"
@.str.119 = [5 x i8] c"cpdr\00"
@.str.120 = [5 x i8] c"indr\00"
@.str.121 = [5 x i8] c"otdr\00"
@.str.122 = [3 x i8] c"iy\00"
@.str.123 = [3 x i8] c"ix\00"
@.str.124 = [5 x i8] c"add \00"
@.str.125 = [5 x i8] c", bc\00"
@.str.126 = [5 x i8] c", de\00"
@.str.127 = [4 x i8] c"), \00"
@.str.128 = [6 x i8] c"inc (\00"
@.str.129 = [2 x i8] c"+\00"
@.str.130 = [6 x i8] c"dec (\00"
@.str.131 = [5 x i8] c", sp\00"
@.str.132 = [3 x i8] c",(\00"
@.str.133 = [9 x i8] c"add a, (\00"
@.str.134 = [9 x i8] c"adc a, (\00"
@.str.135 = [6 x i8] c"sub (\00"
@.str.136 = [9 x i8] c"sbc a, (\00"
@.str.137 = [9 x i8] c"and a, (\00"
@.str.138 = [9 x i8] c"xor a, (\00"
@.str.139 = [8 x i8] c"or a, (\00"
@.str.140 = [8 x i8] c"cp a, (\00"
@.str.141 = [10 x i8] c"ex (sp), \00"
@.str.142 = [6 x i8] c"push \00"
@.str.143 = [5 x i8] c"jp (\00"
@.str.144 = [8 x i8] c"ld sp, \00"
@z80_Disassemble.str.145 = internal global [8 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.146, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.147, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.148, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.149, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.150, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.151, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.72, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.152, i32 0, i32 0)]
@.str.146 = [4 x i8] c"RLC\00"
@.str.147 = [4 x i8] c"RRC\00"
@.str.148 = [3 x i8] c"RL\00"
@.str.149 = [3 x i8] c"RR\00"
@.str.150 = [4 x i8] c"SLA\00"
@.str.151 = [4 x i8] c"SRA\00"
@.str.152 = [4 x i8] c"SRL\00"
@.str.153 = [4 x i8] c"res\00"
@.str.154 = [2 x i8] c"(\00"
@.str.155 = [5 x i8] c"rst \00"
define void @z80_Disassemble(i8* %0, i16 zeroext %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i16
%6 = alloca i8*
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8
%10 = alloca [80 x i8]
%11 = alloca [3 x i8]
store i8* %0, i8** %4
store i16 %1, i16* %5
store i8* %2, i8** %6
%12 = load i8*, i8** %4
%13 = load i16, i16* %5
%14 = zext i16 %13 to i64
%15 = getelementptr inbounds i8, i8* %12, i64 %14
%16 = load i8, i8* %15
store i8 %16, i8* %7
%17 = load i8, i8* %7
%18 = zext i8 %17 to i32
%19 = ashr i32 %18, 3
%20 = and i32 %19, 7
%21 = trunc i32 %20 to i8
store i8 %21, i8* %8
%22 = load i8, i8* %7
%23 = zext i8 %22 to i32
%24 = and i32 %23, 7
%25 = trunc i32 %24 to i8
store i8 %25, i8* %9
%26 = load i8, i8* %7
%27 = zext i8 %26 to i32
%28 = and i32 %27, 192
switch i32 %28, label %1607 [
i32 0, label %29
i32 64, label %370
i32 128, label %397
i32 192, label %410
]
29: ; preds = %3
%30 = load i8, i8* %9
%31 = zext i8 %30 to i32
switch i32 %31, label %369 [
i32 0, label %32
i32 1, label %115
i32 2, label %169
i32 3, label %301
i32 4, label %321
i32 5, label %330
i32 6, label %339
i32 7, label %362
]
32: ; preds = %29
%33 = load i8, i8* %8
%34 = zext i8 %33 to i32
switch i32 %34, label %83 [
i32 0, label %35
i32 1, label %38
i32 2, label %41
i32 3, label %62
]
35: ; preds = %32
%36 = load i8*, i8** %6
%37 = call i32 @strcpy(i8* %36, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.27, i64 0, i64 0))
br label %114
38: ; preds = %32
%39 = load i8*, i8** %6
%40 = call i32 @strcpy(i8* %39, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.28, i64 0, i64 0))
br label %114
41: ; preds = %32
%42 = load i8*, i8** %6
%43 = call i32 @strcpy(i8* %42, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.29, i64 0, i64 0))
%44 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%45 = load i16, i16* %5
%46 = zext i16 %45 to i32
%47 = add nsw i32 %46, 2
%48 = load i8*, i8** %4
%49 = load i16, i16* %5
%50 = zext i16 %49 to i32
%51 = add nsw i32 %50, 1
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %48, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
%56 = add nsw i32 %47, %55
%57 = trunc i32 %56 to i8
%58 = call i32 @sprintf(i8* %44, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %57)
%59 = load i8*, i8** %6
%60 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%61 = call i32 @strcat(i8* %59, i8* %60)
br label %114
62: ; preds = %32
%63 = load i8*, i8** %6
%64 = call i32 @strcpy(i8* %63, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0))
%65 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%66 = load i16, i16* %5
%67 = zext i16 %66 to i32
%68 = add nsw i32 %67, 2
%69 = load i8*, i8** %4
%70 = load i16, i16* %5
%71 = zext i16 %70 to i32
%72 = add nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i8, i8* %69, i64 %73
%75 = load i8, i8* %74
%76 = sext i8 %75 to i32
%77 = add nsw i32 %68, %76
%78 = trunc i32 %77 to i8
%79 = call i32 @sprintf(i8* %65, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %78)
%80 = load i8*, i8** %6
%81 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%82 = call i32 @strcat(i8* %80, i8* %81)
br label %114
83: ; preds = %32
%84 = load i8*, i8** %6
%85 = call i32 @strcpy(i8* %84, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0))
%86 = load i8*, i8** %6
%87 = load i8, i8* %8
%88 = zext i8 %87 to i32
%89 = and i32 %88, 3
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %90
%92 = load i8*, i8** %91
%93 = call i32 @strcat(i8* %86, i8* %92)
%94 = load i8*, i8** %6
%95 = call i32 @strcat(i8* %94, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%96 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%97 = load i16, i16* %5
%98 = zext i16 %97 to i32
%99 = add nsw i32 %98, 2
%100 = load i8*, i8** %4
%101 = load i16, i16* %5
%102 = zext i16 %101 to i32
%103 = add nsw i32 %102, 1
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %100, i64 %104
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
%108 = add nsw i32 %99, %107
%109 = trunc i32 %108 to i8
%110 = call i32 @sprintf(i8* %96, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %109)
%111 = load i8*, i8** %6
%112 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%113 = call i32 @strcat(i8* %111, i8* %112)
br label %114
114: ; preds = %83, %62, %41, %38, %35
br label %369
115: ; preds = %29
%116 = load i8, i8* %7
%117 = zext i8 %116 to i32
%118 = and i32 %117, 8
%119 = icmp ne i32 %118, 0
br i1 %119, label %120, label %131
120: ; preds = %115
%121 = load i8*, i8** %6
%122 = call i32 @strcpy(i8* %121, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.33, i64 0, i64 0))
%123 = load i8*, i8** %6
%124 = load i8, i8* %8
%125 = zext i8 %124 to i32
%126 = ashr i32 %125, 1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %127
%129 = load i8*, i8** %128
%130 = call i32 @strcat(i8* %123, i8* %129)
br label %168
131: ; preds = %115
%132 = load i8*, i8** %6
%133 = call i32 @strcpy(i8* %132, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%134 = load i8*, i8** %6
%135 = load i8, i8* %8
%136 = zext i8 %135 to i32
%137 = ashr i32 %136, 1
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %138
%140 = load i8*, i8** %139
%141 = call i32 @strcat(i8* %134, i8* %140)
%142 = load i8*, i8** %6
%143 = call i32 @strcat(i8* %142, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%144 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%145 = load i8*, i8** %4
%146 = load i16, i16* %5
%147 = zext i16 %146 to i32
%148 = add nsw i32 %147, 1
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8, i8* %145, i64 %149
%151 = load i8, i8* %150
%152 = zext i8 %151 to i32
%153 = load i8*, i8** %4
%154 = load i16, i16* %5
%155 = zext i16 %154 to i32
%156 = add nsw i32 %155, 2
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %153, i64 %157
%159 = load i8, i8* %158
%160 = zext i8 %159 to i32
%161 = shl i32 %160, 8
%162 = add nsw i32 %152, %161
%163 = trunc i32 %162 to i8
%164 = call i32 @sprintf(i8* %144, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %163)
%165 = load i8*, i8** %6
%166 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%167 = call i32 @strcat(i8* %165, i8* %166)
br label %168
168: ; preds = %131, %120
br label %369
169: ; preds = %29
%170 = load i8, i8* %8
%171 = zext i8 %170 to i32
switch i32 %171, label %300 [
i32 0, label %172
i32 1, label %175
i32 2, label %178
i32 3, label %181
i32 4, label %184
i32 5, label %213
i32 6, label %242
i32 7, label %271
]
172: ; preds = %169
%173 = load i8*, i8** %6
%174 = call i32 @strcpy(i8* %173, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.35, i64 0, i64 0))
br label %300
175: ; preds = %169
%176 = load i8*, i8** %6
%177 = call i32 @strcpy(i8* %176, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.36, i64 0, i64 0))
br label %300
178: ; preds = %169
%179 = load i8*, i8** %6
%180 = call i32 @strcpy(i8* %179, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0))
br label %300
181: ; preds = %169
%182 = load i8*, i8** %6
%183 = call i32 @strcpy(i8* %182, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.38, i64 0, i64 0))
br label %300
184: ; preds = %169
%185 = load i8*, i8** %6
%186 = call i32 @strcpy(i8* %185, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%187 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%188 = load i8*, i8** %4
%189 = load i16, i16* %5
%190 = zext i16 %189 to i32
%191 = add nsw i32 %190, 1
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds i8, i8* %188, i64 %192
%194 = load i8, i8* %193
%195 = zext i8 %194 to i32
%196 = load i8*, i8** %4
%197 = load i16, i16* %5
%198 = zext i16 %197 to i32
%199 = add nsw i32 %198, 2
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i8, i8* %196, i64 %200
%202 = load i8, i8* %201
%203 = zext i8 %202 to i32
%204 = shl i32 %203, 8
%205 = add nsw i32 %195, %204
%206 = trunc i32 %205 to i8
%207 = call i32 @sprintf(i8* %187, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %206)
%208 = load i8*, i8** %6
%209 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%210 = call i32 @strcat(i8* %208, i8* %209)
%211 = load i8*, i8** %6
%212 = call i32 @strcat(i8* %211, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.40, i64 0, i64 0))
br label %300
213: ; preds = %169
%214 = load i8*, i8** %6
%215 = call i32 @strcpy(i8* %214, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.41, i64 0, i64 0))
%216 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%217 = load i8*, i8** %4
%218 = load i16, i16* %5
%219 = zext i16 %218 to i32
%220 = add nsw i32 %219, 1
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds i8, i8* %217, i64 %221
%223 = load i8, i8* %222
%224 = zext i8 %223 to i32
%225 = load i8*, i8** %4
%226 = load i16, i16* %5
%227 = zext i16 %226 to i32
%228 = add nsw i32 %227, 2
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i8, i8* %225, i64 %229
%231 = load i8, i8* %230
%232 = zext i8 %231 to i32
%233 = shl i32 %232, 8
%234 = add nsw i32 %224, %233
%235 = trunc i32 %234 to i8
%236 = call i32 @sprintf(i8* %216, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %235)
%237 = load i8*, i8** %6
%238 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%239 = call i32 @strcat(i8* %237, i8* %238)
%240 = load i8*, i8** %6
%241 = call i32 @strcat(i8* %240, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %300
242: ; preds = %169
%243 = load i8*, i8** %6
%244 = call i32 @strcpy(i8* %243, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%245 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%246 = load i8*, i8** %4
%247 = load i16, i16* %5
%248 = zext i16 %247 to i32
%249 = add nsw i32 %248, 1
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i8, i8* %246, i64 %250
%252 = load i8, i8* %251
%253 = zext i8 %252 to i32
%254 = load i8*, i8** %4
%255 = load i16, i16* %5
%256 = zext i16 %255 to i32
%257 = add nsw i32 %256, 2
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %254, i64 %258
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = shl i32 %261, 8
%263 = add nsw i32 %253, %262
%264 = trunc i32 %263 to i8
%265 = call i32 @sprintf(i8* %245, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %264)
%266 = load i8*, i8** %6
%267 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%268 = call i32 @strcat(i8* %266, i8* %267)
%269 = load i8*, i8** %6
%270 = call i32 @strcat(i8* %269, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.43, i64 0, i64 0))
br label %300
271: ; preds = %169
%272 = load i8*, i8** %6
%273 = call i32 @strcpy(i8* %272, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.44, i64 0, i64 0))
%274 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%275 = load i8*, i8** %4
%276 = load i16, i16* %5
%277 = zext i16 %276 to i32
%278 = add nsw i32 %277, 1
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds i8, i8* %275, i64 %279
%281 = load i8, i8* %280
%282 = zext i8 %281 to i32
%283 = load i8*, i8** %4
%284 = load i16, i16* %5
%285 = zext i16 %284 to i32
%286 = add nsw i32 %285, 2
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds i8, i8* %283, i64 %287
%289 = load i8, i8* %288
%290 = zext i8 %289 to i32
%291 = shl i32 %290, 8
%292 = add nsw i32 %282, %291
%293 = trunc i32 %292 to i8
%294 = call i32 @sprintf(i8* %274, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %293)
%295 = load i8*, i8** %6
%296 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%297 = call i32 @strcat(i8* %295, i8* %296)
%298 = load i8*, i8** %6
%299 = call i32 @strcat(i8* %298, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %300
300: ; preds = %169, %271, %242, %213, %184, %181, %178, %175, %172
br label %369
301: ; preds = %29
%302 = load i8, i8* %7
%303 = zext i8 %302 to i32
%304 = and i32 %303, 8
%305 = icmp ne i32 %304, 0
br i1 %305, label %306, label %309
306: ; preds = %301
%307 = load i8*, i8** %6
%308 = call i32 @strcpy(i8* %307, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.45, i64 0, i64 0))
br label %312
309: ; preds = %301
%310 = load i8*, i8** %6
%311 = call i32 @strcpy(i8* %310, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0))
br label %312
312: ; preds = %309, %306
%313 = load i8*, i8** %6
%314 = load i8, i8* %8
%315 = zext i8 %314 to i32
%316 = ashr i32 %315, 1
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %317
%319 = load i8*, i8** %318
%320 = call i32 @strcat(i8* %313, i8* %319)
br label %369
321: ; preds = %29
%322 = load i8*, i8** %6
%323 = call i32 @strcpy(i8* %322, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0))
%324 = load i8*, i8** %6
%325 = load i8, i8* %8
%326 = zext i8 %325 to i64
%327 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %326
%328 = load i8*, i8** %327
%329 = call i32 @strcat(i8* %324, i8* %328)
br label %369
330: ; preds = %29
%331 = load i8*, i8** %6
%332 = call i32 @strcpy(i8* %331, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.45, i64 0, i64 0))
%333 = load i8*, i8** %6
%334 = load i8, i8* %8
%335 = zext i8 %334 to i64
%336 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %335
%337 = load i8*, i8** %336
%338 = call i32 @strcat(i8* %333, i8* %337)
br label %369
339: ; preds = %29
%340 = load i8*, i8** %6
%341 = call i32 @strcpy(i8* %340, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%342 = load i8*, i8** %6
%343 = load i8, i8* %8
%344 = zext i8 %343 to i64
%345 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %344
%346 = load i8*, i8** %345
%347 = call i32 @strcat(i8* %342, i8* %346)
%348 = load i8*, i8** %6
%349 = call i32 @strcat(i8* %348, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%350 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%351 = load i8*, i8** %4
%352 = load i16, i16* %5
%353 = zext i16 %352 to i32
%354 = add nsw i32 %353, 1
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds i8, i8* %351, i64 %355
%357 = load i8, i8* %356
%358 = call i32 @sprintf(i8* %350, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %357)
%359 = load i8*, i8** %6
%360 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%361 = call i32 @strcat(i8* %359, i8* %360)
br label %369
362: ; preds = %29
%363 = load i8*, i8** %6
%364 = load i8, i8* %8
%365 = zext i8 %364 to i64
%366 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.str, i64 0, i64 %365
%367 = load i8*, i8** %366
%368 = call i32 @strcpy(i8* %363, i8* %367)
br label %369
369: ; preds = %29, %362, %339, %330, %321, %312, %300, %168, %114
br label %1607
370: ; preds = %3
%371 = load i8, i8* %8
%372 = zext i8 %371 to i32
%373 = load i8, i8* %9
%374 = zext i8 %373 to i32
%375 = icmp eq i32 %372, %374
br i1 %375, label %376, label %379
376: ; preds = %370
%377 = load i8*, i8** %6
%378 = call i32 @strcpy(i8* %377, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.56, i64 0, i64 0))
br label %396
379: ; preds = %370
%380 = load i8*, i8** %6
%381 = call i32 @strcpy(i8* %380, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%382 = load i8*, i8** %6
%383 = load i8, i8* %8
%384 = zext i8 %383 to i64
%385 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %384
%386 = load i8*, i8** %385
%387 = call i32 @strcat(i8* %382, i8* %386)
%388 = load i8*, i8** %6
%389 = call i32 @strcat(i8* %388, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%390 = load i8*, i8** %6
%391 = load i8, i8* %9
%392 = zext i8 %391 to i64
%393 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %392
%394 = load i8*, i8** %393
%395 = call i32 @strcat(i8* %390, i8* %394)
br label %396
396: ; preds = %379, %376
br label %1607
397: ; preds = %3
%398 = load i8*, i8** %6
%399 = load i8, i8* %8
%400 = zext i8 %399 to i64
%401 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.arith, i64 0, i64 %400
%402 = load i8*, i8** %401
%403 = call i32 @strcpy(i8* %398, i8* %402)
%404 = load i8*, i8** %6
%405 = load i8, i8* %9
%406 = zext i8 %405 to i64
%407 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %406
%408 = load i8*, i8** %407
%409 = call i32 @strcat(i8* %404, i8* %408)
br label %1607
410: ; preds = %3
%411 = load i8, i8* %9
%412 = zext i8 %411 to i32
switch i32 %412, label %1606 [
i32 0, label %413
i32 1, label %422
i32 2, label %465
i32 3, label %500
i32 4, label %670
i32 5, label %705
i32 6, label %1575
i32 7, label %1594
]
413: ; preds = %410
%414 = load i8*, i8** %6
%415 = call i32 @strcpy(i8* %414, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.57, i64 0, i64 0))
%416 = load i8*, i8** %6
%417 = load i8, i8* %8
%418 = zext i8 %417 to i64
%419 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %418
%420 = load i8*, i8** %419
%421 = call i32 @strcat(i8* %416, i8* %420)
br label %1606
422: ; preds = %410
%423 = load i8, i8* %8
%424 = zext i8 %423 to i32
%425 = and i32 %424, 1
%426 = icmp ne i32 %425, 0
br i1 %426, label %427, label %444
427: ; preds = %422
%428 = load i8, i8* %8
%429 = zext i8 %428 to i32
%430 = ashr i32 %429, 1
switch i32 %430, label %443 [
i32 0, label %431
i32 1, label %434
i32 2, label %437
i32 3, label %440
]
431: ; preds = %427
%432 = load i8*, i8** %6
%433 = call i32 @strcpy(i8* %432, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.58, i64 0, i64 0))
br label %443
434: ; preds = %427
%435 = load i8*, i8** %6
%436 = call i32 @strcpy(i8* %435, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.59, i64 0, i64 0))
br label %443
437: ; preds = %427
%438 = load i8*, i8** %6
%439 = call i32 @strcpy(i8* %438, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.60, i64 0, i64 0))
br label %443
440: ; preds = %427
%441 = load i8*, i8** %6
%442 = call i32 @strcpy(i8* %441, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.61, i64 0, i64 0))
br label %443
443: ; preds = %427, %440, %437, %434, %431
br label %464
444: ; preds = %422
%445 = load i8*, i8** %6
%446 = call i32 @strcpy(i8* %445, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.62, i64 0, i64 0))
%447 = load i8, i8* %8
%448 = zext i8 %447 to i32
%449 = ashr i32 %448, 1
%450 = icmp eq i32 %449, 3
br i1 %450, label %451, label %454
451: ; preds = %444
%452 = load i8*, i8** %6
%453 = call i32 @strcat(i8* %452, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.63, i64 0, i64 0))
br label %463
454: ; preds = %444
%455 = load i8*, i8** %6
%456 = load i8, i8* %8
%457 = zext i8 %456 to i32
%458 = ashr i32 %457, 1
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %459
%461 = load i8*, i8** %460
%462 = call i32 @strcat(i8* %455, i8* %461)
br label %463
463: ; preds = %454, %451
br label %464
464: ; preds = %463, %443
br label %1606
465: ; preds = %410
%466 = load i8*, i8** %6
%467 = call i32 @strcpy(i8* %466, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.64, i64 0, i64 0))
%468 = load i8*, i8** %6
%469 = load i8, i8* %8
%470 = zext i8 %469 to i64
%471 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %470
%472 = load i8*, i8** %471
%473 = call i32 @strcat(i8* %468, i8* %472)
%474 = load i8*, i8** %6
%475 = call i32 @strcat(i8* %474, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%476 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%477 = load i8*, i8** %4
%478 = load i16, i16* %5
%479 = zext i16 %478 to i32
%480 = add nsw i32 %479, 1
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i8, i8* %477, i64 %481
%483 = load i8, i8* %482
%484 = zext i8 %483 to i32
%485 = load i8*, i8** %4
%486 = load i16, i16* %5
%487 = zext i16 %486 to i32
%488 = add nsw i32 %487, 2
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i8, i8* %485, i64 %489
%491 = load i8, i8* %490
%492 = zext i8 %491 to i32
%493 = shl i32 %492, 8
%494 = add nsw i32 %484, %493
%495 = trunc i32 %494 to i8
%496 = call i32 @sprintf(i8* %476, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %495)
%497 = load i8*, i8** %6
%498 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%499 = call i32 @strcat(i8* %497, i8* %498)
br label %1606
500: ; preds = %410
%501 = load i8, i8* %8
%502 = zext i8 %501 to i32
switch i32 %502, label %669 [
i32 0, label %503
i32 1, label %530
i32 2, label %623
i32 3, label %640
i32 4, label %657
i32 5, label %660
i32 6, label %663
i32 7, label %666
]
503: ; preds = %500
%504 = load i8*, i8** %6
%505 = call i32 @strcpy(i8* %504, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.64, i64 0, i64 0))
%506 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%507 = load i8*, i8** %4
%508 = load i16, i16* %5
%509 = zext i16 %508 to i32
%510 = add nsw i32 %509, 1
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds i8, i8* %507, i64 %511
%513 = load i8, i8* %512
%514 = zext i8 %513 to i32
%515 = load i8*, i8** %4
%516 = load i16, i16* %5
%517 = zext i16 %516 to i32
%518 = add nsw i32 %517, 2
%519 = sext i32 %518 to i64
%520 = getelementptr inbounds i8, i8* %515, i64 %519
%521 = load i8, i8* %520
%522 = zext i8 %521 to i32
%523 = shl i32 %522, 8
%524 = add nsw i32 %514, %523
%525 = trunc i32 %524 to i8
%526 = call i32 @sprintf(i8* %506, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %525)
%527 = load i8*, i8** %6
%528 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%529 = call i32 @strcat(i8* %527, i8* %528)
br label %669
530: ; preds = %500
%531 = load i8*, i8** %4
%532 = load i16, i16* %5
%533 = add i16 %532, 1
store i16 %533, i16* %5
%534 = zext i16 %533 to i64
%535 = getelementptr inbounds i8, i8* %531, i64 %534
%536 = load i8, i8* %535
store i8 %536, i8* %7
%537 = load i8, i8* %7
%538 = zext i8 %537 to i32
%539 = ashr i32 %538, 3
%540 = and i32 %539, 7
%541 = trunc i32 %540 to i8
store i8 %541, i8* %8
%542 = load i8, i8* %7
%543 = zext i8 %542 to i32
%544 = and i32 %543, 7
%545 = trunc i32 %544 to i8
store i8 %545, i8* %9
%546 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 1
store i8 0, i8* %546
%547 = load i8, i8* %7
%548 = zext i8 %547 to i32
%549 = and i32 %548, 192
switch i32 %549, label %622 [
i32 0, label %550
i32 64, label %565
i32 128, label %584
i32 192, label %603
]
550: ; preds = %530
%551 = load i8*, i8** %6
%552 = load i8, i8* %8
%553 = zext i8 %552 to i64
%554 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.str.65, i64 0, i64 %553
%555 = load i8*, i8** %554
%556 = call i32 @strcpy(i8* %551, i8* %555)
%557 = load i8*, i8** %6
%558 = call i32 @strcat(i8* %557, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.74, i64 0, i64 0))
%559 = load i8*, i8** %6
%560 = load i8, i8* %9
%561 = zext i8 %560 to i64
%562 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %561
%563 = load i8*, i8** %562
%564 = call i32 @strcat(i8* %559, i8* %563)
br label %622
565: ; preds = %530
%566 = load i8*, i8** %6
%567 = call i32 @strcpy(i8* %566, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.75, i64 0, i64 0))
%568 = load i8, i8* %8
%569 = zext i8 %568 to i32
%570 = add nsw i32 %569, 48
%571 = trunc i32 %570 to i8
%572 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
store i8 %571, i8* %572
%573 = load i8*, i8** %6
%574 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%575 = call i32 @strcat(i8* %573, i8* %574)
%576 = load i8*, i8** %6
%577 = call i32 @strcat(i8* %576, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%578 = load i8*, i8** %6
%579 = load i8, i8* %9
%580 = zext i8 %579 to i64
%581 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %580
%582 = load i8*, i8** %581
%583 = call i32 @strcat(i8* %578, i8* %582)
br label %622
584: ; preds = %530
%585 = load i8*, i8** %6
%586 = call i32 @strcpy(i8* %585, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.76, i64 0, i64 0))
%587 = load i8, i8* %8
%588 = zext i8 %587 to i32
%589 = add nsw i32 %588, 48
%590 = trunc i32 %589 to i8
%591 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
store i8 %590, i8* %591
%592 = load i8*, i8** %6
%593 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%594 = call i32 @strcat(i8* %592, i8* %593)
%595 = load i8*, i8** %6
%596 = call i32 @strcat(i8* %595, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%597 = load i8*, i8** %6
%598 = load i8, i8* %9
%599 = zext i8 %598 to i64
%600 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %599
%601 = load i8*, i8** %600
%602 = call i32 @strcat(i8* %597, i8* %601)
br label %622
603: ; preds = %530
%604 = load i8*, i8** %6
%605 = call i32 @strcpy(i8* %604, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.77, i64 0, i64 0))
%606 = load i8, i8* %8
%607 = zext i8 %606 to i32
%608 = add nsw i32 %607, 48
%609 = trunc i32 %608 to i8
%610 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
store i8 %609, i8* %610
%611 = load i8*, i8** %6
%612 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%613 = call i32 @strcat(i8* %611, i8* %612)
%614 = load i8*, i8** %6
%615 = call i32 @strcat(i8* %614, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%616 = load i8*, i8** %6
%617 = load i8, i8* %9
%618 = zext i8 %617 to i64
%619 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %618
%620 = load i8*, i8** %619
%621 = call i32 @strcat(i8* %616, i8* %620)
br label %622
622: ; preds = %530, %603, %584, %565, %550
br label %669
623: ; preds = %500
%624 = load i8*, i8** %6
%625 = call i32 @strcpy(i8* %624, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.78, i64 0, i64 0))
%626 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%627 = load i8*, i8** %4
%628 = load i16, i16* %5
%629 = zext i16 %628 to i32
%630 = add nsw i32 %629, 1
%631 = sext i32 %630 to i64
%632 = getelementptr inbounds i8, i8* %627, i64 %631
%633 = load i8, i8* %632
%634 = call i32 @sprintf(i8* %626, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %633)
%635 = load i8*, i8** %6
%636 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%637 = call i32 @strcat(i8* %635, i8* %636)
%638 = load i8*, i8** %6
%639 = call i32 @strcat(i8* %638, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.43, i64 0, i64 0))
br label %669
640: ; preds = %500
%641 = load i8*, i8** %6
%642 = call i32 @strcpy(i8* %641, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.79, i64 0, i64 0))
%643 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%644 = load i8*, i8** %4
%645 = load i16, i16* %5
%646 = zext i16 %645 to i32
%647 = add nsw i32 %646, 1
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds i8, i8* %644, i64 %648
%650 = load i8, i8* %649
%651 = call i32 @sprintf(i8* %643, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %650)
%652 = load i8*, i8** %6
%653 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%654 = call i32 @strcat(i8* %652, i8* %653)
%655 = load i8*, i8** %6
%656 = call i32 @strcat(i8* %655, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %669
657: ; preds = %500
%658 = load i8*, i8** %6
%659 = call i32 @strcpy(i8* %658, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.80, i64 0, i64 0))
br label %669
660: ; preds = %500
%661 = load i8*, i8** %6
%662 = call i32 @strcpy(i8* %661, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.81, i64 0, i64 0))
br label %669
663: ; preds = %500
%664 = load i8*, i8** %6
%665 = call i32 @strcpy(i8* %664, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.82, i64 0, i64 0))
br label %669
666: ; preds = %500
%667 = load i8*, i8** %6
%668 = call i32 @strcpy(i8* %667, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.83, i64 0, i64 0))
br label %669
669: ; preds = %500, %666, %663, %660, %657, %640, %623, %622, %503
br label %1606
670: ; preds = %410
%671 = load i8*, i8** %6
%672 = call i32 @strcpy(i8* %671, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.84, i64 0, i64 0))
%673 = load i8*, i8** %6
%674 = load i8, i8* %8
%675 = zext i8 %674 to i64
%676 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %675
%677 = load i8*, i8** %676
%678 = call i32 @strcat(i8* %673, i8* %677)
%679 = load i8*, i8** %6
%680 = call i32 @strcat(i8* %679, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%681 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%682 = load i8*, i8** %4
%683 = load i16, i16* %5
%684 = zext i16 %683 to i32
%685 = add nsw i32 %684, 1
%686 = sext i32 %685 to i64
%687 = getelementptr inbounds i8, i8* %682, i64 %686
%688 = load i8, i8* %687
%689 = zext i8 %688 to i32
%690 = load i8*, i8** %4
%691 = load i16, i16* %5
%692 = zext i16 %691 to i32
%693 = add nsw i32 %692, 2
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds i8, i8* %690, i64 %694
%696 = load i8, i8* %695
%697 = zext i8 %696 to i32
%698 = shl i32 %697, 8
%699 = add nsw i32 %689, %698
%700 = trunc i32 %699 to i8
%701 = call i32 @sprintf(i8* %681, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %700)
%702 = load i8*, i8** %6
%703 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%704 = call i32 @strcat(i8* %702, i8* %703)
br label %1606
705: ; preds = %410
%706 = load i8, i8* %8
%707 = zext i8 %706 to i32
%708 = and i32 %707, 1
%709 = icmp ne i32 %708, 0
br i1 %709, label %710, label %1554
710: ; preds = %705
%711 = load i8, i8* %8
%712 = zext i8 %711 to i32
%713 = ashr i32 %712, 1
switch i32 %713, label %932 [
i32 0, label %714
i32 2, label %741
]
714: ; preds = %710
%715 = load i8*, i8** %6
%716 = call i32 @strcpy(i8* %715, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.84, i64 0, i64 0))
%717 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%718 = load i8*, i8** %4
%719 = load i16, i16* %5
%720 = zext i16 %719 to i32
%721 = add nsw i32 %720, 1
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds i8, i8* %718, i64 %722
%724 = load i8, i8* %723
%725 = zext i8 %724 to i32
%726 = load i8*, i8** %4
%727 = load i16, i16* %5
%728 = zext i16 %727 to i32
%729 = add nsw i32 %728, 2
%730 = sext i32 %729 to i64
%731 = getelementptr inbounds i8, i8* %726, i64 %730
%732 = load i8, i8* %731
%733 = zext i8 %732 to i32
%734 = shl i32 %733, 8
%735 = add nsw i32 %725, %734
%736 = trunc i32 %735 to i8
%737 = call i32 @sprintf(i8* %717, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %736)
%738 = load i8*, i8** %6
%739 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%740 = call i32 @strcat(i8* %738, i8* %739)
br label %1553
741: ; preds = %710
%742 = load i8*, i8** %4
%743 = load i16, i16* %5
%744 = add i16 %743, 1
store i16 %744, i16* %5
%745 = zext i16 %744 to i64
%746 = getelementptr inbounds i8, i8* %742, i64 %745
%747 = load i8, i8* %746
store i8 %747, i8* %7
%748 = load i8, i8* %7
%749 = zext i8 %748 to i32
%750 = ashr i32 %749, 3
%751 = and i32 %750, 7
%752 = trunc i32 %751 to i8
store i8 %752, i8* %8
%753 = load i8, i8* %7
%754 = zext i8 %753 to i32
%755 = and i32 %754, 7
%756 = trunc i32 %755 to i8
store i8 %756, i8* %9
%757 = load i8, i8* %7
%758 = zext i8 %757 to i32
%759 = and i32 %758, 192
switch i32 %759, label %931 [
i32 64, label %760
i32 128, label %922
]
760: ; preds = %741
%761 = load i8, i8* %9
%762 = zext i8 %761 to i32
switch i32 %762, label %921 [
i32 0, label %763
i32 1, label %774
i32 2, label %783
i32 3, label %805
i32 4, label %887
i32 5, label %894
i32 6, label %901
i32 7, label %914
]
763: ; preds = %760
%764 = load i8*, i8** %6
%765 = call i32 @strcpy(i8* %764, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.85, i64 0, i64 0))
%766 = load i8*, i8** %6
%767 = load i8, i8* %8
%768 = zext i8 %767 to i64
%769 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %768
%770 = load i8*, i8** %769
%771 = call i32 @strcat(i8* %766, i8* %770)
%772 = load i8*, i8** %6
%773 = call i32 @strcat(i8* %772, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.86, i64 0, i64 0))
br label %921
774: ; preds = %760
%775 = load i8*, i8** %6
%776 = call i32 @strcpy(i8* %775, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.87, i64 0, i64 0))
%777 = load i8*, i8** %6
%778 = load i8, i8* %8
%779 = zext i8 %778 to i64
%780 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %779
%781 = load i8*, i8** %780
%782 = call i32 @strcat(i8* %777, i8* %781)
br label %921
783: ; preds = %760
%784 = load i8, i8* %8
%785 = zext i8 %784 to i32
%786 = and i32 %785, 1
%787 = icmp ne i32 %786, 0
br i1 %787, label %788, label %791
788: ; preds = %783
%789 = load i8*, i8** %6
%790 = call i32 @strcpy(i8* %789, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.88, i64 0, i64 0))
br label %794
791: ; preds = %783
%792 = load i8*, i8** %6
%793 = call i32 @strcpy(i8* %792, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.89, i64 0, i64 0))
br label %794
794: ; preds = %791, %788
%795 = load i8*, i8** %6
%796 = call i32 @strcat(i8* %795, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.90, i64 0, i64 0))
%797 = load i8*, i8** %6
%798 = load i8, i8* %8
%799 = zext i8 %798 to i32
%800 = ashr i32 %799, 1
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %801
%803 = load i8*, i8** %802
%804 = call i32 @strcat(i8* %797, i8* %803)
br label %921
805: ; preds = %760
%806 = load i8, i8* %8
%807 = zext i8 %806 to i32
%808 = and i32 %807, 1
%809 = icmp ne i32 %808, 0
br i1 %809, label %810, label %849
810: ; preds = %805
%811 = load i8*, i8** %6
%812 = call i32 @strcpy(i8* %811, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%813 = load i8*, i8** %6
%814 = load i8, i8* %8
%815 = zext i8 %814 to i32
%816 = ashr i32 %815, 1
%817 = sext i32 %816 to i64
%818 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %817
%819 = load i8*, i8** %818
%820 = call i32 @strcat(i8* %813, i8* %819)
%821 = load i8*, i8** %6
%822 = call i32 @strcat(i8* %821, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.91, i64 0, i64 0))
%823 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%824 = load i8*, i8** %4
%825 = load i16, i16* %5
%826 = zext i16 %825 to i32
%827 = add nsw i32 %826, 1
%828 = sext i32 %827 to i64
%829 = getelementptr inbounds i8, i8* %824, i64 %828
%830 = load i8, i8* %829
%831 = zext i8 %830 to i32
%832 = load i8*, i8** %4
%833 = load i16, i16* %5
%834 = zext i16 %833 to i32
%835 = add nsw i32 %834, 2
%836 = sext i32 %835 to i64
%837 = getelementptr inbounds i8, i8* %832, i64 %836
%838 = load i8, i8* %837
%839 = zext i8 %838 to i32
%840 = shl i32 %839, 8
%841 = add nsw i32 %831, %840
%842 = trunc i32 %841 to i8
%843 = call i32 @sprintf(i8* %823, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %842)
%844 = load i8*, i8** %6
%845 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%846 = call i32 @strcat(i8* %844, i8* %845)
%847 = load i8*, i8** %6
%848 = call i32 @strcat(i8* %847, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %886
849: ; preds = %805
%850 = load i8*, i8** %6
%851 = call i32 @strcpy(i8* %850, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.92, i64 0, i64 0))
%852 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%853 = load i8*, i8** %4
%854 = load i16, i16* %5
%855 = zext i16 %854 to i32
%856 = add nsw i32 %855, 1
%857 = sext i32 %856 to i64
%858 = getelementptr inbounds i8, i8* %853, i64 %857
%859 = load i8, i8* %858
%860 = zext i8 %859 to i32
%861 = load i8*, i8** %4
%862 = load i16, i16* %5
%863 = zext i16 %862 to i32
%864 = add nsw i32 %863, 2
%865 = sext i32 %864 to i64
%866 = getelementptr inbounds i8, i8* %861, i64 %865
%867 = load i8, i8* %866
%868 = zext i8 %867 to i32
%869 = shl i32 %868, 8
%870 = add nsw i32 %860, %869
%871 = trunc i32 %870 to i8
%872 = call i32 @sprintf(i8* %852, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %871)
%873 = load i8*, i8** %6
%874 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%875 = call i32 @strcat(i8* %873, i8* %874)
%876 = load i8*, i8** %6
%877 = call i32 @strcat(i8* %876, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0))
%878 = load i8*, i8** %6
%879 = load i8, i8* %8
%880 = zext i8 %879 to i32
%881 = ashr i32 %880, 1
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %882
%884 = load i8*, i8** %883
%885 = call i32 @strcat(i8* %878, i8* %884)
br label %886
886: ; preds = %849, %810
br label %921
887: ; preds = %760
%888 = load i8*, i8** %6
%889 = load i8, i8* %8
%890 = zext i8 %889 to i64
%891 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.str.94, i64 0, i64 %890
%892 = load i8*, i8** %891
%893 = call i32 @strcpy(i8* %888, i8* %892)
br label %921
894: ; preds = %760
%895 = load i8*, i8** %6
%896 = load i8, i8* %8
%897 = zext i8 %896 to i64
%898 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.str.96, i64 0, i64 %897
%899 = load i8*, i8** %898
%900 = call i32 @strcpy(i8* %895, i8* %899)
br label %921
901: ; preds = %760
%902 = load i8*, i8** %6
%903 = call i32 @strcpy(i8* %902, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.99, i64 0, i64 0))
%904 = load i8, i8* %8
%905 = zext i8 %904 to i32
%906 = add nsw i32 %905, 48
%907 = sub nsw i32 %906, 1
%908 = trunc i32 %907 to i8
%909 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
store i8 %908, i8* %909
%910 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 1
store i8 0, i8* %910
%911 = load i8*, i8** %6
%912 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%913 = call i32 @strcat(i8* %911, i8* %912)
br label %921
914: ; preds = %760
%915 = load i8*, i8** %6
%916 = load i8, i8* %8
%917 = zext i8 %916 to i64
%918 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.str.100, i64 0, i64 %917
%919 = load i8*, i8** %918
%920 = call i32 @strcpy(i8* %915, i8* %919)
br label %921
921: ; preds = %760, %914, %901, %894, %887, %886, %794, %774, %763
br label %931
922: ; preds = %741
%923 = load i8*, i8** %6
%924 = load i8, i8* %7
%925 = zext i8 %924 to i32
%926 = and i32 %925, 31
%927 = sext i32 %926 to i64
%928 = getelementptr inbounds [32 x i8*], [32 x i8*]* @z80_Disassemble.str.105, i64 0, i64 %927
%929 = load i8*, i8** %928
%930 = call i32 @strcpy(i8* %923, i8* %929)
br label %931
931: ; preds = %741, %922, %921
br label %1553
932: ; preds = %710
%933 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%934 = load i8, i8* %7
%935 = zext i8 %934 to i32
%936 = and i32 %935, 32
%937 = icmp ne i32 %936, 0
%938 = zext i1 %937 to i64
%939 = select i1 %937, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.122, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.123, i64 0, i64 0)
%940 = call i32 @strcpy(i8* %933, i8* %939)
%941 = load i8*, i8** %4
%942 = load i16, i16* %5
%943 = add i16 %942, 1
store i16 %943, i16* %5
%944 = zext i16 %943 to i64
%945 = getelementptr inbounds i8, i8* %941, i64 %944
%946 = load i8, i8* %945
store i8 %946, i8* %7
%947 = load i8, i8* %7
%948 = zext i8 %947 to i32
switch i32 %948, label %1552 [
i32 9, label %949
i32 25, label %957
i32 33, label %965
i32 34, label %997
i32 35, label %1029
i32 41, label %1035
i32 42, label %1046
i32 43, label %1080
i32 52, label %1086
i32 53, label %1108
i32 54, label %1130
i32 57, label %1164
i32 70, label %1172
i32 78, label %1172
i32 86, label %1172
i32 94, label %1172
i32 102, label %1172
i32 110, label %1172
i32 112, label %1205
i32 113, label %1205
i32 114, label %1205
i32 115, label %1205
i32 116, label %1205
i32 117, label %1205
i32 119, label %1205
i32 126, label %1235
i32 134, label %1257
i32 142, label %1279
i32 150, label %1301
i32 158, label %1323
i32 166, label %1345
i32 174, label %1367
i32 182, label %1389
i32 190, label %1411
i32 225, label %1433
i32 227, label %1439
i32 229, label %1445
i32 233, label %1451
i32 249, label %1459
i32 203, label %1465
]
949: ; preds = %932
%950 = load i8*, i8** %6
%951 = call i32 @strcpy(i8* %950, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%952 = load i8*, i8** %6
%953 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%954 = call i32 @strcat(i8* %952, i8* %953)
%955 = load i8*, i8** %6
%956 = call i32 @strcat(i8* %955, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.125, i64 0, i64 0))
br label %1552
957: ; preds = %932
%958 = load i8*, i8** %6
%959 = call i32 @strcpy(i8* %958, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%960 = load i8*, i8** %6
%961 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%962 = call i32 @strcat(i8* %960, i8* %961)
%963 = load i8*, i8** %6
%964 = call i32 @strcat(i8* %963, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.126, i64 0, i64 0))
br label %1552
965: ; preds = %932
%966 = load i8*, i8** %6
%967 = call i32 @strcpy(i8* %966, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%968 = load i8*, i8** %6
%969 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%970 = call i32 @strcat(i8* %968, i8* %969)
%971 = load i8*, i8** %6
%972 = call i32 @strcat(i8* %971, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%973 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%974 = load i8*, i8** %4
%975 = load i16, i16* %5
%976 = zext i16 %975 to i32
%977 = add nsw i32 %976, 1
%978 = sext i32 %977 to i64
%979 = getelementptr inbounds i8, i8* %974, i64 %978
%980 = load i8, i8* %979
%981 = zext i8 %980 to i32
%982 = load i8*, i8** %4
%983 = load i16, i16* %5
%984 = zext i16 %983 to i32
%985 = add nsw i32 %984, 2
%986 = sext i32 %985 to i64
%987 = getelementptr inbounds i8, i8* %982, i64 %986
%988 = load i8, i8* %987
%989 = zext i8 %988 to i32
%990 = shl i32 %989, 8
%991 = add nsw i32 %981, %990
%992 = trunc i32 %991 to i8
%993 = call i32 @sprintf(i8* %973, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %992)
%994 = load i8*, i8** %6
%995 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%996 = call i32 @strcat(i8* %994, i8* %995)
br label %1552
997: ; preds = %932
%998 = load i8*, i8** %6
%999 = call i32 @strcpy(i8* %998, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%1000 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1001 = load i8*, i8** %4
%1002 = load i16, i16* %5
%1003 = zext i16 %1002 to i32
%1004 = add nsw i32 %1003, 1
%1005 = sext i32 %1004 to i64
%1006 = getelementptr inbounds i8, i8* %1001, i64 %1005
%1007 = load i8, i8* %1006
%1008 = zext i8 %1007 to i32
%1009 = load i8*, i8** %4
%1010 = load i16, i16* %5
%1011 = zext i16 %1010 to i32
%1012 = add nsw i32 %1011, 2
%1013 = sext i32 %1012 to i64
%1014 = getelementptr inbounds i8, i8* %1009, i64 %1013
%1015 = load i8, i8* %1014
%1016 = zext i8 %1015 to i32
%1017 = shl i32 %1016, 8
%1018 = add nsw i32 %1008, %1017
%1019 = trunc i32 %1018 to i8
%1020 = call i32 @sprintf(i8* %1000, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %1019)
%1021 = load i8*, i8** %6
%1022 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1023 = call i32 @strcat(i8* %1021, i8* %1022)
%1024 = load i8*, i8** %6
%1025 = call i32 @strcat(i8* %1024, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.127, i64 0, i64 0))
%1026 = load i8*, i8** %6
%1027 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1028 = call i32 @strcat(i8* %1026, i8* %1027)
br label %1552
1029: ; preds = %932
%1030 = load i8*, i8** %6
%1031 = call i32 @strcpy(i8* %1030, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0))
%1032 = load i8*, i8** %6
%1033 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1034 = call i32 @strcat(i8* %1032, i8* %1033)
br label %1552
1035: ; preds = %932
%1036 = load i8*, i8** %6
%1037 = call i32 @strcpy(i8* %1036, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%1038 = load i8*, i8** %6
%1039 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1040 = call i32 @strcat(i8* %1038, i8* %1039)
%1041 = load i8*, i8** %6
%1042 = call i32 @strcat(i8* %1041, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%1043 = load i8*, i8** %6
%1044 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1045 = call i32 @strcat(i8* %1043, i8* %1044)
br label %1552
1046: ; preds = %932
%1047 = load i8*, i8** %6
%1048 = call i32 @strcpy(i8* %1047, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%1049 = load i8*, i8** %6
%1050 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1051 = call i32 @strcat(i8* %1049, i8* %1050)
%1052 = load i8*, i8** %6
%1053 = call i32 @strcat(i8* %1052, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.91, i64 0, i64 0))
%1054 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1055 = load i8*, i8** %4
%1056 = load i16, i16* %5
%1057 = zext i16 %1056 to i32
%1058 = add nsw i32 %1057, 1
%1059 = sext i32 %1058 to i64
%1060 = getelementptr inbounds i8, i8* %1055, i64 %1059
%1061 = load i8, i8* %1060
%1062 = zext i8 %1061 to i32
%1063 = load i8*, i8** %4
%1064 = load i16, i16* %5
%1065 = zext i16 %1064 to i32
%1066 = add nsw i32 %1065, 2
%1067 = sext i32 %1066 to i64
%1068 = getelementptr inbounds i8, i8* %1063, i64 %1067
%1069 = load i8, i8* %1068
%1070 = zext i8 %1069 to i32
%1071 = shl i32 %1070, 8
%1072 = add nsw i32 %1062, %1071
%1073 = trunc i32 %1072 to i8
%1074 = call i32 @sprintf(i8* %1054, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %1073)
%1075 = load i8*, i8** %6
%1076 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1077 = call i32 @strcat(i8* %1075, i8* %1076)
%1078 = load i8*, i8** %6
%1079 = call i32 @strcat(i8* %1078, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1080: ; preds = %932
%1081 = load i8*, i8** %6
%1082 = call i32 @strcpy(i8* %1081, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.45, i64 0, i64 0))
%1083 = load i8*, i8** %6
%1084 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1085 = call i32 @strcat(i8* %1083, i8* %1084)
br label %1552
1086: ; preds = %932
%1087 = load i8*, i8** %6
%1088 = call i32 @strcpy(i8* %1087, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.128, i64 0, i64 0))
%1089 = load i8*, i8** %6
%1090 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1091 = call i32 @strcat(i8* %1089, i8* %1090)
%1092 = load i8*, i8** %6
%1093 = call i32 @strcat(i8* %1092, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1094 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1095 = load i8*, i8** %4
%1096 = load i16, i16* %5
%1097 = zext i16 %1096 to i32
%1098 = add nsw i32 %1097, 1
%1099 = sext i32 %1098 to i64
%1100 = getelementptr inbounds i8, i8* %1095, i64 %1099
%1101 = load i8, i8* %1100
%1102 = call i32 @sprintf(i8* %1094, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1101)
%1103 = load i8*, i8** %6
%1104 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1105 = call i32 @strcat(i8* %1103, i8* %1104)
%1106 = load i8*, i8** %6
%1107 = call i32 @strcat(i8* %1106, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1108: ; preds = %932
%1109 = load i8*, i8** %6
%1110 = call i32 @strcpy(i8* %1109, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.130, i64 0, i64 0))
%1111 = load i8*, i8** %6
%1112 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1113 = call i32 @strcat(i8* %1111, i8* %1112)
%1114 = load i8*, i8** %6
%1115 = call i32 @strcat(i8* %1114, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1116 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1117 = load i8*, i8** %4
%1118 = load i16, i16* %5
%1119 = zext i16 %1118 to i32
%1120 = add nsw i32 %1119, 1
%1121 = sext i32 %1120 to i64
%1122 = getelementptr inbounds i8, i8* %1117, i64 %1121
%1123 = load i8, i8* %1122
%1124 = call i32 @sprintf(i8* %1116, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1123)
%1125 = load i8*, i8** %6
%1126 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1127 = call i32 @strcat(i8* %1125, i8* %1126)
%1128 = load i8*, i8** %6
%1129 = call i32 @strcat(i8* %1128, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1130: ; preds = %932
%1131 = load i8*, i8** %6
%1132 = call i32 @strcpy(i8* %1131, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%1133 = load i8*, i8** %6
%1134 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1135 = call i32 @strcat(i8* %1133, i8* %1134)
%1136 = load i8*, i8** %6
%1137 = call i32 @strcat(i8* %1136, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1138 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1139 = load i8*, i8** %4
%1140 = load i16, i16* %5
%1141 = zext i16 %1140 to i32
%1142 = add nsw i32 %1141, 1
%1143 = sext i32 %1142 to i64
%1144 = getelementptr inbounds i8, i8* %1139, i64 %1143
%1145 = load i8, i8* %1144
%1146 = call i32 @sprintf(i8* %1138, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1145)
%1147 = load i8*, i8** %6
%1148 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1149 = call i32 @strcat(i8* %1147, i8* %1148)
%1150 = load i8*, i8** %6
%1151 = call i32 @strcat(i8* %1150, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0))
%1152 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1153 = load i8*, i8** %4
%1154 = load i16, i16* %5
%1155 = zext i16 %1154 to i32
%1156 = add nsw i32 %1155, 2
%1157 = sext i32 %1156 to i64
%1158 = getelementptr inbounds i8, i8* %1153, i64 %1157
%1159 = load i8, i8* %1158
%1160 = call i32 @sprintf(i8* %1152, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1159)
%1161 = load i8*, i8** %6
%1162 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1163 = call i32 @strcat(i8* %1161, i8* %1162)
br label %1552
1164: ; preds = %932
%1165 = load i8*, i8** %6
%1166 = call i32 @strcpy(i8* %1165, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%1167 = load i8*, i8** %6
%1168 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1169 = call i32 @strcat(i8* %1167, i8* %1168)
%1170 = load i8*, i8** %6
%1171 = call i32 @strcat(i8* %1170, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.131, i64 0, i64 0))
br label %1552
1172: ; preds = %932, %932, %932, %932, %932, %932
%1173 = load i8*, i8** %6
%1174 = call i32 @strcpy(i8* %1173, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%1175 = load i8*, i8** %6
%1176 = load i8, i8* %7
%1177 = zext i8 %1176 to i32
%1178 = ashr i32 %1177, 3
%1179 = and i32 %1178, 7
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %1180
%1182 = load i8*, i8** %1181
%1183 = call i32 @strcat(i8* %1175, i8* %1182)
%1184 = load i8*, i8** %6
%1185 = call i32 @strcat(i8* %1184, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.132, i64 0, i64 0))
%1186 = load i8*, i8** %6
%1187 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1188 = call i32 @strcat(i8* %1186, i8* %1187)
%1189 = load i8*, i8** %6
%1190 = call i32 @strcat(i8* %1189, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1191 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1192 = load i8*, i8** %4
%1193 = load i16, i16* %5
%1194 = zext i16 %1193 to i32
%1195 = add nsw i32 %1194, 1
%1196 = sext i32 %1195 to i64
%1197 = getelementptr inbounds i8, i8* %1192, i64 %1196
%1198 = load i8, i8* %1197
%1199 = call i32 @sprintf(i8* %1191, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1198)
%1200 = load i8*, i8** %6
%1201 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1202 = call i32 @strcat(i8* %1200, i8* %1201)
%1203 = load i8*, i8** %6
%1204 = call i32 @strcat(i8* %1203, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1205: ; preds = %932, %932, %932, %932, %932, %932, %932
%1206 = load i8*, i8** %6
%1207 = call i32 @strcpy(i8* %1206, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%1208 = load i8*, i8** %6
%1209 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1210 = call i32 @strcat(i8* %1208, i8* %1209)
%1211 = load i8*, i8** %6
%1212 = call i32 @strcat(i8* %1211, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1213 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1214 = load i8*, i8** %4
%1215 = load i16, i16* %5
%1216 = zext i16 %1215 to i32
%1217 = add nsw i32 %1216, 1
%1218 = sext i32 %1217 to i64
%1219 = getelementptr inbounds i8, i8* %1214, i64 %1218
%1220 = load i8, i8* %1219
%1221 = call i32 @sprintf(i8* %1213, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1220)
%1222 = load i8*, i8** %6
%1223 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1224 = call i32 @strcat(i8* %1222, i8* %1223)
%1225 = load i8*, i8** %6
%1226 = call i32 @strcat(i8* %1225, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0))
%1227 = load i8*, i8** %6
%1228 = load i8, i8* %7
%1229 = zext i8 %1228 to i32
%1230 = and i32 %1229, 7
%1231 = sext i32 %1230 to i64
%1232 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %1231
%1233 = load i8*, i8** %1232
%1234 = call i32 @strcat(i8* %1227, i8* %1233)
br label %1552
1235: ; preds = %932
%1236 = load i8*, i8** %6
%1237 = call i32 @strcpy(i8* %1236, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.44, i64 0, i64 0))
%1238 = load i8*, i8** %6
%1239 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1240 = call i32 @strcat(i8* %1238, i8* %1239)
%1241 = load i8*, i8** %6
%1242 = call i32 @strcat(i8* %1241, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1243 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1244 = load i8*, i8** %4
%1245 = load i16, i16* %5
%1246 = zext i16 %1245 to i32
%1247 = add nsw i32 %1246, 1
%1248 = sext i32 %1247 to i64
%1249 = getelementptr inbounds i8, i8* %1244, i64 %1248
%1250 = load i8, i8* %1249
%1251 = call i32 @sprintf(i8* %1243, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1250)
%1252 = load i8*, i8** %6
%1253 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1254 = call i32 @strcat(i8* %1252, i8* %1253)
%1255 = load i8*, i8** %6
%1256 = call i32 @strcat(i8* %1255, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1257: ; preds = %932
%1258 = load i8*, i8** %6
%1259 = call i32 @strcpy(i8* %1258, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.133, i64 0, i64 0))
%1260 = load i8*, i8** %6
%1261 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1262 = call i32 @strcat(i8* %1260, i8* %1261)
%1263 = load i8*, i8** %6
%1264 = call i32 @strcat(i8* %1263, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1265 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1266 = load i8*, i8** %4
%1267 = load i16, i16* %5
%1268 = zext i16 %1267 to i32
%1269 = add nsw i32 %1268, 1
%1270 = sext i32 %1269 to i64
%1271 = getelementptr inbounds i8, i8* %1266, i64 %1270
%1272 = load i8, i8* %1271
%1273 = call i32 @sprintf(i8* %1265, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1272)
%1274 = load i8*, i8** %6
%1275 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1276 = call i32 @strcat(i8* %1274, i8* %1275)
%1277 = load i8*, i8** %6
%1278 = call i32 @strcat(i8* %1277, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1279: ; preds = %932
%1280 = load i8*, i8** %6
%1281 = call i32 @strcpy(i8* %1280, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.134, i64 0, i64 0))
%1282 = load i8*, i8** %6
%1283 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1284 = call i32 @strcat(i8* %1282, i8* %1283)
%1285 = load i8*, i8** %6
%1286 = call i32 @strcat(i8* %1285, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1287 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1288 = load i8*, i8** %4
%1289 = load i16, i16* %5
%1290 = zext i16 %1289 to i32
%1291 = add nsw i32 %1290, 1
%1292 = sext i32 %1291 to i64
%1293 = getelementptr inbounds i8, i8* %1288, i64 %1292
%1294 = load i8, i8* %1293
%1295 = call i32 @sprintf(i8* %1287, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1294)
%1296 = load i8*, i8** %6
%1297 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1298 = call i32 @strcat(i8* %1296, i8* %1297)
%1299 = load i8*, i8** %6
%1300 = call i32 @strcat(i8* %1299, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1301: ; preds = %932
%1302 = load i8*, i8** %6
%1303 = call i32 @strcpy(i8* %1302, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.135, i64 0, i64 0))
%1304 = load i8*, i8** %6
%1305 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1306 = call i32 @strcat(i8* %1304, i8* %1305)
%1307 = load i8*, i8** %6
%1308 = call i32 @strcat(i8* %1307, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1309 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1310 = load i8*, i8** %4
%1311 = load i16, i16* %5
%1312 = zext i16 %1311 to i32
%1313 = add nsw i32 %1312, 1
%1314 = sext i32 %1313 to i64
%1315 = getelementptr inbounds i8, i8* %1310, i64 %1314
%1316 = load i8, i8* %1315
%1317 = call i32 @sprintf(i8* %1309, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1316)
%1318 = load i8*, i8** %6
%1319 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1320 = call i32 @strcat(i8* %1318, i8* %1319)
%1321 = load i8*, i8** %6
%1322 = call i32 @strcat(i8* %1321, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1323: ; preds = %932
%1324 = load i8*, i8** %6
%1325 = call i32 @strcpy(i8* %1324, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.136, i64 0, i64 0))
%1326 = load i8*, i8** %6
%1327 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1328 = call i32 @strcat(i8* %1326, i8* %1327)
%1329 = load i8*, i8** %6
%1330 = call i32 @strcat(i8* %1329, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1331 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1332 = load i8*, i8** %4
%1333 = load i16, i16* %5
%1334 = zext i16 %1333 to i32
%1335 = add nsw i32 %1334, 1
%1336 = sext i32 %1335 to i64
%1337 = getelementptr inbounds i8, i8* %1332, i64 %1336
%1338 = load i8, i8* %1337
%1339 = call i32 @sprintf(i8* %1331, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1338)
%1340 = load i8*, i8** %6
%1341 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1342 = call i32 @strcat(i8* %1340, i8* %1341)
%1343 = load i8*, i8** %6
%1344 = call i32 @strcat(i8* %1343, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1345: ; preds = %932
%1346 = load i8*, i8** %6
%1347 = call i32 @strcpy(i8* %1346, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.137, i64 0, i64 0))
%1348 = load i8*, i8** %6
%1349 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1350 = call i32 @strcat(i8* %1348, i8* %1349)
%1351 = load i8*, i8** %6
%1352 = call i32 @strcat(i8* %1351, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1353 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1354 = load i8*, i8** %4
%1355 = load i16, i16* %5
%1356 = zext i16 %1355 to i32
%1357 = add nsw i32 %1356, 1
%1358 = sext i32 %1357 to i64
%1359 = getelementptr inbounds i8, i8* %1354, i64 %1358
%1360 = load i8, i8* %1359
%1361 = call i32 @sprintf(i8* %1353, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1360)
%1362 = load i8*, i8** %6
%1363 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1364 = call i32 @strcat(i8* %1362, i8* %1363)
%1365 = load i8*, i8** %6
%1366 = call i32 @strcat(i8* %1365, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1367: ; preds = %932
%1368 = load i8*, i8** %6
%1369 = call i32 @strcpy(i8* %1368, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.138, i64 0, i64 0))
%1370 = load i8*, i8** %6
%1371 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1372 = call i32 @strcat(i8* %1370, i8* %1371)
%1373 = load i8*, i8** %6
%1374 = call i32 @strcat(i8* %1373, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1375 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1376 = load i8*, i8** %4
%1377 = load i16, i16* %5
%1378 = zext i16 %1377 to i32
%1379 = add nsw i32 %1378, 1
%1380 = sext i32 %1379 to i64
%1381 = getelementptr inbounds i8, i8* %1376, i64 %1380
%1382 = load i8, i8* %1381
%1383 = call i32 @sprintf(i8* %1375, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1382)
%1384 = load i8*, i8** %6
%1385 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1386 = call i32 @strcat(i8* %1384, i8* %1385)
%1387 = load i8*, i8** %6
%1388 = call i32 @strcat(i8* %1387, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1389: ; preds = %932
%1390 = load i8*, i8** %6
%1391 = call i32 @strcpy(i8* %1390, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.139, i64 0, i64 0))
%1392 = load i8*, i8** %6
%1393 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1394 = call i32 @strcat(i8* %1392, i8* %1393)
%1395 = load i8*, i8** %6
%1396 = call i32 @strcat(i8* %1395, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1397 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1398 = load i8*, i8** %4
%1399 = load i16, i16* %5
%1400 = zext i16 %1399 to i32
%1401 = add nsw i32 %1400, 1
%1402 = sext i32 %1401 to i64
%1403 = getelementptr inbounds i8, i8* %1398, i64 %1402
%1404 = load i8, i8* %1403
%1405 = call i32 @sprintf(i8* %1397, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1404)
%1406 = load i8*, i8** %6
%1407 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1408 = call i32 @strcat(i8* %1406, i8* %1407)
%1409 = load i8*, i8** %6
%1410 = call i32 @strcat(i8* %1409, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1411: ; preds = %932
%1412 = load i8*, i8** %6
%1413 = call i32 @strcpy(i8* %1412, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.140, i64 0, i64 0))
%1414 = load i8*, i8** %6
%1415 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1416 = call i32 @strcat(i8* %1414, i8* %1415)
%1417 = load i8*, i8** %6
%1418 = call i32 @strcat(i8* %1417, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1419 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1420 = load i8*, i8** %4
%1421 = load i16, i16* %5
%1422 = zext i16 %1421 to i32
%1423 = add nsw i32 %1422, 1
%1424 = sext i32 %1423 to i64
%1425 = getelementptr inbounds i8, i8* %1420, i64 %1424
%1426 = load i8, i8* %1425
%1427 = call i32 @sprintf(i8* %1419, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1426)
%1428 = load i8*, i8** %6
%1429 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1430 = call i32 @strcat(i8* %1428, i8* %1429)
%1431 = load i8*, i8** %6
%1432 = call i32 @strcat(i8* %1431, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1433: ; preds = %932
%1434 = load i8*, i8** %6
%1435 = call i32 @strcpy(i8* %1434, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.62, i64 0, i64 0))
%1436 = load i8*, i8** %6
%1437 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1438 = call i32 @strcat(i8* %1436, i8* %1437)
br label %1552
1439: ; preds = %932
%1440 = load i8*, i8** %6
%1441 = call i32 @strcpy(i8* %1440, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.141, i64 0, i64 0))
%1442 = load i8*, i8** %6
%1443 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1444 = call i32 @strcat(i8* %1442, i8* %1443)
br label %1552
1445: ; preds = %932
%1446 = load i8*, i8** %6
%1447 = call i32 @strcpy(i8* %1446, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.142, i64 0, i64 0))
%1448 = load i8*, i8** %6
%1449 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1450 = call i32 @strcat(i8* %1448, i8* %1449)
br label %1552
1451: ; preds = %932
%1452 = load i8*, i8** %6
%1453 = call i32 @strcpy(i8* %1452, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.143, i64 0, i64 0))
%1454 = load i8*, i8** %6
%1455 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1456 = call i32 @strcat(i8* %1454, i8* %1455)
%1457 = load i8*, i8** %6
%1458 = call i32 @strcat(i8* %1457, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1459: ; preds = %932
%1460 = load i8*, i8** %6
%1461 = call i32 @strcpy(i8* %1460, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.144, i64 0, i64 0))
%1462 = load i8*, i8** %6
%1463 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1464 = call i32 @strcat(i8* %1462, i8* %1463)
br label %1552
1465: ; preds = %932
%1466 = load i8*, i8** %4
%1467 = load i16, i16* %5
%1468 = zext i16 %1467 to i32
%1469 = add nsw i32 %1468, 2
%1470 = sext i32 %1469 to i64
%1471 = getelementptr inbounds i8, i8* %1466, i64 %1470
%1472 = load i8, i8* %1471
store i8 %1472, i8* %7
%1473 = load i8, i8* %7
%1474 = zext i8 %1473 to i32
%1475 = ashr i32 %1474, 3
%1476 = and i32 %1475, 7
%1477 = trunc i32 %1476 to i8
store i8 %1477, i8* %8
%1478 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 1
store i8 0, i8* %1478
%1479 = load i8, i8* %7
%1480 = zext i8 %1479 to i32
%1481 = and i32 %1480, 192
switch i32 %1481, label %1530 [
i32 0, label %1482
i32 64, label %1491
i32 128, label %1504
i32 192, label %1517
]
1482: ; preds = %1465
%1483 = load i8*, i8** %6
%1484 = load i8, i8* %8
%1485 = zext i8 %1484 to i64
%1486 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.str.145, i64 0, i64 %1485
%1487 = load i8*, i8** %1486
%1488 = call i32 @strcpy(i8* %1483, i8* %1487)
%1489 = load i8*, i8** %6
%1490 = call i32 @strcat(i8* %1489, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.74, i64 0, i64 0))
br label %1530
1491: ; preds = %1465
%1492 = load i8*, i8** %6
%1493 = call i32 @strcpy(i8* %1492, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.75, i64 0, i64 0))
%1494 = load i8, i8* %8
%1495 = zext i8 %1494 to i32
%1496 = add nsw i32 %1495, 48
%1497 = trunc i32 %1496 to i8
%1498 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
store i8 %1497, i8* %1498
%1499 = load i8*, i8** %6
%1500 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1501 = call i32 @strcat(i8* %1499, i8* %1500)
%1502 = load i8*, i8** %6
%1503 = call i32 @strcat(i8* %1502, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
br label %1530
1504: ; preds = %1465
%1505 = load i8*, i8** %6
%1506 = call i32 @strcpy(i8* %1505, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.153, i64 0, i64 0))
%1507 = load i8, i8* %8
%1508 = zext i8 %1507 to i32
%1509 = add nsw i32 %1508, 48
%1510 = trunc i32 %1509 to i8
%1511 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
store i8 %1510, i8* %1511
%1512 = load i8*, i8** %6
%1513 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1514 = call i32 @strcat(i8* %1512, i8* %1513)
%1515 = load i8*, i8** %6
%1516 = call i32 @strcat(i8* %1515, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
br label %1530
1517: ; preds = %1465
%1518 = load i8*, i8** %6
%1519 = call i32 @strcpy(i8* %1518, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.77, i64 0, i64 0))
%1520 = load i8, i8* %8
%1521 = zext i8 %1520 to i32
%1522 = add nsw i32 %1521, 48
%1523 = trunc i32 %1522 to i8
%1524 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
store i8 %1523, i8* %1524
%1525 = load i8*, i8** %6
%1526 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1527 = call i32 @strcat(i8* %1525, i8* %1526)
%1528 = load i8*, i8** %6
%1529 = call i32 @strcat(i8* %1528, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
br label %1530
1530: ; preds = %1465, %1517, %1504, %1491, %1482
%1531 = load i8*, i8** %6
%1532 = call i32 @strcat(i8* %1531, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.154, i64 0, i64 0))
%1533 = load i8*, i8** %6
%1534 = getelementptr inbounds [3 x i8], [3 x i8]* %11, i64 0, i64 0
%1535 = call i32 @strcat(i8* %1533, i8* %1534)
%1536 = load i8*, i8** %6
%1537 = call i32 @strcat(i8* %1536, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%1538 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1539 = load i8*, i8** %4
%1540 = load i16, i16* %5
%1541 = zext i16 %1540 to i32
%1542 = add nsw i32 %1541, 1
%1543 = sext i32 %1542 to i64
%1544 = getelementptr inbounds i8, i8* %1539, i64 %1543
%1545 = load i8, i8* %1544
%1546 = call i32 @sprintf(i8* %1538, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1545)
%1547 = load i8*, i8** %6
%1548 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1549 = call i32 @strcat(i8* %1547, i8* %1548)
%1550 = load i8*, i8** %6
%1551 = call i32 @strcat(i8* %1550, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %1552
1552: ; preds = %932, %1530, %1459, %1451, %1445, %1439, %1433, %1411, %1389, %1367, %1345, %1323, %1301, %1279, %1257, %1235, %1205, %1172, %1164, %1130, %1108, %1086, %1080, %1046, %1035, %1029, %997, %965, %957, %949
br label %1553
1553: ; preds = %1552, %931, %714
br label %1574
1554: ; preds = %705
%1555 = load i8*, i8** %6
%1556 = call i32 @strcpy(i8* %1555, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.142, i64 0, i64 0))
%1557 = load i8, i8* %8
%1558 = zext i8 %1557 to i32
%1559 = ashr i32 %1558, 1
%1560 = icmp eq i32 %1559, 3
br i1 %1560, label %1561, label %1564
1561: ; preds = %1554
%1562 = load i8*, i8** %6
%1563 = call i32 @strcat(i8* %1562, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.63, i64 0, i64 0))
br label %1573
1564: ; preds = %1554
%1565 = load i8*, i8** %6
%1566 = load i8, i8* %8
%1567 = zext i8 %1566 to i32
%1568 = ashr i32 %1567, 1
%1569 = sext i32 %1568 to i64
%1570 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %1569
%1571 = load i8*, i8** %1570
%1572 = call i32 @strcat(i8* %1565, i8* %1571)
br label %1573
1573: ; preds = %1564, %1561
br label %1574
1574: ; preds = %1573, %1553
br label %1606
1575: ; preds = %410
%1576 = load i8*, i8** %6
%1577 = load i8, i8* %8
%1578 = zext i8 %1577 to i64
%1579 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.arith, i64 0, i64 %1578
%1580 = load i8*, i8** %1579
%1581 = call i32 @strcpy(i8* %1576, i8* %1580)
%1582 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1583 = load i8*, i8** %4
%1584 = load i16, i16* %5
%1585 = zext i16 %1584 to i32
%1586 = add nsw i32 %1585, 1
%1587 = sext i32 %1586 to i64
%1588 = getelementptr inbounds i8, i8* %1583, i64 %1587
%1589 = load i8, i8* %1588
%1590 = call i32 @sprintf(i8* %1582, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1589)
%1591 = load i8*, i8** %6
%1592 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1593 = call i32 @strcat(i8* %1591, i8* %1592)
br label %1606
1594: ; preds = %410
%1595 = load i8*, i8** %6
%1596 = call i32 @strcpy(i8* %1595, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.155, i64 0, i64 0))
%1597 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1598 = load i8, i8* %7
%1599 = zext i8 %1598 to i32
%1600 = and i32 %1599, 56
%1601 = trunc i32 %1600 to i8
%1602 = call i32 @sprintf(i8* %1597, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %1601)
%1603 = load i8*, i8** %6
%1604 = getelementptr inbounds [80 x i8], [80 x i8]* %10, i64 0, i64 0
%1605 = call i32 @strcat(i8* %1603, i8* %1604)
br label %1606
1606: ; preds = %410, %1594, %1575, %1574, %670, %669, %465, %464, %413
br label %1607
1607: ; preds = %3, %1606, %397, %396, %369
ret void
}

LLVM IR (-O2):
@z80_Disassemble.reg = internal unnamed_addr constant [8 x i8*] [i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.7, i32 0, i32 0)]
@.str = [2 x i8] c"b\00"
@.str.1 = [2 x i8] c"c\00"
@.str.2 = [2 x i8] c"d\00"
@.str.3 = [2 x i8] c"e\00"
@.str.4 = [2 x i8] c"h\00"
@.str.5 = [2 x i8] c"l\00"
@.str.6 = [5 x i8] c"(hl)\00"
@.str.7 = [2 x i8] c"a\00"
@z80_Disassemble.dreg = internal unnamed_addr constant [4 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.8, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.9, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.10, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.11, i32 0, i32 0)]
@.str.8 = [3 x i8] c"bc\00"
@.str.9 = [3 x i8] c"de\00"
@.str.10 = [3 x i8] c"hl\00"
@.str.11 = [3 x i8] c"sp\00"
@z80_Disassemble.cond = internal unnamed_addr constant [8 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.12, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.13, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.14, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.15, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.16, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.17, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i32 0, i32 0)]
@.str.12 = [3 x i8] c"nz\00"
@.str.13 = [2 x i8] c"z\00"
@.str.14 = [3 x i8] c"nc\00"
@.str.15 = [3 x i8] c"po\00"
@.str.16 = [3 x i8] c"pe\00"
@.str.17 = [2 x i8] c"p\00"
@.str.18 = [2 x i8] c"m\00"
@z80_Disassemble.arith = internal unnamed_addr constant [8 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.20, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.23, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.24, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.25, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i32 0, i32 0)]
@.str.19 = [8 x i8] c"add a, \00"
@.str.20 = [8 x i8] c"adc a, \00"
@.str.21 = [5 x i8] c"sub \00"
@.str.22 = [8 x i8] c"sbc a, \00"
@.str.23 = [5 x i8] c"and \00"
@.str.24 = [5 x i8] c"xor \00"
@.str.25 = [4 x i8] c"or \00"
@.str.26 = [4 x i8] c"cp \00"
@.str.27 = [4 x i8] c"nop\00"
@.str.28 = [10 x i8] c"ex af, af\00"
@.str.29 = [6 x i8] c"djnz \00"
@.str.30 = [8 x i8] c"0x%4.4x\00"
@.str.31 = [4 x i8] c"jr \00"
@.str.32 = [3 x i8] c", \00"
@.str.33 = [8 x i8] c"add hl,\00"
@.str.34 = [4 x i8] c"ld \00"
@.str.35 = [10 x i8] c"ld (bc),a\00"
@.str.36 = [11 x i8] c"ld a, (bc)\00"
@.str.37 = [11 x i8] c"ld (de), a\00"
@.str.38 = [11 x i8] c"ld a, (de)\00"
@.str.39 = [5 x i8] c"ld (\00"
@.str.40 = [6 x i8] c"), hl\00"
@.str.41 = [9 x i8] c"ld hl, (\00"
@.str.42 = [2 x i8] c")\00"
@.str.43 = [5 x i8] c"), a\00"
@.str.44 = [8 x i8] c"ld a, (\00"
@.str.45 = [5 x i8] c"dec \00"
@.str.46 = [5 x i8] c"inc \00"
@.str.47 = [8 x i8] c"0x%2.2x\00"
@reltable.z80_Disassemble = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.48 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.49 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.50 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.51 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.52 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.53 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.54 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.55 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble to i64)) to i32)]
@.str.48 = [5 x i8] c"rlca\00"
@.str.49 = [5 x i8] c"rrca\00"
@.str.50 = [4 x i8] c"rla\00"
@.str.51 = [4 x i8] c"rra\00"
@.str.52 = [4 x i8] c"daa\00"
@.str.53 = [4 x i8] c"cpl\00"
@.str.54 = [4 x i8] c"scf\00"
@.str.55 = [4 x i8] c"ccf\00"
@.str.56 = [5 x i8] c"halt\00"
@.str.57 = [5 x i8] c"ret \00"
@.str.58 = [4 x i8] c"ret\00"
@.str.59 = [4 x i8] c"exx\00"
@.str.60 = [8 x i8] c"jp (hl)\00"
@.str.61 = [10 x i8] c"ld sp, hl\00"
@.str.62 = [5 x i8] c"pop \00"
@.str.63 = [3 x i8] c"af\00"
@.str.64 = [4 x i8] c"jp \00"
@reltable.z80_Disassemble.156 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.66 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.67 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.68 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.69 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.70 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.71 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.73 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.156 to i64)) to i32)]
@.str.66 = [4 x i8] c"rlc\00"
@.str.67 = [4 x i8] c"rrc\00"
@.str.68 = [3 x i8] c"rl\00"
@.str.69 = [3 x i8] c"rr\00"
@.str.70 = [4 x i8] c"sla\00"
@.str.71 = [4 x i8] c"sra\00"
@.str.72 = [4 x i8] c"???\00"
@.str.73 = [4 x i8] c"srl\00"
@.str.74 = [2 x i8] c" \00"
@.str.75 = [5 x i8] c"bit \00"
@.str.76 = [5 x i8] c"res \00"
@.str.77 = [5 x i8] c"set \00"
@.str.78 = [6 x i8] c"out (\00"
@.str.79 = [8 x i8] c"in a, (\00"
@.str.80 = [12 x i8] c"ex (sp), hl\00"
@.str.81 = [10 x i8] c"ex de, hl\00"
@.str.82 = [3 x i8] c"di\00"
@.str.83 = [3 x i8] c"ei\00"
@.str.84 = [6 x i8] c"call \00"
@.str.85 = [4 x i8] c"in \00"
@.str.86 = [6 x i8] c", (c)\00"
@.str.87 = [9 x i8] c"out (c),\00"
@.str.88 = [4 x i8] c"adc\00"
@.str.89 = [4 x i8] c"sbc\00"
@.str.90 = [6 x i8] c" hl, \00"
@.str.91 = [4 x i8] c", (\00"
@.str.92 = [6 x i8] c"LD\09\09(\00"
@.str.93 = [3 x i8] c"),\00"
@reltable.z80_Disassemble.157 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.95 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.157 to i64)) to i32)]
@.str.95 = [4 x i8] c"neg\00"
@reltable.z80_Disassemble.158 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.98 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.158 to i64)) to i32)]
@.str.97 = [5 x i8] c"retn\00"
@.str.98 = [5 x i8] c"reti\00"
@.str.99 = [4 x i8] c"im \00"
@reltable.z80_Disassemble.159 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @.str.101 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([7 x i8]* @.str.102 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.103 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.104 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.159 to i64)) to i32)]
@.str.101 = [8 x i8] c"ld i, a\00"
@.str.102 = [7 x i8] c"ld a,i\00"
@.str.103 = [4 x i8] c"rrd\00"
@.str.104 = [4 x i8] c"rld\00"
@reltable.z80_Disassemble.160 = internal unnamed_addr constant [32 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.106 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.107 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.108 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.109 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.110 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.111 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.112 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.113 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.114 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.115 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.116 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.117 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.118 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.119 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.120 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.121 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([32 x i32]* @reltable.z80_Disassemble.160 to i64)) to i32)]
@.str.106 = [4 x i8] c"ldi\00"
@.str.107 = [4 x i8] c"cpi\00"
@.str.108 = [4 x i8] c"ini\00"
@.str.109 = [5 x i8] c"outi\00"
@.str.110 = [4 x i8] c"ldd\00"
@.str.111 = [4 x i8] c"cpd\00"
@.str.112 = [4 x i8] c"ind\00"
@.str.113 = [5 x i8] c"outd\00"
@.str.114 = [5 x i8] c"ldir\00"
@.str.115 = [5 x i8] c"cpir\00"
@.str.116 = [5 x i8] c"inir\00"
@.str.117 = [5 x i8] c"otir\00"
@.str.118 = [5 x i8] c"lddr\00"
@.str.119 = [5 x i8] c"cpdr\00"
@.str.120 = [5 x i8] c"indr\00"
@.str.121 = [5 x i8] c"otdr\00"
@.str.122 = [3 x i8] c"iy\00"
@.str.123 = [3 x i8] c"ix\00"
@.str.124 = [5 x i8] c"add \00"
@.str.125 = [5 x i8] c", bc\00"
@.str.126 = [5 x i8] c", de\00"
@.str.127 = [4 x i8] c"), \00"
@.str.128 = [6 x i8] c"inc (\00"
@.str.129 = [2 x i8] c"+\00"
@.str.130 = [6 x i8] c"dec (\00"
@.str.131 = [5 x i8] c", sp\00"
@.str.132 = [3 x i8] c",(\00"
@.str.133 = [9 x i8] c"add a, (\00"
@.str.134 = [9 x i8] c"adc a, (\00"
@.str.135 = [6 x i8] c"sub (\00"
@.str.136 = [9 x i8] c"sbc a, (\00"
@.str.137 = [9 x i8] c"and a, (\00"
@.str.138 = [9 x i8] c"xor a, (\00"
@.str.139 = [8 x i8] c"or a, (\00"
@.str.140 = [8 x i8] c"cp a, (\00"
@.str.141 = [10 x i8] c"ex (sp), \00"
@.str.142 = [6 x i8] c"push \00"
@.str.143 = [5 x i8] c"jp (\00"
@.str.144 = [8 x i8] c"ld sp, \00"
@reltable.z80_Disassemble.161 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.146 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.147 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.148 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.149 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.150 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.151 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.152 to i64), i64 ptrtoint ([8 x i32]* @reltable.z80_Disassemble.161 to i64)) to i32)]
@.str.146 = [4 x i8] c"RLC\00"
@.str.147 = [4 x i8] c"RRC\00"
@.str.148 = [3 x i8] c"RL\00"
@.str.149 = [3 x i8] c"RR\00"
@.str.150 = [4 x i8] c"SLA\00"
@.str.151 = [4 x i8] c"SRA\00"
@.str.152 = [4 x i8] c"SRL\00"
@.str.153 = [4 x i8] c"res\00"
@.str.154 = [2 x i8] c"(\00"
@.str.155 = [5 x i8] c"rst \00"
define void @z80_Disassemble(i8* %0, i16 zeroext %1, i8* %2) {
%4 = alloca [80 x i8]
%5 = alloca [3 x i8]
%6 = zext i16 %1 to i64
%7 = getelementptr inbounds i8, i8* %0, i64 %6
%8 = load i8, i8* %7
%9 = zext i8 %8 to i32
%10 = lshr i8 %8, 3
%11 = and i8 %10, 7
%12 = and i8 %8, 7
%13 = getelementptr inbounds [80 x i8], [80 x i8]* %4, i64 0, i64 0
%14 = getelementptr inbounds [3 x i8], [3 x i8]* %5, i64 0, i64 0
%15 = lshr i32 %9, 6
switch i32 %15, label %738 [
i32 0, label %16
i32 1, label %164
i32 2, label %179
i32 3, label %188
]
16: ; preds = %3
%17 = zext i8 %12 to i32
switch i32 %17, label %739 [
i32 0, label %18
i32 1, label %60
i32 2, label %83
i32 3, label %125
i32 4, label %135
i32 5, label %141
i32 6, label %147
i32 7, label %159
]
18: ; preds = %16
%19 = zext i8 %11 to i32
switch i32 %19, label %44 [
i32 0, label %20
i32 1, label %22
i32 2, label %24
i32 3, label %34
]
20: ; preds = %18
%21 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.27, i64 0, i64 0))
br label %745
22: ; preds = %18
%23 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.28, i64 0, i64 0))
br label %745
24: ; preds = %18
%25 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.29, i64 0, i64 0))
%26 = add nuw nsw i64 %6, 1
%27 = getelementptr inbounds i8, i8* %0, i64 %26
%28 = load i8, i8* %27
%29 = trunc i16 %1 to i8
%30 = add i8 %29, 2
%31 = add i8 %30, %28
%32 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %31)
%33 = call i32 @strcat(i8* %2, i8* %13)
br label %745
34: ; preds = %18
%35 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0))
%36 = add nuw nsw i64 %6, 1
%37 = getelementptr inbounds i8, i8* %0, i64 %36
%38 = load i8, i8* %37
%39 = trunc i16 %1 to i8
%40 = add i8 %39, 2
%41 = add i8 %40, %38
%42 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %41)
%43 = call i32 @strcat(i8* %2, i8* %13)
br label %745
44: ; preds = %18
%45 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.31, i64 0, i64 0))
%46 = and i32 %19, 3
%47 = zext i32 %46 to i64
%48 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %47
%49 = load i8*, i8** %48
%50 = tail call i32 @strcat(i8* %2, i8* %49)
%51 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%52 = add nuw nsw i64 %6, 1
%53 = getelementptr inbounds i8, i8* %0, i64 %52
%54 = load i8, i8* %53
%55 = trunc i16 %1 to i8
%56 = add i8 %55, 2
%57 = add i8 %56, %54
%58 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %57)
%59 = call i32 @strcat(i8* %2, i8* %13)
br label %745
60: ; preds = %16
%61 = and i32 %9, 8
%62 = icmp eq i32 %61, 0
br i1 %62, label %70, label %63
63: ; preds = %60
%64 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.33, i64 0, i64 0))
%65 = lshr i8 %11, 1
%66 = zext i8 %65 to i64
%67 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %66
%68 = load i8*, i8** %67
%69 = tail call i32 @strcat(i8* %2, i8* %68)
br label %745
70: ; preds = %60
%71 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%72 = lshr i8 %11, 1
%73 = zext i8 %72 to i64
%74 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %73
%75 = load i8*, i8** %74
%76 = tail call i32 @strcat(i8* %2, i8* %75)
%77 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%78 = add nuw nsw i64 %6, 1
%79 = getelementptr inbounds i8, i8* %0, i64 %78
%80 = load i8, i8* %79
%81 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %80)
%82 = call i32 @strcat(i8* %2, i8* %13)
br label %745
83: ; preds = %16
%84 = zext i8 %11 to i32
switch i32 %84, label %740 [
i32 0, label %85
i32 1, label %87
i32 2, label %89
i32 3, label %91
i32 4, label %93
i32 5, label %101
i32 6, label %109
i32 7, label %117
]
85: ; preds = %83
%86 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.35, i64 0, i64 0))
br label %745
87: ; preds = %83
%88 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.36, i64 0, i64 0))
br label %745
89: ; preds = %83
%90 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0))
br label %745
91: ; preds = %83
%92 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.38, i64 0, i64 0))
br label %745
93: ; preds = %83
%94 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%95 = add nuw nsw i64 %6, 1
%96 = getelementptr inbounds i8, i8* %0, i64 %95
%97 = load i8, i8* %96
%98 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %97)
%99 = call i32 @strcat(i8* %2, i8* %13)
%100 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.40, i64 0, i64 0))
br label %745
101: ; preds = %83
%102 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.41, i64 0, i64 0))
%103 = add nuw nsw i64 %6, 1
%104 = getelementptr inbounds i8, i8* %0, i64 %103
%105 = load i8, i8* %104
%106 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %105)
%107 = call i32 @strcat(i8* %2, i8* %13)
%108 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
109: ; preds = %83
%110 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%111 = add nuw nsw i64 %6, 1
%112 = getelementptr inbounds i8, i8* %0, i64 %111
%113 = load i8, i8* %112
%114 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %113)
%115 = call i32 @strcat(i8* %2, i8* %13)
%116 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.43, i64 0, i64 0))
br label %745
117: ; preds = %83
%118 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.44, i64 0, i64 0))
%119 = add nuw nsw i64 %6, 1
%120 = getelementptr inbounds i8, i8* %0, i64 %119
%121 = load i8, i8* %120
%122 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %121)
%123 = call i32 @strcat(i8* %2, i8* %13)
%124 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
125: ; preds = %16
%126 = and i32 %9, 8
%127 = icmp eq i32 %126, 0
%128 = select i1 %127, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.45, i64 0, i64 0)
%129 = tail call i32 @strcpy(i8* %2, i8* %128)
%130 = lshr i8 %11, 1
%131 = zext i8 %130 to i64
%132 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %131
%133 = load i8*, i8** %132
%134 = tail call i32 @strcat(i8* %2, i8* %133)
br label %745
135: ; preds = %16
%136 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0))
%137 = zext i8 %11 to i64
%138 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %137
%139 = load i8*, i8** %138
%140 = tail call i32 @strcat(i8* %2, i8* %139)
br label %745
141: ; preds = %16
%142 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.45, i64 0, i64 0))
%143 = zext i8 %11 to i64
%144 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %143
%145 = load i8*, i8** %144
%146 = tail call i32 @strcat(i8* %2, i8* %145)
br label %745
147: ; preds = %16
%148 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%149 = zext i8 %11 to i64
%150 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %149
%151 = load i8*, i8** %150
%152 = tail call i32 @strcat(i8* %2, i8* %151)
%153 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%154 = add nuw nsw i64 %6, 1
%155 = getelementptr inbounds i8, i8* %0, i64 %154
%156 = load i8, i8* %155
%157 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %156)
%158 = call i32 @strcat(i8* %2, i8* %13)
br label %745
159: ; preds = %16
%160 = zext i8 %11 to i64
%161 = shl i64 %160, 2
%162 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.z80_Disassemble to i8*), i64 %161)
%163 = tail call i32 @strcpy(i8* %2, i8* %162)
br label %745
164: ; preds = %3
%165 = icmp eq i8 %11, %12
br i1 %165, label %166, label %168
166: ; preds = %164
%167 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.56, i64 0, i64 0))
br label %745
168: ; preds = %164
%169 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%170 = zext i8 %11 to i64
%171 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %170
%172 = load i8*, i8** %171
%173 = tail call i32 @strcat(i8* %2, i8* %172)
%174 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%175 = zext i8 %12 to i64
%176 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %175
%177 = load i8*, i8** %176
%178 = tail call i32 @strcat(i8* %2, i8* %177)
br label %745
179: ; preds = %3
%180 = zext i8 %11 to i64
%181 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.arith, i64 0, i64 %180
%182 = load i8*, i8** %181
%183 = tail call i32 @strcpy(i8* %2, i8* %182)
%184 = zext i8 %12 to i64
%185 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %184
%186 = load i8*, i8** %185
%187 = tail call i32 @strcat(i8* %2, i8* %186)
br label %745
188: ; preds = %3
%189 = zext i8 %12 to i32
switch i32 %189, label %741 [
i32 0, label %190
i32 1, label %196
i32 2, label %221
i32 3, label %233
i32 4, label %315
i32 5, label %327
i32 6, label %723
i32 7, label %733
]
190: ; preds = %188
%191 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.57, i64 0, i64 0))
%192 = zext i8 %11 to i64
%193 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %192
%194 = load i8*, i8** %193
%195 = tail call i32 @strcat(i8* %2, i8* %194)
br label %745
196: ; preds = %188
%197 = zext i8 %11 to i32
%198 = and i32 %197, 1
%199 = icmp eq i32 %198, 0
br i1 %199, label %210, label %200
200: ; preds = %196
%201 = lshr i32 %197, 1
switch i32 %201, label %742 [
i32 0, label %202
i32 1, label %204
i32 2, label %206
i32 3, label %208
]
202: ; preds = %200
%203 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.58, i64 0, i64 0))
br label %745
204: ; preds = %200
%205 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.59, i64 0, i64 0))
br label %745
206: ; preds = %200
%207 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.60, i64 0, i64 0))
br label %745
208: ; preds = %200
%209 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.61, i64 0, i64 0))
br label %745
210: ; preds = %196
%211 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.62, i64 0, i64 0))
%212 = lshr i32 %197, 1
%213 = icmp eq i32 %212, 3
br i1 %213, label %214, label %216
214: ; preds = %210
%215 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.63, i64 0, i64 0))
br label %745
216: ; preds = %210
%217 = zext i32 %212 to i64
%218 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %217
%219 = load i8*, i8** %218
%220 = tail call i32 @strcat(i8* %2, i8* %219)
br label %745
221: ; preds = %188
%222 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.64, i64 0, i64 0))
%223 = zext i8 %11 to i64
%224 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %223
%225 = load i8*, i8** %224
%226 = tail call i32 @strcat(i8* %2, i8* %225)
%227 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%228 = add nuw nsw i64 %6, 1
%229 = getelementptr inbounds i8, i8* %0, i64 %228
%230 = load i8, i8* %229
%231 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %230)
%232 = call i32 @strcat(i8* %2, i8* %13)
br label %745
233: ; preds = %188
%234 = zext i8 %11 to i32
switch i32 %234, label %743 [
i32 0, label %235
i32 1, label %242
i32 2, label %291
i32 3, label %299
i32 4, label %307
i32 5, label %309
i32 6, label %311
i32 7, label %313
]
235: ; preds = %233
%236 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.64, i64 0, i64 0))
%237 = add nuw nsw i64 %6, 1
%238 = getelementptr inbounds i8, i8* %0, i64 %237
%239 = load i8, i8* %238
%240 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %239)
%241 = call i32 @strcat(i8* %2, i8* %13)
br label %745
242: ; preds = %233
%243 = add i16 %1, 1
%244 = zext i16 %243 to i64
%245 = getelementptr inbounds i8, i8* %0, i64 %244
%246 = load i8, i8* %245
%247 = lshr i8 %246, 3
%248 = and i8 %247, 7
%249 = and i8 %246, 7
%250 = getelementptr inbounds [80 x i8], [80 x i8]* %4, i64 0, i64 1
store i8 0, i8* %250
%251 = lshr i8 %246, 6
%252 = zext i8 %251 to i32
switch i32 %252, label %290 [
i32 0, label %253
i32 1, label %263
i32 2, label %272
i32 3, label %281
]
253: ; preds = %242
%254 = zext i8 %248 to i64
%255 = shl i64 %254, 2
%256 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.z80_Disassemble.156 to i8*), i64 %255)
%257 = tail call i32 @strcpy(i8* %2, i8* %256)
%258 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.74, i64 0, i64 0))
%259 = zext i8 %249 to i64
%260 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %259
%261 = load i8*, i8** %260
%262 = tail call i32 @strcat(i8* %2, i8* %261)
br label %745
263: ; preds = %242
%264 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.75, i64 0, i64 0))
%265 = or i8 %248, 48
store i8 %265, i8* %13
%266 = call i32 @strcat(i8* %2, i8* %13)
%267 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%268 = zext i8 %249 to i64
%269 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %268
%270 = load i8*, i8** %269
%271 = call i32 @strcat(i8* %2, i8* %270)
br label %745
272: ; preds = %242
%273 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.76, i64 0, i64 0))
%274 = or i8 %248, 48
store i8 %274, i8* %13
%275 = call i32 @strcat(i8* %2, i8* %13)
%276 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%277 = zext i8 %249 to i64
%278 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %277
%279 = load i8*, i8** %278
%280 = call i32 @strcat(i8* %2, i8* %279)
br label %745
281: ; preds = %242
%282 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.77, i64 0, i64 0))
%283 = or i8 %248, 48
store i8 %283, i8* %13
%284 = call i32 @strcat(i8* %2, i8* %13)
%285 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%286 = zext i8 %249 to i64
%287 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %286
%288 = load i8*, i8** %287
%289 = call i32 @strcat(i8* %2, i8* %288)
br label %745
290: ; preds = %242
unreachable
291: ; preds = %233
%292 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.78, i64 0, i64 0))
%293 = add nuw nsw i64 %6, 1
%294 = getelementptr inbounds i8, i8* %0, i64 %293
%295 = load i8, i8* %294
%296 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %295)
%297 = call i32 @strcat(i8* %2, i8* %13)
%298 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.43, i64 0, i64 0))
br label %745
299: ; preds = %233
%300 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.79, i64 0, i64 0))
%301 = add nuw nsw i64 %6, 1
%302 = getelementptr inbounds i8, i8* %0, i64 %301
%303 = load i8, i8* %302
%304 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %303)
%305 = call i32 @strcat(i8* %2, i8* %13)
%306 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
307: ; preds = %233
%308 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.80, i64 0, i64 0))
br label %745
309: ; preds = %233
%310 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.81, i64 0, i64 0))
br label %745
311: ; preds = %233
%312 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.82, i64 0, i64 0))
br label %745
313: ; preds = %233
%314 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.83, i64 0, i64 0))
br label %745
315: ; preds = %188
%316 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.84, i64 0, i64 0))
%317 = zext i8 %11 to i64
%318 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.cond, i64 0, i64 %317
%319 = load i8*, i8** %318
%320 = tail call i32 @strcat(i8* %2, i8* %319)
%321 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%322 = add nuw nsw i64 %6, 1
%323 = getelementptr inbounds i8, i8* %0, i64 %322
%324 = load i8, i8* %323
%325 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %324)
%326 = call i32 @strcat(i8* %2, i8* %13)
br label %745
327: ; preds = %188
%328 = zext i8 %11 to i32
%329 = and i32 %328, 1
%330 = icmp eq i32 %329, 0
br i1 %330, label %712, label %331
331: ; preds = %327
%332 = lshr i32 %328, 1
switch i32 %332, label %433 [
i32 0, label %333
i32 2, label %340
]
333: ; preds = %331
%334 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.84, i64 0, i64 0))
%335 = add nuw nsw i64 %6, 1
%336 = getelementptr inbounds i8, i8* %0, i64 %335
%337 = load i8, i8* %336
%338 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %337)
%339 = call i32 @strcat(i8* %2, i8* %13)
br label %745
340: ; preds = %331
%341 = add i16 %1, 1
%342 = zext i16 %341 to i64
%343 = getelementptr inbounds i8, i8* %0, i64 %342
%344 = load i8, i8* %343
%345 = lshr i8 %344, 3
%346 = and i8 %345, 7
%347 = and i8 %344, -64
switch i8 %347, label %745 [
i8 64, label %348
i8 -128, label %427
]
348: ; preds = %340
%349 = and i8 %344, 7
%350 = zext i8 %349 to i32
switch i32 %350, label %744 [
i32 0, label %351
i32 1, label %358
i32 2, label %364
i32 3, label %376
i32 4, label %407
i32 5, label %412
i32 6, label %417
i32 7, label %422
]
351: ; preds = %348
%352 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.85, i64 0, i64 0))
%353 = zext i8 %346 to i64
%354 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %353
%355 = load i8*, i8** %354
%356 = tail call i32 @strcat(i8* %2, i8* %355)
%357 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.86, i64 0, i64 0))
br label %745
358: ; preds = %348
%359 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.87, i64 0, i64 0))
%360 = zext i8 %346 to i64
%361 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %360
%362 = load i8*, i8** %361
%363 = tail call i32 @strcat(i8* %2, i8* %362)
br label %745
364: ; preds = %348
%365 = zext i8 %346 to i32
%366 = and i32 %365, 1
%367 = icmp eq i32 %366, 0
%368 = select i1 %367, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.89, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.88, i64 0, i64 0)
%369 = tail call i32 @strcpy(i8* %2, i8* %368)
%370 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.90, i64 0, i64 0))
%371 = lshr i32 %365, 1
%372 = zext i32 %371 to i64
%373 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %372
%374 = load i8*, i8** %373
%375 = tail call i32 @strcat(i8* %2, i8* %374)
br label %745
376: ; preds = %348
%377 = zext i8 %346 to i32
%378 = and i32 %377, 1
%379 = icmp eq i32 %378, 0
br i1 %379, label %394, label %380
380: ; preds = %376
%381 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%382 = lshr i32 %377, 1
%383 = zext i32 %382 to i64
%384 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %383
%385 = load i8*, i8** %384
%386 = tail call i32 @strcat(i8* %2, i8* %385)
%387 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.91, i64 0, i64 0))
%388 = add nuw nsw i64 %342, 1
%389 = getelementptr inbounds i8, i8* %0, i64 %388
%390 = load i8, i8* %389
%391 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %390)
%392 = call i32 @strcat(i8* %2, i8* %13)
%393 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
394: ; preds = %376
%395 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.92, i64 0, i64 0))
%396 = add nuw nsw i64 %342, 1
%397 = getelementptr inbounds i8, i8* %0, i64 %396
%398 = load i8, i8* %397
%399 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %398)
%400 = call i32 @strcat(i8* %2, i8* %13)
%401 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0))
%402 = lshr i32 %377, 1
%403 = zext i32 %402 to i64
%404 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %403
%405 = load i8*, i8** %404
%406 = call i32 @strcat(i8* %2, i8* %405)
br label %745
407: ; preds = %348
%408 = zext i8 %346 to i64
%409 = shl i64 %408, 2
%410 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.z80_Disassemble.157 to i8*), i64 %409)
%411 = tail call i32 @strcpy(i8* %2, i8* %410)
br label %745
412: ; preds = %348
%413 = zext i8 %346 to i64
%414 = shl i64 %413, 2
%415 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.z80_Disassemble.158 to i8*), i64 %414)
%416 = tail call i32 @strcpy(i8* %2, i8* %415)
br label %745
417: ; preds = %348
%418 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.99, i64 0, i64 0))
%419 = add nuw nsw i8 %346, 47
store i8 %419, i8* %13
%420 = getelementptr inbounds [80 x i8], [80 x i8]* %4, i64 0, i64 1
store i8 0, i8* %420
%421 = call i32 @strcat(i8* %2, i8* %13)
br label %745
422: ; preds = %348
%423 = zext i8 %346 to i64
%424 = shl i64 %423, 2
%425 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.z80_Disassemble.159 to i8*), i64 %424)
%426 = tail call i32 @strcpy(i8* %2, i8* %425)
br label %745
427: ; preds = %340
%428 = and i8 %344, 31
%429 = zext i8 %428 to i64
%430 = shl i64 %429, 2
%431 = call i8* @llvm.load.relative.i64(i8* bitcast ([32 x i32]* @reltable.z80_Disassemble.160 to i8*), i64 %430)
%432 = tail call i32 @strcpy(i8* %2, i8* %431)
br label %745
433: ; preds = %331
%434 = and i32 %9, 32
%435 = icmp eq i32 %434, 0
%436 = select i1 %435, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.123, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.122, i64 0, i64 0)
%437 = call i32 @strcpy(i8* %14, i8* %436)
%438 = add i16 %1, 1
%439 = zext i16 %438 to i64
%440 = getelementptr inbounds i8, i8* %0, i64 %439
%441 = load i8, i8* %440
%442 = zext i8 %441 to i32
switch i8 %441, label %745 [
i8 9, label %443
i8 25, label %447
i8 33, label %451
i8 34, label %460
i8 35, label %469
i8 41, label %472
i8 42, label %477
i8 43, label %487
i8 52, label %490
i8 53, label %500
i8 54, label %510
i8 57, label %528
i8 70, label %532
i8 78, label %532
i8 86, label %532
i8 94, label %532
i8 102, label %532
i8 110, label %532
i8 112, label %549
i8 113, label %549
i8 114, label %549
i8 115, label %549
i8 116, label %549
i8 117, label %549
i8 119, label %549
i8 126, label %564
i8 -122, label %574
i8 -114, label %584
i8 -106, label %594
i8 -98, label %604
i8 -90, label %614
i8 -82, label %624
i8 -74, label %634
i8 -66, label %644
i8 -31, label %654
i8 -29, label %657
i8 -27, label %660
i8 -23, label %663
i8 -7, label %667
i8 -53, label %670
]
443: ; preds = %433
%444 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%445 = call i32 @strcat(i8* %2, i8* %14)
%446 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.125, i64 0, i64 0))
br label %745
447: ; preds = %433
%448 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%449 = call i32 @strcat(i8* %2, i8* %14)
%450 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.126, i64 0, i64 0))
br label %745
451: ; preds = %433
%452 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%453 = call i32 @strcat(i8* %2, i8* %14)
%454 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%455 = add nuw nsw i64 %439, 1
%456 = getelementptr inbounds i8, i8* %0, i64 %455
%457 = load i8, i8* %456
%458 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %457)
%459 = call i32 @strcat(i8* %2, i8* %13)
br label %745
460: ; preds = %433
%461 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%462 = add nuw nsw i64 %439, 1
%463 = getelementptr inbounds i8, i8* %0, i64 %462
%464 = load i8, i8* %463
%465 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %464)
%466 = call i32 @strcat(i8* %2, i8* %13)
%467 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.127, i64 0, i64 0))
%468 = call i32 @strcat(i8* %2, i8* %14)
br label %745
469: ; preds = %433
%470 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0))
%471 = call i32 @strcat(i8* %2, i8* %14)
br label %745
472: ; preds = %433
%473 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%474 = call i32 @strcat(i8* %2, i8* %14)
%475 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0))
%476 = call i32 @strcat(i8* %2, i8* %14)
br label %745
477: ; preds = %433
%478 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%479 = call i32 @strcat(i8* %2, i8* %14)
%480 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.91, i64 0, i64 0))
%481 = add nuw nsw i64 %439, 1
%482 = getelementptr inbounds i8, i8* %0, i64 %481
%483 = load i8, i8* %482
%484 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i8 zeroext %483)
%485 = call i32 @strcat(i8* %2, i8* %13)
%486 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
487: ; preds = %433
%488 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.45, i64 0, i64 0))
%489 = call i32 @strcat(i8* %2, i8* %14)
br label %745
490: ; preds = %433
%491 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.128, i64 0, i64 0))
%492 = call i32 @strcat(i8* %2, i8* %14)
%493 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%494 = add nuw nsw i64 %439, 1
%495 = getelementptr inbounds i8, i8* %0, i64 %494
%496 = load i8, i8* %495
%497 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %496)
%498 = call i32 @strcat(i8* %2, i8* %13)
%499 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
500: ; preds = %433
%501 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.130, i64 0, i64 0))
%502 = call i32 @strcat(i8* %2, i8* %14)
%503 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%504 = add nuw nsw i64 %439, 1
%505 = getelementptr inbounds i8, i8* %0, i64 %504
%506 = load i8, i8* %505
%507 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %506)
%508 = call i32 @strcat(i8* %2, i8* %13)
%509 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
510: ; preds = %433
%511 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%512 = call i32 @strcat(i8* %2, i8* %14)
%513 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%514 = zext i16 %438 to i32
%515 = add nuw nsw i32 %514, 1
%516 = zext i32 %515 to i64
%517 = getelementptr inbounds i8, i8* %0, i64 %516
%518 = load i8, i8* %517
%519 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %518)
%520 = call i32 @strcat(i8* %2, i8* %13)
%521 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0))
%522 = add nuw nsw i32 %514, 2
%523 = zext i32 %522 to i64
%524 = getelementptr inbounds i8, i8* %0, i64 %523
%525 = load i8, i8* %524
%526 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %525)
%527 = call i32 @strcat(i8* %2, i8* %13)
br label %745
528: ; preds = %433
%529 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.124, i64 0, i64 0))
%530 = call i32 @strcat(i8* %2, i8* %14)
%531 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.131, i64 0, i64 0))
br label %745
532: ; preds = %433, %433, %433, %433, %433, %433
%533 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.34, i64 0, i64 0))
%534 = lshr i32 %442, 3
%535 = and i32 %534, 7
%536 = zext i32 %535 to i64
%537 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %536
%538 = load i8*, i8** %537
%539 = call i32 @strcat(i8* %2, i8* %538)
%540 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.132, i64 0, i64 0))
%541 = call i32 @strcat(i8* %2, i8* %14)
%542 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%543 = add nuw nsw i64 %439, 1
%544 = getelementptr inbounds i8, i8* %0, i64 %543
%545 = load i8, i8* %544
%546 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %545)
%547 = call i32 @strcat(i8* %2, i8* %13)
%548 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
549: ; preds = %433, %433, %433, %433, %433, %433, %433
%550 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.39, i64 0, i64 0))
%551 = call i32 @strcat(i8* %2, i8* %14)
%552 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%553 = add nuw nsw i64 %439, 1
%554 = getelementptr inbounds i8, i8* %0, i64 %553
%555 = load i8, i8* %554
%556 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %555)
%557 = call i32 @strcat(i8* %2, i8* %13)
%558 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.93, i64 0, i64 0))
%559 = and i32 %442, 7
%560 = zext i32 %559 to i64
%561 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.reg, i64 0, i64 %560
%562 = load i8*, i8** %561
%563 = call i32 @strcat(i8* %2, i8* %562)
br label %745
564: ; preds = %433
%565 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.44, i64 0, i64 0))
%566 = call i32 @strcat(i8* %2, i8* %14)
%567 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%568 = add nuw nsw i64 %439, 1
%569 = getelementptr inbounds i8, i8* %0, i64 %568
%570 = load i8, i8* %569
%571 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %570)
%572 = call i32 @strcat(i8* %2, i8* %13)
%573 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
574: ; preds = %433
%575 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.133, i64 0, i64 0))
%576 = call i32 @strcat(i8* %2, i8* %14)
%577 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%578 = add nuw nsw i64 %439, 1
%579 = getelementptr inbounds i8, i8* %0, i64 %578
%580 = load i8, i8* %579
%581 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %580)
%582 = call i32 @strcat(i8* %2, i8* %13)
%583 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
584: ; preds = %433
%585 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.134, i64 0, i64 0))
%586 = call i32 @strcat(i8* %2, i8* %14)
%587 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%588 = add nuw nsw i64 %439, 1
%589 = getelementptr inbounds i8, i8* %0, i64 %588
%590 = load i8, i8* %589
%591 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %590)
%592 = call i32 @strcat(i8* %2, i8* %13)
%593 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
594: ; preds = %433
%595 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.135, i64 0, i64 0))
%596 = call i32 @strcat(i8* %2, i8* %14)
%597 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%598 = add nuw nsw i64 %439, 1
%599 = getelementptr inbounds i8, i8* %0, i64 %598
%600 = load i8, i8* %599
%601 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %600)
%602 = call i32 @strcat(i8* %2, i8* %13)
%603 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
604: ; preds = %433
%605 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.136, i64 0, i64 0))
%606 = call i32 @strcat(i8* %2, i8* %14)
%607 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%608 = add nuw nsw i64 %439, 1
%609 = getelementptr inbounds i8, i8* %0, i64 %608
%610 = load i8, i8* %609
%611 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %610)
%612 = call i32 @strcat(i8* %2, i8* %13)
%613 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
614: ; preds = %433
%615 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.137, i64 0, i64 0))
%616 = call i32 @strcat(i8* %2, i8* %14)
%617 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%618 = add nuw nsw i64 %439, 1
%619 = getelementptr inbounds i8, i8* %0, i64 %618
%620 = load i8, i8* %619
%621 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %620)
%622 = call i32 @strcat(i8* %2, i8* %13)
%623 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
624: ; preds = %433
%625 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.138, i64 0, i64 0))
%626 = call i32 @strcat(i8* %2, i8* %14)
%627 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%628 = add nuw nsw i64 %439, 1
%629 = getelementptr inbounds i8, i8* %0, i64 %628
%630 = load i8, i8* %629
%631 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %630)
%632 = call i32 @strcat(i8* %2, i8* %13)
%633 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
634: ; preds = %433
%635 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.139, i64 0, i64 0))
%636 = call i32 @strcat(i8* %2, i8* %14)
%637 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%638 = add nuw nsw i64 %439, 1
%639 = getelementptr inbounds i8, i8* %0, i64 %638
%640 = load i8, i8* %639
%641 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %640)
%642 = call i32 @strcat(i8* %2, i8* %13)
%643 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
644: ; preds = %433
%645 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.140, i64 0, i64 0))
%646 = call i32 @strcat(i8* %2, i8* %14)
%647 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%648 = add nuw nsw i64 %439, 1
%649 = getelementptr inbounds i8, i8* %0, i64 %648
%650 = load i8, i8* %649
%651 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %650)
%652 = call i32 @strcat(i8* %2, i8* %13)
%653 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
654: ; preds = %433
%655 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.62, i64 0, i64 0))
%656 = call i32 @strcat(i8* %2, i8* %14)
br label %745
657: ; preds = %433
%658 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.141, i64 0, i64 0))
%659 = call i32 @strcat(i8* %2, i8* %14)
br label %745
660: ; preds = %433
%661 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.142, i64 0, i64 0))
%662 = call i32 @strcat(i8* %2, i8* %14)
br label %745
663: ; preds = %433
%664 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.143, i64 0, i64 0))
%665 = call i32 @strcat(i8* %2, i8* %14)
%666 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
667: ; preds = %433
%668 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.144, i64 0, i64 0))
%669 = call i32 @strcat(i8* %2, i8* %14)
br label %745
670: ; preds = %433
%671 = zext i16 %438 to i32
%672 = add nuw nsw i32 %671, 2
%673 = zext i32 %672 to i64
%674 = getelementptr inbounds i8, i8* %0, i64 %673
%675 = load i8, i8* %674
%676 = lshr i8 %675, 3
%677 = and i8 %676, 7
%678 = getelementptr inbounds [80 x i8], [80 x i8]* %4, i64 0, i64 1
store i8 0, i8* %678
%679 = lshr i8 %675, 6
%680 = zext i8 %679 to i32
switch i32 %680, label %698 [
i32 0, label %681
i32 1, label %686
i32 2, label %690
i32 3, label %694
]
681: ; preds = %670
%682 = zext i8 %677 to i64
%683 = shl i64 %682, 2
%684 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.z80_Disassemble.161 to i8*), i64 %683)
%685 = call i32 @strcpy(i8* %2, i8* %684)
br label %699
686: ; preds = %670
%687 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.75, i64 0, i64 0))
%688 = or i8 %677, 48
store i8 %688, i8* %13
%689 = call i32 @strcat(i8* %2, i8* %13)
br label %699
690: ; preds = %670
%691 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.153, i64 0, i64 0))
%692 = or i8 %677, 48
store i8 %692, i8* %13
%693 = call i32 @strcat(i8* %2, i8* %13)
br label %699
694: ; preds = %670
%695 = call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.77, i64 0, i64 0))
%696 = or i8 %677, 48
store i8 %696, i8* %13
%697 = call i32 @strcat(i8* %2, i8* %13)
br label %699
698: ; preds = %670
unreachable
699: ; preds = %694, %690, %686, %681
%700 = phi i8* [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), %694 ], [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), %690 ], [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), %686 ], [ getelementptr inbounds ([2 x i8], [2 x i8]* @.str.74, i64 0, i64 0), %681 ]
%701 = call i32 @strcat(i8* %2, i8* %700)
%702 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.154, i64 0, i64 0))
%703 = call i32 @strcat(i8* %2, i8* %14)
%704 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.129, i64 0, i64 0))
%705 = add nuw nsw i32 %671, 1
%706 = zext i32 %705 to i64
%707 = getelementptr inbounds i8, i8* %0, i64 %706
%708 = load i8, i8* %707
%709 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %708)
%710 = call i32 @strcat(i8* %2, i8* %13)
%711 = call i32 @strcat(i8* %2, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.42, i64 0, i64 0))
br label %745
712: ; preds = %327
%713 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.142, i64 0, i64 0))
%714 = lshr i32 %328, 1
%715 = icmp eq i32 %714, 3
br i1 %715, label %716, label %718
716: ; preds = %712
%717 = tail call i32 @strcat(i8* %2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.63, i64 0, i64 0))
br label %745
718: ; preds = %712
%719 = zext i32 %714 to i64
%720 = getelementptr inbounds [4 x i8*], [4 x i8*]* @z80_Disassemble.dreg, i64 0, i64 %719
%721 = load i8*, i8** %720
%722 = tail call i32 @strcat(i8* %2, i8* %721)
br label %745
723: ; preds = %188
%724 = zext i8 %11 to i64
%725 = getelementptr inbounds [8 x i8*], [8 x i8*]* @z80_Disassemble.arith, i64 0, i64 %724
%726 = load i8*, i8** %725
%727 = tail call i32 @strcpy(i8* %2, i8* %726)
%728 = add nuw nsw i64 %6, 1
%729 = getelementptr inbounds i8, i8* %0, i64 %728
%730 = load i8, i8* %729
%731 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %730)
%732 = call i32 @strcat(i8* %2, i8* %13)
br label %745
733: ; preds = %188
%734 = tail call i32 @strcpy(i8* %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.155, i64 0, i64 0))
%735 = and i8 %8, 56
%736 = call i32 @sprintf(i8* %13, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.47, i64 0, i64 0), i8 zeroext %735)
%737 = call i32 @strcat(i8* %2, i8* %13)
br label %745
738: ; preds = %3
unreachable
739: ; preds = %16
unreachable
740: ; preds = %83
unreachable
741: ; preds = %188
unreachable
742: ; preds = %200
unreachable
743: ; preds = %233
unreachable
744: ; preds = %348
unreachable
745: ; preds = %190, %221, %315, %723, %733, %214, %216, %202, %204, %206, %208, %253, %263, %272, %281, %313, %311, %309, %307, %299, %291, %235, %716, %718, %333, %351, %358, %364, %407, %412, %417, %422, %394, %380, %340, %427, %433, %699, %667, %663, %660, %657, %654, %644, %634, %624, %614, %604, %594, %584, %574, %564, %549, %532, %528, %510, %500, %490, %487, %477, %472, %469, %460, %451, %447, %443, %166, %168, %125, %135, %141, %147, %159, %44, %34, %24, %22, %20, %70, %63, %117, %109, %101, %93, %91, %89, %87, %85, %179
ret void
}