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


x86 assembly (clang, -O0):
<Disassemble>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1e(%rbp)
mov    -0x1d(%rbp),%al
and    $0x7,%al
mov    %al,-0x1f(%rbp)
mov    -0x10(%rbp),%rsi
xor    %edi,%edi
call   1040 <OpcodeLen@plt>
mov    %eax,-0x78(%rbp)
movzbl -0x1d(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0x7c(%rbp)
je     11d5 <Disassemble+0x95>
jmp    119e <Disassemble+0x5e>
mov    -0x7c(%rbp),%eax
sub    $0x40,%eax
je     17bf <Disassemble+0x67f>
jmp    11af <Disassemble+0x6f>
mov    -0x7c(%rbp),%eax
sub    $0x80,%eax
je     183d <Disassemble+0x6fd>
jmp    11c2 <Disassemble+0x82>
mov    -0x7c(%rbp),%eax
sub    $0xc0,%eax
je     1876 <Disassemble+0x736>
jmp    2f56 <Disassemble+0x1e16>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0x88(%rbp)
sub    $0x7,%rax
ja     17ba <Disassemble+0x67a>
mov    -0x88(%rbp),%rax
lea    0x223c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl -0x1e(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0x3,%rax
ja     12f7 <Disassemble+0x1b7>
mov    -0x90(%rbp),%rax
lea    0x2250(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2286(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x2275(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x226b(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzwl -0x2(%rbp),%eax
add    $0x2,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
lea    0x2246(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x2229(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzwl -0x2(%rbp),%eax
add    $0x2,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
lea    0x21f6(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x21d9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0x3d94(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x22cc(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
movzwl -0x2(%rbp),%eax
add    $0x2,%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
lea    0x2178(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17ba <Disassemble+0x67a>
movzbl -0x1d(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     13b8 <Disassemble+0x278>
mov    -0x18(%rbp),%rdi
lea    0x214f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3ce6(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    143f <Disassemble+0x2ff>
mov    -0x18(%rbp),%rdi
lea    0x2125(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3cb3(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x220b(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x20a9(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17ba <Disassemble+0x67a>
movzbl -0x1e(%rbp),%eax
mov    %rax,-0x98(%rbp)
sub    $0x7,%rax
ja     1677 <Disassemble+0x537>
mov    -0x98(%rbp),%rax
lea    0x1fed(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2071(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1677 <Disassemble+0x537>
mov    -0x18(%rbp),%rdi
lea    0x2067(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1677 <Disassemble+0x537>
mov    -0x18(%rbp),%rdi
lea    0x205d(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1677 <Disassemble+0x537>
mov    -0x18(%rbp),%rdi
lea    0x2053(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1677 <Disassemble+0x537>
mov    -0x18(%rbp),%rdi
lea    0x2049(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1fcb(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x20aa(%rip),%rsi
call   1050 <strcat@plt>
jmp    1677 <Disassemble+0x537>
mov    -0x18(%rbp),%rdi
lea    0x1fe0(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1f5d(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x205d(%rip),%rsi
call   1050 <strcat@plt>
jmp    1677 <Disassemble+0x537>
mov    -0x18(%rbp),%rdi
lea    0x1f6d(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1eef(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1eee(%rip),%rsi
call   1050 <strcat@plt>
jmp    1677 <Disassemble+0x537>
mov    -0x18(%rbp),%rdi
lea    0x1f0d(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1e81(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f81(%rip),%rsi
call   1050 <strcat@plt>
jmp    17ba <Disassemble+0x67a>
movzbl -0x1d(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     16a1 <Disassemble+0x561>
mov    -0x18(%rbp),%rdi
lea    0x1e96(%rip),%rsi
call   1030 <strcpy@plt>
jmp    16b1 <Disassemble+0x571>
mov    -0x18(%rbp),%rdi
lea    0x1e86(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x39ca(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17ba <Disassemble+0x67a>
mov    -0x18(%rbp),%rdi
lea    0x1e53(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x395b(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17ba <Disassemble+0x67a>
mov    -0x18(%rbp),%rdi
lea    0x1e1f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x392c(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17ba <Disassemble+0x67a>
mov    -0x18(%rbp),%rdi
lea    0x1dab(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x38fd(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1e95(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x1db2(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17ba <Disassemble+0x67a>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x397f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2f56 <Disassemble+0x1e16>
movzbl -0x1e(%rbp),%eax
movzbl -0x1f(%rbp),%ecx
cmp    %ecx,%eax
jne    17e4 <Disassemble+0x6a4>
mov    -0x18(%rbp),%rdi
lea    0x1d87(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1838 <Disassemble+0x6f8>
mov    -0x18(%rbp),%rdi
lea    0x1cf9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x384b(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1de3(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x3821(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f56 <Disassemble+0x1e16>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x38a2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x37e8(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f56 <Disassemble+0x1e16>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xa0(%rbp)
sub    $0x7,%rax
ja     2f51 <Disassemble+0x1e11>
mov    -0xa0(%rbp),%rax
lea    0x1767(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1cb9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x37ed(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f51 <Disassemble+0x1e11>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1964 <Disassemble+0x824>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,%ecx
mov    %rcx,-0xa8(%rbp)
sub    $0x3,%eax
ja     195f <Disassemble+0x81f>
mov    -0xa8(%rbp),%rax
lea    0x1b1d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1c50(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195f <Disassemble+0x81f>
mov    -0x18(%rbp),%rdi
lea    0x1c3f(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195f <Disassemble+0x81f>
mov    -0x18(%rbp),%rdi
lea    0x1c2e(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195f <Disassemble+0x81f>
mov    -0x18(%rbp),%rdi
lea    0x1c21(%rip),%rsi
call   1030 <strcpy@plt>
jmp    19bc <Disassemble+0x87c>
mov    -0x18(%rbp),%rdi
lea    0x1c15(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    1999 <Disassemble+0x859>
mov    -0x18(%rbp),%rdi
lea    0x1bfa(%rip),%rsi
call   1050 <strcat@plt>
jmp    19b7 <Disassemble+0x877>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x36e2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    19bc <Disassemble+0x87c>
jmp    2f51 <Disassemble+0x1e11>
mov    -0x18(%rbp),%rdi
lea    0x1bc0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x36ce(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1c06(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1aa4(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f51 <Disassemble+0x1e11>
movzbl -0x1e(%rbp),%eax
mov    %rax,-0xb0(%rbp)
sub    $0x7,%rax
ja     1da3 <Disassemble+0xc63>
mov    -0xb0(%rbp),%rax
lea    0x1998(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1b0c(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1a1a(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1da3 <Disassemble+0xc63>
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%edx
add    $0x1,%edx
mov    %dx,%cx
mov    %cx,-0x2(%rbp)
mov    %edx,%ecx
movzwl %cx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1e(%rbp)
mov    -0x1d(%rbp),%al
and    $0x7,%al
mov    %al,-0x1f(%rbp)
movb   $0x0,-0x6f(%rbp)
movzbl -0x1d(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0xb4(%rbp)
je     1b61 <Disassemble+0xa21>
jmp    1b21 <Disassemble+0x9e1>
mov    -0xb4(%rbp),%eax
sub    $0x40,%eax
je     1baa <Disassemble+0xa6a>
jmp    1b35 <Disassemble+0x9f5>
mov    -0xb4(%rbp),%eax
sub    $0x80,%eax
je     1c00 <Disassemble+0xac0>
jmp    1b4b <Disassemble+0xa0b>
mov    -0xb4(%rbp),%eax
sub    $0xc0,%eax
je     1c56 <Disassemble+0xb16>
jmp    1ca7 <Disassemble+0xb67>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x35fe(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x1a77(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x34b4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca7 <Disassemble+0xb67>
mov    -0x18(%rbp),%rdi
lea    0x19f6(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1a32(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x345e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca7 <Disassemble+0xb67>
mov    -0x18(%rbp),%rdi
lea    0x19a5(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x19dc(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x3408(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca7 <Disassemble+0xb67>
mov    -0x18(%rbp),%rdi
lea    0x1954(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1986(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x33b2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1da3 <Disassemble+0xc63>
mov    -0x18(%rbp),%rdi
lea    0x1903(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x1862(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x18ca(%rip),%rsi
call   1050 <strcat@plt>
jmp    1da3 <Disassemble+0xc63>
mov    -0x18(%rbp),%rdi
lea    0x18b9(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x180e(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x18a9(%rip),%rsi
call   1050 <strcat@plt>
jmp    1da3 <Disassemble+0xc63>
mov    -0x18(%rbp),%rdi
lea    0x186d(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da3 <Disassemble+0xc63>
mov    -0x18(%rbp),%rdi
lea    0x1864(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da3 <Disassemble+0xc63>
mov    -0x18(%rbp),%rdi
lea    0x18b2(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da3 <Disassemble+0xc63>
mov    -0x18(%rbp),%rdi
lea    0x1844(%rip),%rsi
call   1030 <strcpy@plt>
jmp    2f51 <Disassemble+0x1e11>
mov    -0x18(%rbp),%rdi
lea    0x1832(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x32e7(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x181f(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x16bd(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f51 <Disassemble+0x1e11>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2e5a <Disassemble+0x1d1a>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,-0xb8(%rbp)
test   %eax,%eax
je     1e6d <Disassemble+0xd2d>
jmp    1e59 <Disassemble+0xd19>
mov    -0xb8(%rbp),%eax
sub    $0x2,%eax
je     1ecb <Disassemble+0xd8b>
jmp    2219 <Disassemble+0x10d9>
mov    -0x18(%rbp),%rdi
lea    0x176d(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1622(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e55 <Disassemble+0x1d15>
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%edx
add    $0x1,%edx
mov    %dx,%cx
mov    %cx,-0x2(%rbp)
mov    %edx,%ecx
movzwl %cx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1e(%rbp)
mov    -0x1d(%rbp),%al
and    $0x7,%al
mov    %al,-0x1f(%rbp)
movzbl -0x1d(%rbp),%eax
and    $0xffffffc0,%eax
mov    %eax,-0xbc(%rbp)
sub    $0x40,%eax
je     1f2c <Disassemble+0xdec>
jmp    1f16 <Disassemble+0xdd6>
mov    -0xbc(%rbp),%eax
sub    $0x80,%eax
je     21f6 <Disassemble+0x10b6>
jmp    2214 <Disassemble+0x10d4>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xc8(%rbp)
sub    $0x7,%rax
ja     21f1 <Disassemble+0x10b1>
mov    -0xc8(%rbp),%rax
lea    0x10d1(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1688(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x30d7(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1662(%rip),%rsi
call   1050 <strcat@plt>
jmp    21f1 <Disassemble+0x10b1>
mov    -0x18(%rbp),%rdi
lea    0x1653(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3098(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    21f1 <Disassemble+0x10b1>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1feb <Disassemble+0xeab>
mov    -0x18(%rbp),%rdi
lea    0x161e(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1ffb <Disassemble+0xebb>
mov    -0x18(%rbp),%rdi
lea    0x160d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x1601(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3070(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    21f1 <Disassemble+0x10b1>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     20da <Disassemble+0xf9a>
mov    -0x18(%rbp),%rdi
lea    0x149f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x302d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1639(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1423(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1523(%rip),%rsi
call   1050 <strcat@plt>
jmp    2161 <Disassemble+0x1021>
mov    -0x18(%rbp),%rdi
lea    0x1433(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x13b5(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x14cf(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x2f38(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    21f1 <Disassemble+0x10b1>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3039(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    21f1 <Disassemble+0x10b1>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x305a(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    21f1 <Disassemble+0x10b1>
mov    -0x18(%rbp),%rdi
lea    0x146f(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%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   1050 <strcat@plt>
jmp    21f1 <Disassemble+0x10b1>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3048(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2214 <Disassemble+0x10d4>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x1f,%eax
movslq %eax,%rcx
lea    0x3065(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2e55 <Disassemble+0x1d15>
movzbl -0x1d(%rbp),%eax
mov    %al,%cl
lea    0x145e(%rip),%rax
lea    0x145a(%rip),%rsi
test   $0x20,%cl
cmovne %rax,%rsi
lea    -0x73(%rbp),%rdi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%edx
add    $0x1,%edx
mov    %dx,%cx
mov    %cx,-0x2(%rbp)
mov    %edx,%ecx
movzwl %cx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1d(%rbp)
movzbl -0x1d(%rbp),%eax
add    $0xfffffff7,%eax
mov    %eax,%ecx
mov    %rcx,-0xd0(%rbp)
sub    $0xf0,%eax
ja     2e50 <Disassemble+0x1d10>
mov    -0xd0(%rbp),%rax
lea    0xdbd(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x13f3(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x13db(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x13c1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x13ae(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x11ed(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x12f6(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1182(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x11a2(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x1124(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x122c(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x1141(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x1277(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x11de(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x1096(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1249(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
lea    0x102b(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x112b(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x1050(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x119a(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1183(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xffd(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1098(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x1131(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1112(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xf8c(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1027(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xf37(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x10a1(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xf1b(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xfd0(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
lea    0xedc(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x1009(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1009(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xe35(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
sar    $0x3,%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x2980(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xfcc(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xf9e(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xe18(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xeb3(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xdc3(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xf2d(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xda7(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xe5c(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x2885(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xec8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xe9e(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xd18(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xdb3(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xe5e(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xe2d(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xca7(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xd42(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xdf6(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xdbc(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xc36(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xcd1(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xd8d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xd4b(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xbc5(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc60(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xd22(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xcda(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xb54(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xbef(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xcba(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc69(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xae3(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb7e(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xc51(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xbf8(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xa72(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb0d(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xbe9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb87(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0xa01(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xa9c(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xb7f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb16(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x990(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xa2b(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0x9a7(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xaf3(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xadb(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xabf(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x993(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x18(%rbp),%rdi
lea    0xa92(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e50 <Disassemble+0x1d10>
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1e(%rbp)
movb   $0x0,-0x6f(%rbp)
movzbl -0x1d(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0xd4(%rbp)
je     2d06 <Disassemble+0x1bc6>
jmp    2cc6 <Disassemble+0x1b86>
mov    -0xd4(%rbp),%eax
sub    $0x40,%eax
je     2d35 <Disassemble+0x1bf5>
jmp    2cda <Disassemble+0x1b9a>
mov    -0xd4(%rbp),%eax
sub    $0x80,%eax
je     2d71 <Disassemble+0x1c31>
jmp    2cf0 <Disassemble+0x1bb0>
mov    -0xd4(%rbp),%eax
sub    $0xc0,%eax
je     2dad <Disassemble+0x1c6d>
jmp    2de4 <Disassemble+0x1ca4>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x2659(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x8d2(%rip),%rsi
call   1050 <strcat@plt>
jmp    2de4 <Disassemble+0x1ca4>
mov    -0x18(%rbp),%rdi
lea    0x86b(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x8a7(%rip),%rsi
call   1050 <strcat@plt>
jmp    2de4 <Disassemble+0x1ca4>
mov    -0x18(%rbp),%rdi
lea    0x834(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x86b(%rip),%rsi
call   1050 <strcat@plt>
jmp    2de4 <Disassemble+0x1ca4>
mov    -0x18(%rbp),%rdi
lea    0x7fd(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
add    $0x30,%eax
mov    %al,-0x70(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x82f(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x8cb(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x893(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x70d(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x7a8(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e55 <Disassemble+0x1d15>
jmp    2ec7 <Disassemble+0x1d87>
mov    -0x18(%rbp),%rdi
lea    0x897(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0xe0(%rbp)
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    2e98 <Disassemble+0x1d58>
lea    0x6fd(%rip),%rax
mov    %rax,-0xe8(%rbp)
jmp    2eb4 <Disassemble+0x1d74>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x21e7(%rip),%rax
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xe8(%rbp)
mov    -0xe0(%rbp),%rdi
mov    -0xe8(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f51 <Disassemble+0x1e11>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x2213(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
lea    0x638(%rip),%rsi
movzbl (%rax,%rcx,1),%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f51 <Disassemble+0x1e11>
mov    -0x18(%rbp),%rdi
lea    0x7ea(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x38,%eax
lea    0x5fb(%rip),%rsi
movzbl %al,%edx
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f56 <Disassemble+0x1e16>
mov    -0x78(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Disassemble>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdx,%r15
mov    %rsi,%r12
mov    %edi,%r13d
movzbl (%rsi),%ebx
mov    %ebx,%r14d
shr    $0x3,%r14d
and    $0x7,%r14d
mov    %ebx,%ebp
and    $0x7,%ebp
xor    %edi,%edi
call   1040 <OpcodeLen@plt>
mov    %rbx,%rdx
shr    $0x6,%rdx
lea    0xe81(%rip),%rcx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
mov    %eax,0x64(%rsp)
jmp    *%rdx
mov    %ebp,%edx
lea    0x12ef(%rip),%rcx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
cmp    $0x3,%r14d
ja     1518 <Disassemble+0x3d8>
mov    %r14d,%eax
lea    0x1312(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x144c(%rip),%rsi
jmp    1349 <Disassemble+0x209>
cmp    %bpl,%r14b
jne    1236 <Disassemble+0xf6>
lea    0x14de(%rip),%rsi
jmp    1349 <Disassemble+0x209>
movzbl %r14b,%eax
lea    0x2bbd(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %bpl,%eax
lea    0x2b06(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
movzbl %bpl,%edx
lea    0xdff(%rip),%rcx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
lea    0x1495(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x2b2c(%rip),%rcx
jmp    11fa <Disassemble+0xba>
lea    0x13fb(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x2ab0(%rip),%rbx
mov    (%rbx,%rax,8),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x14e9(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
mov    (%rbx,%rbp,8),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
test   $0x8,%bl
jne    14ad <Disassemble+0x36d>
lea    0x13b1(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
shr    %r14b
movzbl %r14b,%eax
lea    0x2aa3(%rip),%rcx
jmp    13c8 <Disassemble+0x288>
movzbl %r14b,%eax
lea    0x11f7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x137f(%rip),%rsi
jmp    1349 <Disassemble+0x209>
test   $0x8,%bl
lea    0x13b6(%rip),%rax
lea    0x13aa(%rip),%rsi
cmove  %rax,%rsi
jmp    14b4 <Disassemble+0x374>
lea    0x139f(%rip),%rsi
jmp    12ec <Disassemble+0x1ac>
lea    0x1391(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %r14b,%eax
jmp    11f3 <Disassemble+0xb3>
lea    0x1334(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x29e9(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x1422(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
jmp    1441 <Disassemble+0x301>
movzbl %r14b,%eax
lea    0x1192(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
jmp    146a <Disassemble+0x32a>
movzbl %r14b,%ebx
test   $0x1,%r14b
jne    14cf <Disassemble+0x38f>
lea    0x1369(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
shr    %ebx
cmp    $0x3,%ebx
je     141e <Disassemble+0x2de>
mov    %ebx,%eax
jmp    14c3 <Disassemble+0x383>
lea    0x1350(%rip),%rsi
jmp    13b5 <Disassemble+0x275>
movzbl %r14b,%edx
lea    0x10ab(%rip),%rcx
movslq (%rcx,%rdx,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
lea    0x1333(%rip),%rsi
jmp    1507 <Disassemble+0x3c7>
lea    0x1380(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %r14b,%eax
lea    0x2998(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x1371(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
movzwl %r13w,%eax
movzbl 0x1(%rax,%r12,1),%edx
lea    0x122f(%rip),%rsi
jmp    1452 <Disassemble+0x312>
movzbl %r14b,%ebp
test   $0x1,%r14b
jne    14ed <Disassemble+0x3ad>
lea    0x1441(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
shr    %ebp
cmp    $0x3,%ebp
jne    1514 <Disassemble+0x3d4>
lea    0x12b4(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
movzbl %r14b,%eax
lea    0x296b(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r13w,%eax
movzbl 0x1(%rax,%r12,1),%edx
lea    0x1235(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
mov    0x64(%rsp),%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x13db(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
and    $0x38,%ebx
lea    0x11f1(%rip),%rsi
lea    0x10(%rsp),%rbp
mov    %rbp,%rdi
mov    %ebx,%edx
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
jmp    1465 <Disassemble+0x325>
lea    0x117b(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
shr    %r14b
movzbl %r14b,%eax
lea    0x2876(%rip),%rcx
jmp    11fa <Disassemble+0xba>
shr    %ebx
lea    0xf9c(%rip),%rax
movslq (%rax,%rbx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
lea    0x11d3(%rip),%rsi
jmp    1349 <Disassemble+0x209>
shr    %ebp
cmp    $0x2,%ebp
je     1589 <Disassemble+0x449>
test   %ebp,%ebp
jne    15f9 <Disassemble+0x4b9>
lea    0x122e(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
jmp    13e3 <Disassemble+0x2a3>
mov    %ebp,%eax
jmp    14c3 <Disassemble+0x383>
lea    0x110c(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
and    $0x3,%r14d
lea    0x282e(%rip),%rax
mov    (%rax,%r14,8),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x1207(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
jmp    1573 <Disassemble+0x433>
lea    0x10bc(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0x10bb(%rip),%rsi
jmp    156b <Disassemble+0x42b>
lea    0x10c0(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r13w,%eax
add    0x1(%rax,%r12,1),%r13b
add    $0x2,%r13b
movzbl %r13b,%edx
jmp    13ed <Disassemble+0x2ad>
add    $0x1,%r13d
movzwl %r13w,%ebx
movzbl (%r12,%rbx,1),%eax
mov    %eax,%ecx
and    $0xc0,%cl
cmp    $0x80,%cl
je     18ad <Disassemble+0x76d>
cmp    $0x40,%cl
jne    146a <Disassemble+0x32a>
mov    %eax,%ebp
shr    $0x3,%ebp
and    $0x7,%ebp
and    $0x7,%eax
lea    0xa71(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x116c(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0x2722(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x114e(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
test   $0x20,%bl
lea    0x11d4(%rip),%rax
lea    0x11ca(%rip),%rsi
cmove  %rax,%rsi
lea    0xd(%rsp),%rdi
call   1030 <strcpy@plt>
add    $0x1,%r13d
movzwl %r13w,%ebx
movzbl (%r12,%rbx,1),%ebp
lea    0x7a(%rbp),%eax
cmp    $0xf8,%al
ja     146a <Disassemble+0x32a>
movzbl %al,%eax
lea    0xa16(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x101e(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x1189(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
movzbl 0x1(%rbx,%r12,1),%edx
lea    0x100c(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0x10c3(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
and    $0x7,%ebp
jmp    17e1 <Disassemble+0x6a1>
lea    0xf96(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xf95(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xf94(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xf93(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r13w,%eax
movzbl 0x1(%rax,%r12,1),%edx
lea    0xf35(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0x1015(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xf51(%rip),%rsi
jmp    176c <Disassemble+0x62c>
lea    0xf43(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r13w,%eax
movzbl 0x1(%rax,%r12,1),%edx
lea    0xee5(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0xee5(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xf0a(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r13w,%eax
movzbl 0x1(%rax,%r12,1),%edx
lea    0xe9e(%rip),%rsi
jmp    1d26 <Disassemble+0xbe6>
add    $0x1,%r13d
movzwl %r13w,%eax
movzbl (%r12,%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    0xcae(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x261a(%rip),%rax
mov    (%rax,%rbx,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xf74(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x2518(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xf0f(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r13w,%eax
movzbl 0x1(%rax,%r12,1),%edx
lea    0xe73(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0xedd(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xed2(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r13w,%eax
movzbl 0x1(%rax,%r12,1),%edx
jmp    1d1f <Disassemble+0xbdf>
lea    0xebc(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xebc(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xf13(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xeae(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xe2f(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xe27(%rip),%rsi
jmp    1349 <Disassemble+0x209>
lea    0xe23(%rip),%rsi
jmp    1349 <Disassemble+0x209>
and    $0x1f,%eax
lea    0xc9d(%rip),%rcx
jmp    1342 <Disassemble+0x202>
lea    0xe38(%rip),%rsi
jmp    18d5 <Disassemble+0x795>
lea    0xe34(%rip),%rsi
jmp    18d5 <Disassemble+0x795>
lea    0xe30(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0x30(%rbx),%eax
mov    %al,0x10(%rsp)
lea    0x10(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xe66(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
jmp    11ef <Disassemble+0xaf>
lea    0xd2c(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
and    $0x38,%ebp
lea    0x23e2(%rip),%rax
mov    0x0(%rbp,%rax,1),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xece(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
jmp    1cfd <Disassemble+0xbbd>
lea    0xdff(%rip),%rsi
jmp    11e7 <Disassemble+0xa7>
movzbl %bpl,%ebx
test   $0x1,%bpl
lea    0xdf9(%rip),%rax
lea    0xdee(%rip),%rsi
cmove  %rax,%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xde3(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
and    $0x6,%ebx
lea    0x23ba(%rip),%rax
mov    (%rax,%rbx,4),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
movzbl %bpl,%r14d
test   $0x1,%bpl
jne    1da8 <Disassemble+0xc68>
lea    0xcc1(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl 0x1(%rbx,%r12,1),%edx
lea    0xc67(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0xd82(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
shr    %r14d
lea    0x2353(%rip),%rax
mov    (%rax,%r14,8),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
movzbl %bpl,%eax
lea    0xaf0(%rip),%rcx
jmp    1342 <Disassemble+0x202>
movzbl %bpl,%eax
lea    0xb00(%rip),%rcx
jmp    1342 <Disassemble+0x202>
lea    0xd4e(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0x2f(%rbp),%eax
mov    %al,0x10(%rsp)
movb   $0x0,0x11(%rsp)
lea    0x10(%rsp),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
movzbl %bpl,%eax
lea    0xae8(%rip),%rcx
jmp    1342 <Disassemble+0x202>
lea    0xdab(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xda8(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xda4(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xd9e(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xd9b(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xd97(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xd94(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xd8f(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
movzbl 0x2(%rbx,%r12,1),%ebp
movzbl %bpl,%eax
shr    $0x3,%ebp
and    $0x7,%ebp
movb   $0x0,0x11(%rsp)
shr    $0x6,%rax
lea    0x963(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    0x22ff(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xc59(%rip),%rsi
jmp    1e2a <Disassemble+0xcea>
lea    0xbd4(%rip),%rsi
jmp    1c23 <Disassemble+0xae3>
lea    0xd36(%rip),%rsi
jmp    1c23 <Disassemble+0xae3>
lea    0xd34(%rip),%rsi
jmp    1c23 <Disassemble+0xae3>
lea    0xd2e(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
jmp    1d39 <Disassemble+0xbf9>
lea    0xd17(%rip),%rsi
jmp    1c23 <Disassemble+0xae3>
lea    0xc8e(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xc77(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xc63(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xc51(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xac6(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl 0x1(%rbx,%r12,1),%edx
lea    0xa6c(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0xb75(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
jmp    1c2b <Disassemble+0xaeb>
lea    0xa9b(%rip),%rsi
jmp    1c23 <Disassemble+0xae3>
lea    0xbea(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rbx
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0xb4f(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
jmp    145f <Disassemble+0x31f>
lea    0xa5a(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xbaa(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xba6(%rip),%rsi
jmp    1cf5 <Disassemble+0xbb5>
lea    0xa11(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xb7c(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
movzbl 0x1(%rbx,%r12,1),%edx
lea    0x9ff(%rip),%r13
lea    0x10(%rsp),%rbp
mov    %rbp,%rdi
mov    %r13,%rsi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
call   1050 <strcat@plt>
lea    0xab3(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
movzbl 0x2(%rbx,%r12,1),%edx
mov    %rbp,%rdi
mov    %r13,%rsi
jmp    14a0 <Disassemble+0x360>
lea    0xb10(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xb11(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0xb07(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xade(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
movzbl 0x1(%rbx,%r12,1),%edx
lea    0x961(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
call   1060 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1050 <strcat@plt>
lea    0x9fe(%rip),%rsi
mov    %r15,%rdi
jmp    1465 <Disassemble+0x325>
lea    0x8e4(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x9ee(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
movzbl 0x1(%rbx,%r12,1),%edx
jmp    13ed <Disassemble+0x2ad>
lea    0x8ae(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0xd(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xa62(%rip),%rsi
jmp    1dd4 <Disassemble+0xc94>
lea    0x889(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
shr    %r14d
lea    0x1f7f(%rip),%rax
mov    (%rax,%r14,8),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0xa2c(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
movzbl 0x1(%rbx,%r12,1),%edx
lea    0x83a(%rip),%rsi
jmp    1d26 <Disassemble+0xbe6>
lea    0x906(%rip),%rsi
jmp    1e07 <Disassemble+0xcc7>
lea    0x902(%rip),%rsi
jmp    1e07 <Disassemble+0xcc7>
lea    0x8fe(%rip),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
lea    0x30(%rbp),%eax
mov    %al,0x10(%rsp)
lea    0x10(%rsp),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x934(%rip),%rsi
mov    %r15,%rdi
call   1050 <strcat@plt>
lea    0x9d1(%rip),%rsi
jmp    1932 <Disassemble+0x7f2>

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

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