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%2.2X", (adr + 2 + (char)Opcodes[adr + 1]) & 0xff);
        strcat(s, stemp);
        break;
      case 0x03:
        strcpy(s, "jr ");
        sprintf(stemp, "0x%2.2X", (adr + 2 + (char)Opcodes[adr + 1]) & 0xff);
        strcat(s, stemp);
        break;
      default:
        strcpy(s, "jr ");
        strcat(s, cond[d & 3]);
        strcat(s, ", ");
        sprintf(stemp, "0x%2.2X", (adr + 2 + (char)Opcodes[adr + 1]) & 0xff);
        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] = {"rlca", "rrca", "rla", "rra",
                                   "daa",  "cpl",  "scf", "ccf"};
      strcpy(s, str[d]);
    } break;
    }
    break;
  case 0x40:
    if (a == 0x76) {
      strcpy(s, "halt");
      break;
    }
    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", "sll", "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 ");
              if (d != 6)
                strcat(s, reg[d]);
              else
                strcat(s, "f");
              strcat(s, ", (c)");
              break;
            case 0x01:
              strcpy(s, "out (c), ");
              if (d != 6)
                strcat(s, reg[d]);
              else
                strcat(s, "0");
              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 ");
              switch (a) {
              case 0x46:
                strcat(s, "0");
                break;
              case 0x56:
                strcat(s, "1");
                break;
              case 0x5E:
                strcat(s, "2");
                break;
              }
              break;
            case 0x07: {
              static char *str[8] = {"ld i, a", "ld r, a", "ld a, i", "ld a, r",
                                     "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 a, (");
            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 ", "sll ", "srl "};
              strcpy(s, str[d]);
            } 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;
            }
            if ((a & 7) != 6) {
              strcat(s, reg[a & 7]);
              strcat(s, ", ");
            }
            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
mov    %dil,%al
call   1040 <OpcodeLen@plt>
mov    %eax,-0x78(%rbp)
movzbl -0x1d(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0x7c(%rbp)
je     11d8 <Disassemble+0x98>
jmp    11a1 <Disassemble+0x61>
mov    -0x7c(%rbp),%eax
sub    $0x40,%eax
je     17ce <Disassemble+0x68e>
jmp    11b2 <Disassemble+0x72>
mov    -0x7c(%rbp),%eax
sub    $0x80,%eax
je     1849 <Disassemble+0x709>
jmp    11c5 <Disassemble+0x85>
mov    -0x7c(%rbp),%eax
sub    $0xc0,%eax
je     1882 <Disassemble+0x742>
jmp    304c <Disassemble+0x1f0c>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0x88(%rbp)
sub    $0x7,%rax
ja     17c9 <Disassemble+0x689>
mov    -0x88(%rbp),%rax
lea    0x3239(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl -0x1e(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0x3,%rax
ja     1304 <Disassemble+0x1c4>
mov    -0x90(%rbp),%rax
lea    0x324d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x3286(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1382 <Disassemble+0x242>
mov    -0x18(%rbp),%rdi
lea    0x3275(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1382 <Disassemble+0x242>
mov    -0x18(%rbp),%rdi
lea    0x326b(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
add    %eax,%edx
and    $0xff,%edx
lea    0x3240(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1382 <Disassemble+0x242>
mov    -0x18(%rbp),%rdi
lea    0x3224(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
add    %eax,%edx
and    $0xff,%edx
lea    0x31eb(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1382 <Disassemble+0x242>
mov    -0x18(%rbp),%rdi
lea    0x31cf(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0x4d87(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x32c0(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
movzwl -0x2(%rbp),%edx
add    $0x2,%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
add    %eax,%edx
and    $0xff,%edx
lea    0x3168(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17c9 <Disassemble+0x689>
movzbl -0x1d(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     13ca <Disassemble+0x28a>
mov    -0x18(%rbp),%rdi
lea    0x3140(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x4cd4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1450 <Disassemble+0x310>
mov    -0x18(%rbp),%rdi
lea    0x3116(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x4ca1(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x31fa(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x30b3(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17c9 <Disassemble+0x689>
movzbl -0x1e(%rbp),%eax
mov    %rax,-0x98(%rbp)
sub    $0x7,%rax
ja     1684 <Disassemble+0x544>
mov    -0x98(%rbp),%rax
lea    0x2fdc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x306b(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1684 <Disassemble+0x544>
mov    -0x18(%rbp),%rdi
lea    0x3061(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1684 <Disassemble+0x544>
mov    -0x18(%rbp),%rdi
lea    0x3057(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1684 <Disassemble+0x544>
mov    -0x18(%rbp),%rdi
lea    0x304d(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1684 <Disassemble+0x544>
mov    -0x18(%rbp),%rdi
lea    0x3043(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2fd6(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x309b(%rip),%rsi
call   1050 <strcat@plt>
jmp    1684 <Disassemble+0x544>
mov    -0x18(%rbp),%rdi
lea    0x2fdb(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2f69(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x304f(%rip),%rsi
call   1050 <strcat@plt>
jmp    1684 <Disassemble+0x544>
mov    -0x18(%rbp),%rdi
lea    0x2f69(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2efc(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2eeb(%rip),%rsi
call   1050 <strcat@plt>
jmp    1684 <Disassemble+0x544>
mov    -0x18(%rbp),%rdi
lea    0x2f0a(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2e8f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2f75(%rip),%rsi
call   1050 <strcat@plt>
jmp    17c9 <Disassemble+0x689>
movzbl -0x1d(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     16ae <Disassemble+0x56e>
mov    -0x18(%rbp),%rdi
lea    0x2e95(%rip),%rsi
call   1030 <strcpy@plt>
jmp    16be <Disassemble+0x57e>
mov    -0x18(%rbp),%rdi
lea    0x2e85(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x49bd(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17c9 <Disassemble+0x689>
mov    -0x18(%rbp),%rdi
lea    0x2e52(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x494e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17c9 <Disassemble+0x689>
mov    -0x18(%rbp),%rdi
lea    0x2e1e(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x491f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17c9 <Disassemble+0x689>
mov    -0x18(%rbp),%rdi
lea    0x2da1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x48f0(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2e89(%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),%edx
lea    0x2d40(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17c9 <Disassemble+0x689>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x4970(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    304c <Disassemble+0x1f0c>
movzbl -0x1d(%rbp),%eax
cmp    $0x76,%eax
jne    17f0 <Disassemble+0x6b0>
mov    -0x18(%rbp),%rdi
lea    0x2d7f(%rip),%rsi
call   1030 <strcpy@plt>
jmp    304c <Disassemble+0x1f0c>
mov    -0x18(%rbp),%rdi
lea    0x2cf0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x483f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2dd8(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x4815(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    304c <Disassemble+0x1f0c>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x4896(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x47dc(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    304c <Disassemble+0x1f0c>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xa0(%rbp)
sub    $0x7,%rax
ja     3047 <Disassemble+0x1f07>
mov    -0xa0(%rbp),%rax
lea    0x275b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2cb1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x47e1(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    3047 <Disassemble+0x1f07>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1970 <Disassemble+0x830>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,%ecx
mov    %rcx,-0xa8(%rbp)
sub    $0x3,%eax
ja     196b <Disassemble+0x82b>
mov    -0xa8(%rbp),%rax
lea    0x2b11(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2c48(%rip),%rsi
call   1030 <strcpy@plt>
jmp    196b <Disassemble+0x82b>
mov    -0x18(%rbp),%rdi
lea    0x2c37(%rip),%rsi
call   1030 <strcpy@plt>
jmp    196b <Disassemble+0x82b>
mov    -0x18(%rbp),%rdi
lea    0x2c26(%rip),%rsi
call   1030 <strcpy@plt>
jmp    196b <Disassemble+0x82b>
mov    -0x18(%rbp),%rdi
lea    0x2c19(%rip),%rsi
call   1030 <strcpy@plt>
jmp    19c8 <Disassemble+0x888>
mov    -0x18(%rbp),%rdi
lea    0x2c0e(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    19a5 <Disassemble+0x865>
mov    -0x18(%rbp),%rdi
lea    0x2bf3(%rip),%rsi
call   1050 <strcat@plt>
jmp    19c3 <Disassemble+0x883>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x46d6(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    19c8 <Disassemble+0x888>
jmp    3047 <Disassemble+0x1f07>
mov    -0x18(%rbp),%rdi
lea    0x2bb9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x46c2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2bfb(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2ab4(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3047 <Disassemble+0x1f07>
movzbl -0x1e(%rbp),%eax
mov    %rax,-0xb0(%rbp)
sub    $0x7,%rax
ja     1db1 <Disassemble+0xc71>
mov    -0xb0(%rbp),%rax
lea    0x298d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2b06(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2a2b(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1db1 <Disassemble+0xc71>
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     1b6b <Disassemble+0xa2b>
jmp    1b2b <Disassemble+0x9eb>
mov    -0xb4(%rbp),%eax
sub    $0x40,%eax
je     1bb4 <Disassemble+0xa74>
jmp    1b3f <Disassemble+0x9ff>
mov    -0xb4(%rbp),%eax
sub    $0x80,%eax
je     1c0a <Disassemble+0xaca>
jmp    1b55 <Disassemble+0xa15>
mov    -0xb4(%rbp),%eax
sub    $0xc0,%eax
je     1c60 <Disassemble+0xb20>
jmp    1cb1 <Disassemble+0xb71>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x45f4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x2a6e(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x44aa(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1cb1 <Disassemble+0xb71>
mov    -0x18(%rbp),%rdi
lea    0x29f1(%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    0x2a17(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x4454(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1cb1 <Disassemble+0xb71>
mov    -0x18(%rbp),%rdi
lea    0x29a0(%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    0x29c1(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x43fe(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1cb1 <Disassemble+0xb71>
mov    -0x18(%rbp),%rdi
lea    0x294f(%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    0x296b(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x43a8(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1db1 <Disassemble+0xc71>
mov    -0x18(%rbp),%rdi
lea    0x28fe(%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),%edx
lea    0x27f3(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x27fb(%rip),%rsi
call   1050 <strcat@plt>
jmp    1db1 <Disassemble+0xc71>
mov    -0x18(%rbp),%rdi
lea    0x28ae(%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),%edx
lea    0x279d(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x289c(%rip),%rsi
call   1050 <strcat@plt>
jmp    1db1 <Disassemble+0xc71>
mov    -0x18(%rbp),%rdi
lea    0x2860(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1db1 <Disassemble+0xc71>
mov    -0x18(%rbp),%rdi
lea    0x2857(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1db1 <Disassemble+0xc71>
mov    -0x18(%rbp),%rdi
lea    0x28b6(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1db1 <Disassemble+0xc71>
mov    -0x18(%rbp),%rdi
lea    0x2837(%rip),%rsi
call   1030 <strcpy@plt>
jmp    3047 <Disassemble+0x1f07>
mov    -0x18(%rbp),%rdi
lea    0x2825(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x42d9(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2812(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x26cb(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3047 <Disassemble+0x1f07>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2f4f <Disassemble+0x1e0f>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,-0xb8(%rbp)
test   %eax,%eax
je     1e7a <Disassemble+0xd3a>
jmp    1e66 <Disassemble+0xd26>
mov    -0xb8(%rbp),%eax
sub    $0x2,%eax
je     1ed7 <Disassemble+0xd97>
jmp    22c3 <Disassemble+0x1183>
mov    -0x18(%rbp),%rdi
lea    0x2761(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2631(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f4a <Disassemble+0x1e0a>
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     1f38 <Disassemble+0xdf8>
jmp    1f22 <Disassemble+0xde2>
mov    -0xbc(%rbp),%eax
sub    $0x80,%eax
je     22a0 <Disassemble+0x1160>
jmp    22be <Disassemble+0x117e>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xc8(%rbp)
sub    $0x7,%rax
ja     229b <Disassemble+0x115b>
mov    -0xc8(%rbp),%rax
lea    0x20c5(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x267d(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
cmp    $0x6,%eax
je     1fa0 <Disassemble+0xe60>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x40be(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1fb0 <Disassemble+0xe70>
mov    -0x18(%rbp),%rdi
lea    0x25e4(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2635(%rip),%rsi
call   1050 <strcat@plt>
jmp    229b <Disassemble+0x115b>
mov    -0x18(%rbp),%rdi
lea    0x2626(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
cmp    $0x6,%eax
je     2001 <Disassemble+0xec1>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x405d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2011 <Disassemble+0xed1>
mov    -0x18(%rbp),%rdi
lea    0x25f4(%rip),%rsi
call   1050 <strcat@plt>
jmp    229b <Disassemble+0x115b>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     203b <Disassemble+0xefb>
mov    -0x18(%rbp),%rdi
lea    0x25d1(%rip),%rsi
call   1030 <strcpy@plt>
jmp    204b <Disassemble+0xf0b>
mov    -0x18(%rbp),%rdi
lea    0x25c0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x248f(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x4020(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    229b <Disassemble+0x115b>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2129 <Disassemble+0xfe9>
mov    -0x18(%rbp),%rdi
lea    0x2452(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3fdd(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x260e(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x23ef(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x24d5(%rip),%rsi
call   1050 <strcat@plt>
jmp    21af <Disassemble+0x106f>
mov    -0x18(%rbp),%rdi
lea    0x23ef(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2382(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2470(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3eea(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    229b <Disassemble+0x115b>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3feb(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    229b <Disassemble+0x115b>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x400c(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    229b <Disassemble+0x115b>
mov    -0x18(%rbp),%rdi
lea    0x241f(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1d(%rbp),%eax
mov    %eax,-0xcc(%rbp)
sub    $0x46,%eax
je     2242 <Disassemble+0x1102>
jmp    221a <Disassemble+0x10da>
mov    -0xcc(%rbp),%eax
sub    $0x56,%eax
je     2257 <Disassemble+0x1117>
jmp    222e <Disassemble+0x10ee>
mov    -0xcc(%rbp),%eax
sub    $0x5e,%eax
je     226c <Disassemble+0x112c>
jmp    227c <Disassemble+0x113c>
mov    -0x18(%rbp),%rdi
lea    0x23b3(%rip),%rsi
call   1050 <strcat@plt>
jmp    227c <Disassemble+0x113c>
mov    -0x18(%rbp),%rdi
lea    0x23be(%rip),%rsi
call   1050 <strcat@plt>
jmp    227c <Disassemble+0x113c>
mov    -0x18(%rbp),%rdi
lea    0x23ab(%rip),%rsi
call   1050 <strcat@plt>
jmp    229b <Disassemble+0x115b>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3f9e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    22be <Disassemble+0x117e>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x1f,%eax
movslq %eax,%rcx
lea    0x3fbb(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2f4a <Disassemble+0x1e0a>
movzbl -0x1d(%rbp),%eax
mov    %al,%cl
lea    0x23c6(%rip),%rax
lea    0x23c2(%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,-0xd8(%rbp)
sub    $0xf0,%eax
ja     2f45 <Disassemble+0x1e05>
mov    -0xd8(%rbp),%rax
lea    0x1d13(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x235b(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2343(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x2329(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2316(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x2146(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x223b(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x20f4(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x2104(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x2097(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2185(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x20a5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x21e1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2125(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1ff1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x21be(%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),%edx
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    %eax,%edx
lea    0x1f9f(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2085(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1fb5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x2105(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x20ee(%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),%edx
lea    0x1ef1(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1ff0(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x209a(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x207b(%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),%edx
lea    0x1e7e(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f7d(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1e97(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2008(%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),%edx
lea    0x1e0b(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f12(%rip),%rsi
call   1050 <strcat@plt>
lea    -0x70(%rbp),%rdi
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
lea    0x1dca(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1f6c(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f6c(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1d89(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
sar    $0x3,%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x38d1(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f42(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f01(%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),%edx
lea    0x1d04(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1e03(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1d1d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1e8e(%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),%edx
lea    0x1c91(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1d98(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x37d2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1c9a(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1dfd(%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),%edx
lea    0x1c00(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1cff(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1db4(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1d8a(%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),%edx
lea    0x1b8d(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1c8c(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1d4a(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1d17(%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),%edx
lea    0x1b1a(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1c19(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1ce0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1ca4(%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),%edx
lea    0x1aa7(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1ba6(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1c76(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1c31(%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),%edx
lea    0x1a34(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1b33(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1c0c(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1bbe(%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),%edx
lea    0x19c1(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1ac0(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1ba2(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1b4b(%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),%edx
lea    0x194e(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1a4d(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1b30(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1ad8(%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),%edx
lea    0x18db(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x19da(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1ac5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1a65(%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),%edx
lea    0x1868(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1967(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x18e7(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1a38(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1a20(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x1a04(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x18cf(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
mov    -0x18(%rbp),%rdi
lea    0x19d7(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f45 <Disassemble+0x1e05>
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,-0xdc(%rbp)
je     2dcb <Disassemble+0x1c8b>
jmp    2d8b <Disassemble+0x1c4b>
mov    -0xdc(%rbp),%eax
sub    $0x40,%eax
je     2dea <Disassemble+0x1caa>
jmp    2d9f <Disassemble+0x1c5f>
mov    -0xdc(%rbp),%eax
sub    $0x80,%eax
je     2e26 <Disassemble+0x1ce6>
jmp    2db5 <Disassemble+0x1c75>
mov    -0xdc(%rbp),%eax
sub    $0xc0,%eax
je     2e62 <Disassemble+0x1d22>
jmp    2e99 <Disassemble+0x1d59>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3594(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2e99 <Disassemble+0x1d59>
mov    -0x18(%rbp),%rdi
lea    0x17bb(%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    0x17e1(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e99 <Disassemble+0x1d59>
mov    -0x18(%rbp),%rdi
lea    0x1784(%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    0x17a5(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e99 <Disassemble+0x1d59>
mov    -0x18(%rbp),%rdi
lea    0x174d(%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    0x1769(%rip),%rsi
call   1050 <strcat@plt>
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
cmp    $0x6,%eax
je     2ed7 <Disassemble+0x1d97>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x3192(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x172b(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x17f5(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x17b2(%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),%edx
lea    0x15b5(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x16b4(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f4a <Disassemble+0x1e0a>
jmp    2fbc <Disassemble+0x1e7c>
mov    -0x18(%rbp),%rdi
lea    0x17ac(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0xe8(%rbp)
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    2f8d <Disassemble+0x1e4d>
lea    0x160d(%rip),%rax
mov    %rax,-0xf0(%rbp)
jmp    2fa9 <Disassemble+0x1e69>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x30f2(%rip),%rax
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3047 <Disassemble+0x1f07>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x311e(%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
movzbl (%rax,%rcx,1),%edx
lea    0x14de(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3047 <Disassemble+0x1f07>
mov    -0x18(%rbp),%rdi
lea    0x171f(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzbl -0x1d(%rbp),%edx
and    $0x38,%edx
lea    0x14a3(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    304c <Disassemble+0x1f0c>
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,%r13
mov    %edi,%r12d
movzbl (%rsi),%r14d
mov    %r14d,%ebx
shr    $0x3,%ebx
and    $0x7,%ebx
mov    %r14d,%ebp
and    $0x7,%ebp
xor    %edi,%edi
xor    %eax,%eax
call   1050 <OpcodeLen@plt>
mov    %eax,%edi
mov    %r14,%rax
shr    $0x6,%rax
lea    0x1e6d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    %ebp,%eax
lea    0x22df(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
cmp    $0x3,%ebx
ja     1581 <Disassemble+0x431>
mov    %ebx,%eax
lea    0x2304(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x706f6e,(%r15)
jmp    14ae <Disassemble+0x35e>
cmp    $0x76,%r14b
jne    1247 <Disassemble+0xf7>
movb   $0x0,0x4(%r15)
movl   $0x746c6168,(%r15)
jmp    14ae <Disassemble+0x35e>
movzbl %bl,%eax
lea    0x3bea(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %bpl,%eax
lea    0x3b31(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
jmp    1315 <Disassemble+0x1c5>
movzbl %bpl,%eax
lea    0x1ded(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movb   $0x0,0x4(%r15)
movl   $0x20746572,(%r15)
movzbl %bl,%eax
lea    0x3b5e(%rip),%rcx
jmp    130f <Disassemble+0x1bf>
movl   $0x20646c,(%r15)
movzbl %bl,%eax
lea    0x3ae8(%rip),%r14
mov    (%r14,%rax,8),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
mov    (%r14,%rbp,8),%rsi
jmp    1315 <Disassemble+0x1c5>
mov    %edi,%ebp
test   $0x8,%r14b
jne    14e5 <Disassemble+0x395>
movl   $0x20646c,(%r15)
shr    %bl
movzbl %bl,%eax
lea    0x3add(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
jmp    1406 <Disassemble+0x2b6>
movzbl %bl,%eax
lea    0x21ee(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movabs $0x2c2963622820646c,%rax
63 29 2c
jmp    1781 <Disassemble+0x631>
mov    %edi,%ebp
test   $0x8,%r14b
jne    14f9 <Disassemble+0x3a9>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1505 <Disassemble+0x3b5>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1305 <Disassemble+0x1b5>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
movzbl %bl,%eax
lea    0x3a31(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %ebx,%edi
jmp    14ae <Disassemble+0x35e>
movl   $0x20646c,(%r15)
movzbl %bl,%eax
lea    0x3a0b(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
jmp    1481 <Disassemble+0x331>
movzbl %bl,%eax
lea    0x216d(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    %ebx,%edi
jmp    14ae <Disassemble+0x35e>
movzbl %bl,%eax
test   $0x1,%bl
jne    151a <Disassemble+0x3ca>
mov    %edi,%ebx
movb   $0x0,0x4(%r15)
movl   $0x20706f70,(%r15)
shr    %eax
cmp    $0x3,%eax
jne    156f <Disassemble+0x41f>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x6661,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
mov    %ebx,%edi
jmp    14ae <Disassemble+0x35e>
movl   $0x20706a,(%r15)
jmp    13f6 <Disassemble+0x2a6>
movzbl %bl,%eax
lea    0x2071(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x20706a,(%r15)
jmp    1559 <Disassemble+0x409>
movw   $0x20,0x4(%r15)
movl   $0x6c6c6163,(%r15)
movzbl %bl,%eax
lea    0x39a0(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x2244(%rip),%rsi
jmp    1492 <Disassemble+0x342>
movzbl %bl,%eax
test   $0x1,%bl
jne    1538 <Disassemble+0x3e8>
movw   $0x20,0x4(%r15)
movl   $0x68737570,(%r15)
shr    %eax
mov    %edi,%ebx
cmp    $0x3,%eax
jne    1573 <Disassemble+0x423>
lea    0x229b(%rip),%rsi
jmp    1315 <Disassemble+0x1c5>
movzbl %bl,%eax
lea    0x396d(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
lea    0x21d5(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %ebp,%edi
mov    %edi,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movb   $0x0,0x4(%r15)
movl   $0x20747372,(%r15)
and    $0x38,%r14d
lea    0x2191(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
mov    %rbx,%rdi
mov    %r14d,%edx
jmp    149a <Disassemble+0x34a>
movabs $0x202c6c6820646461,%rax
6c 2c 20
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    1505 <Disassemble+0x3b5>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
shr    %bl
movzbl %bl,%eax
lea    0x386f(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
jmp    14a7 <Disassemble+0x357>
shr    %eax
lea    0x1f51(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x746572,(%r15)
jmp    14ae <Disassemble+0x35e>
shr    %eax
cmp    $0x2,%eax
je     1624 <Disassemble+0x4d4>
test   %eax,%eax
jne    168c <Disassemble+0x53c>
movw   $0x20,0x4(%r15)
movl   $0x6c6c6163,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x210e(%rip),%rsi
jmp    1618 <Disassemble+0x4c8>
mov    %eax,%eax
jmp    1575 <Disassemble+0x425>
mov    %eax,%eax
lea    0x3804(%rip),%rcx
jmp    120f <Disassemble+0xbf>
movl   $0x20726a,(%r15)
and    $0x3,%ebx
lea    0x380e(%rip),%rax
mov    (%rax,%rbx,8),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%eax
add    %r12d,%eax
add    $0x2,%eax
movzbl %al,%edx
jmp    148b <Disassemble+0x33b>
movabs $0x61202c6661207865,%rax
2c 20 61
mov    %rax,(%r15)
movl   $0x276661,0x7(%r15)
jmp    14ae <Disassemble+0x35e>
movw   $0x20,0x4(%r15)
movl   $0x7a6e6a64,(%r15)
jmp    15fe <Disassemble+0x4ae>
movl   $0x20726a,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%eax
add    %r12d,%eax
add    $0x2,%eax
movzbl %al,%edx
lea    0x204f(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
jmp    1497 <Disassemble+0x347>
add    $0x1,%r12d
movzwl %r12w,%eax
movzbl 0x0(%r13,%rax,1),%eax
mov    %eax,%ecx
and    $0xc0,%cl
cmp    $0x80,%cl
je     19f6 <Disassemble+0x8a6>
cmp    $0x40,%cl
jne    14ae <Disassemble+0x35e>
mov    %eax,%ecx
shr    $0x3,%ecx
and    $0x7,%ecx
mov    %eax,%edx
and    $0x7,%edx
lea    0x19d3(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
mov    %edi,%ebx
movl   $0x206e69,(%r15)
cmp    $0x6,%cl
jne    1fd4 <Disassemble+0xe84>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x66,(%r15,%rax,1)
jmp    1fe7 <Disassemble+0xe97>
test   $0x20,%r14b
lea    0x2151(%rip),%rax
lea    0x2147(%rip),%rcx
cmove  %rax,%rcx
mov    0x2(%rcx),%al
mov    %al,0xe(%rsp)
movzwl (%rcx),%eax
mov    %ax,0xc(%rsp)
add    $0x1,%r12d
movzwl %r12w,%ebx
movzbl 0x0(%r13,%rbx,1),%ebp
lea    0x7a(%rbp),%eax
cmp    $0xf8,%al
ja     14ae <Disassemble+0x35e>
movzbl %al,%eax
lea    0x197c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%r14d
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x2b,(%r15,%rax,1)
movzbl 0x1(%rbx,%r13,1),%edx
lea    0x1f52(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x202c29,(%r15,%rax,1)
and    $0x7,%ebp
lea    0x35f7(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r14d,%edi
jmp    14ae <Disassemble+0x35e>
movabs $0x6228202c6120646c,%rax
20 28 62
mov    %rax,(%r15)
movl   $0x296362,0x7(%r15)
jmp    14ae <Disassemble+0x35e>
movabs $0x2c2965642820646c,%rax
65 29 2c
mov    %rax,(%r15)
movl   $0x61202c,0x7(%r15)
jmp    14ae <Disassemble+0x35e>
movabs $0x6428202c6120646c,%rax
20 28 64
mov    %rax,(%r15)
movl   $0x296564,0x7(%r15)
jmp    14ae <Disassemble+0x35e>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1eb0(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebp,%edi
movl   $0x68202c29,(%r15,%rax,1)
68
movw   $0x6c,0x4(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movabs $0x28202c6c6820646c,%rax
2c 20 28
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    1846 <Disassemble+0x6f6>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1e44(%rip),%rsi
jmp    18ea <Disassemble+0x79a>
movabs $0x28202c6120646c,%rax
mov    %rax,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1e21(%rip),%rsi
jmp    1947 <Disassemble+0x7f7>
mov    %edi,%ebp
add    $0x1,%r12d
movzwl %r12w,%eax
movzbl 0x0(%r13,%rax,1),%ebx
movzbl %bl,%ecx
mov    %ebx,%eax
shr    $0x3,%eax
and    $0x7,%eax
and    $0x7,%ebx
movb   $0x0,0x11(%rsp)
shr    $0x6,%rcx
lea    0x1bda(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
lea    0x1c5a(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x20,(%r15,%rax,1)
lea    0x3481(%rip),%rax
mov    (%rax,%rbx,8),%rsi
mov    %r15,%rdi
jmp    14a7 <Disassemble+0x357>
movw   $0x28,0x4(%r15)
movl   $0x2074756f,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
lea    0x1d7d(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebp,%edi
movl   $0x61202c29,(%r15,%rax,1)
61
movb   $0x0,0x4(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movabs $0x28202c6120646c,%rax
add    $0x9fd,%rax
mov    %rax,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
lea    0x1d20(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebp,%edi
movw   $0x29,(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movabs $0x2c29707328207865,%rax
70 29 2c
mov    %rax,(%r15)
movl   $0x6c6820,0x8(%r15)
jmp    14ae <Disassemble+0x35e>
movabs $0x68202c6564207865,%rax
2c 20 68
jmp    19e7 <Disassemble+0x897>
movb   $0x0,0x2(%r15)
movw   $0x6964,(%r15)
jmp    14ae <Disassemble+0x35e>
movb   $0x0,0x2(%r15)
movw   $0x6965,(%r15)
jmp    14ae <Disassemble+0x35e>
movl   $0x787865,(%r15)
jmp    14ae <Disassemble+0x35e>
movabs $0x296c682820706a,%rax
mov    %rax,(%r15)
jmp    14ae <Disassemble+0x35e>
movabs $0x68202c707320646c,%rax
2c 20 68
mov    %rax,(%r15)
movw   $0x6c,0x8(%r15)
jmp    14ae <Disassemble+0x35e>
and    $0x1f,%eax
lea    0x1b74(%rip),%rcx
jmp    1367 <Disassemble+0x217>
movb   $0x0,0x4(%r15)
movl   $0x20746962,(%r15)
jmp    1a2d <Disassemble+0x8dd>
movb   $0x0,0x4(%r15)
movl   $0x20736572,(%r15)
jmp    1a2d <Disassemble+0x8dd>
movb   $0x0,0x4(%r15)
movl   $0x20746573,(%r15)
add    $0x30,%eax
mov    %al,0x10(%rsp)
lea    0x10(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
movzbl %bl,%eax
lea    0x32e0(%rip),%rcx
jmp    1511 <Disassemble+0x3c1>
movl   $0x20646c,(%r15)
and    $0x38,%ebp
lea    0x32ca(%rip),%rax
mov    0x0(%rbp,%rax,1),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x28202c,(%r15,%rax,1)
lea    0xc(%rsp),%rsi
jmp    1f3b <Disassemble+0xdeb>
mov    %edi,%ebx
movabs $0x2c2963282074756f,%rax
63 29 2c
mov    %rax,(%r15)
movw   $0x20,0x8(%r15)
cmp    $0x6,%cl
jne    2006 <Disassemble+0xeb6>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x30,(%r15,%rax,1)
mov    %ebx,%edi
jmp    14ae <Disassemble+0x35e>
movzbl %cl,%ebx
test   $0x1,%cl
mov    $0x636273,%eax
mov    $0x636461,%ecx
cmove  %eax,%ecx
mov    %ecx,(%r15)
mov    %edi,%ebp
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x2c6c6820,(%r15,%rax,1)
2c
movw   $0x20,0x4(%r15,%rax,1)
and    $0x6,%ebx
lea    0x3272(%rip),%rax
mov    (%rax,%rbx,4),%rsi
mov    %r15,%rdi
jmp    14a7 <Disassemble+0x357>
mov    %edi,%r14d
movzbl %cl,%ebp
test   $0x1,%cl
jne    200e <Disassemble+0xebe>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1b32(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x202c29,(%r15,%rax,1)
shr    %ebp
lea    0x3207(%rip),%rax
jmp    1749 <Disassemble+0x5f9>
movzbl %cl,%eax
lea    0x198c(%rip),%rcx
jmp    1367 <Disassemble+0x217>
movzbl %cl,%eax
lea    0x199d(%rip),%rcx
jmp    1367 <Disassemble+0x217>
movl   $0x206d69,(%r15)
cmp    $0x5e,%al
je     2050 <Disassemble+0xf00>
cmp    $0x56,%al
je     2068 <Disassemble+0xf18>
cmp    $0x46,%al
jne    14ae <Disassemble+0x35e>
mov    %edi,%ebx
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movw   $0x30,(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movzbl %cl,%eax
lea    0x1977(%rip),%rcx
jmp    1367 <Disassemble+0x217>
movabs $0x28202c6120646461,%rax
2c 20 28
jmp    1c28 <Disassemble+0xad8>
movabs $0x28202c6120636461,%rax
2c 20 28
jmp    1c28 <Disassemble+0xad8>
movabs $0x28202c6120627573,%rax
2c 20 28
jmp    1c28 <Disassemble+0xad8>
movabs $0x28202c6120636273,%rax
2c 20 28
jmp    1c28 <Disassemble+0xad8>
movabs $0x28202c6120646e61,%rax
2c 20 28
jmp    1c28 <Disassemble+0xad8>
movabs $0x28202c6120726f78,%rax
2c 20 28
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    1f34 <Disassemble+0xde4>
movabs $0x28202c6120646c,%rax
add    $0xe03,%rax
jmp    1f31 <Disassemble+0xde1>
movabs $0x28202c6120646c,%rax
add    $0xbf7,%rax
jmp    1f31 <Disassemble+0xde1>
mov    %edi,%r14d
movzbl 0x2(%rbx,%r13,1),%eax
movzbl %al,%ebp
shr    $0x3,%eax
and    $0x7,%eax
movb   $0x0,0x11(%rsp)
mov    %rbp,%rcx
shr    $0x6,%rcx
lea    0x17b0(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
lea    0x1960(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
jmp    20d1 <Disassemble+0xf81>
movb   $0x0,0x4(%r15)
movl   $0x20706f70,(%r15)
jmp    1e3c <Disassemble+0xcec>
movabs $0x2c29707328207865,%rax
70 29 2c
mov    %rax,(%r15)
movw   $0x20,0x8(%r15)
jmp    1e3c <Disassemble+0xcec>
movw   $0x20,0x4(%r15)
movl   $0x68737570,(%r15)
jmp    1e3c <Disassemble+0xcec>
movb   $0x0,0x4(%r15)
movl   $0x2820706a,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movw   $0x29,(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movabs $0x202c707320646c,%rax
mov    %rax,(%r15)
jmp    1e3c <Disassemble+0xcec>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movl   $0x6362202c,(%r15,%rax,1)
63
movb   $0x0,0x4(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movl   $0x6564202c,(%r15,%rax,1)
65
movb   $0x0,0x4(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl 0x1(%rbx,%r13,1),%edx
lea    0x18c7(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x202c29,(%r15,%rax,1)
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
jmp    14a7 <Disassemble+0x357>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1e3c <Disassemble+0xcec>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
lea    0xc(%rsp),%rbx
mov    %edi,%ebp
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
jmp    14a1 <Disassemble+0x351>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
lea    0xc(%rsp),%rsi
jmp    1313 <Disassemble+0x1c3>
movw   $0x28,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1f34 <Disassemble+0xde4>
movw   $0x28,0x4(%r15)
movl   $0x20636564,(%r15)
jmp    1f34 <Disassemble+0xde4>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%r14d
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x2b,(%r15,%rax,1)
movzbl 0x1(%rbx,%r13,1),%edx
lea    0x17c3(%rip),%r12
lea    0x10(%rsp),%rbp
mov    %rbp,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x202c29,(%r15,%rax,1)
movzbl 0x2(%rbx,%r13,1),%edx
mov    %rbp,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
jmp    1750 <Disassemble+0x600>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movl   $0x7073202c,(%r15,%rax,1)
70
movb   $0x0,0x4(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movabs $0x28202c6120646c,%rax
mov    %rax,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x2b,(%r15,%rax,1)
movzbl 0x1(%rbx,%r13,1),%edx
lea    0x1708(%rip),%rsi
lea    0x10(%rsp),%rbx
jmp    194e <Disassemble+0x7fe>
movl   $0x20646c,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
movzwl 0x1(%rbx,%r13,1),%edx
jmp    142d <Disassemble+0x2dd>
movl   $0x20646c,(%r15)
lea    0xc(%rsp),%rsi
mov    %edi,%ebp
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x28202c,(%r15,%rax,1)
movzwl 0x1(%rbx,%r13,1),%edx
lea    0x16a6(%rip),%rsi
jmp    1f5f <Disassemble+0xe0f>
lea    0x2d65(%rip),%rax
mov    (%rax,%rcx,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x6328202c,(%r15,%rax,1)
63
movw   $0x29,0x4(%r15,%rax,1)
mov    %ebx,%edi
jmp    14ae <Disassemble+0x35e>
movzbl %cl,%eax
jmp    1208 <Disassemble+0xb8>
movl   $0x20646c,(%r15)
shr    %ebp
lea    0x2d62(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movl   $0x28202c,(%r15,%rax,1)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x162d(%rip),%rsi
jmp    2139 <Disassemble+0xfe9>
mov    %edi,%ebx
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movw   $0x32,(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
mov    %edi,%ebx
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movw   $0x31,(%r15,%rax,1)
jmp    14ae <Disassemble+0x35e>
movb   $0x0,0x4(%r15)
movl   $0x20746962,(%r15)
jmp    20a8 <Disassemble+0xf58>
movb   $0x0,0x4(%r15)
movl   $0x20736572,(%r15)
jmp    20a8 <Disassemble+0xf58>
movb   $0x0,0x4(%r15)
movl   $0x20746573,(%r15)
add    $0x30,%eax
mov    %al,0x10(%rsp)
lea    0x10(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
and    $0x7,%ebp
cmp    $0x6,%ebp
je     2101 <Disassemble+0xfb1>
lea    0x2c60(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x202c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x28,(%r15,%rax,1)
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x2b,(%r15,%rax,1)
movzbl 0x1(%rbx,%r13,1),%edx
lea    0x152e(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
xor    %eax,%eax
call   1070 <sprintf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x29,(%r15,%rax,1)
mov    %r14d,%edi
jmp    14ae <Disassemble+0x35e>

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

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 ([8 x i8], [8 x i8]* @.str.19, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.20, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.23, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.24, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.25, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.26, i32 0, i32 0)]
@.str.19 = [8 x i8] c"add a, \00"
@.str.20 = [8 x i8] c"adc a, \00"
@.str.21 = [5 x i8] c"sub \00"
@.str.22 = [8 x i8] c"sbc a, \00"
@.str.23 = [5 x i8] c"and \00"
@.str.24 = [5 x i8] c"xor \00"
@.str.25 = [4 x i8] c"or \00"
@.str.26 = [4 x i8] c"cp \00"
@.str.28 = [11 x i8] c"ex af, af'\00"
@.str.29 = [6 x i8] c"djnz \00"
@.str.30 = [8 x i8] c"0x%2.2X\00"
@.str.32 = [3 x i8] c", \00"
@.str.33 = [9 x i8] c"add hl, \00"
@.str.35 = [8 x i8] c"0x%4.4X\00"
@.str.36 = [11 x i8] c"ld (bc), a\00"
@.str.37 = [11 x i8] c"ld a, (bc)\00"
@.str.38 = [11 x i8] c"ld (de), a\00"
@.str.39 = [11 x i8] c"ld a, (de)\00"
@.str.40 = [5 x i8] c"ld (\00"
@.str.41 = [6 x i8] c"), hl\00"
@.str.42 = [9 x i8] c"ld hl, (\00"
@.str.44 = [5 x i8] c"), a\00"
@.str.46 = [5 x i8] c"dec \00"
@.str.47 = [5 x i8] c"inc \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"rlca\00"
@.str.49 = [5 x i8] c"rrca\00"
@.str.50 = [4 x i8] c"rla\00"
@.str.51 = [4 x i8] c"rra\00"
@.str.52 = [4 x i8] c"daa\00"
@.str.53 = [4 x i8] c"cpl\00"
@.str.54 = [4 x i8] c"scf\00"
@.str.55 = [4 x i8] c"ccf\00"
@.str.56 = [5 x i8] c"halt\00"
@.str.57 = [5 x i8] c"ret \00"
@.str.61 = [10 x i8] c"ld sp, hl\00"
@.str.62 = [5 x i8] c"pop \00"
@.str.63 = [3 x i8] c"af\00"
@reltable.Disassemble.160 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.66 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.67 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.68 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([3 x i8]* @.str.69 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.70 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.71 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.72 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.73 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.160 to i64)) to i32)]
@.str.66 = [4 x i8] c"rlc\00"
@.str.67 = [4 x i8] c"rrc\00"
@.str.68 = [3 x i8] c"rl\00"
@.str.69 = [3 x i8] c"rr\00"
@.str.70 = [4 x i8] c"sla\00"
@.str.71 = [4 x i8] c"sra\00"
@.str.72 = [4 x i8] c"sll\00"
@.str.73 = [4 x i8] c"srl\00"
@.str.75 = [5 x i8] c"bit \00"
@.str.76 = [5 x i8] c"res \00"
@.str.77 = [5 x i8] c"set \00"
@.str.78 = [6 x i8] c"out (\00"
@.str.80 = [12 x i8] c"ex (sp), hl\00"
@.str.81 = [10 x i8] c"ex de, hl\00"
@.str.82 = [3 x i8] c"di\00"
@.str.83 = [3 x i8] c"ei\00"
@.str.84 = [6 x i8] c"call \00"
@.str.87 = [6 x i8] c", (c)\00"
@.str.88 = [10 x i8] c"out (c), \00"
@.str.92 = [6 x i8] c" hl, \00"
@reltable.Disassemble.161 = 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.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.161 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.161 to i64)) to i32)]
@.str.96 = [4 x i8] c"neg\00"
@.str.97 = [4 x i8] c"???\00"
@reltable.Disassemble.162 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.99 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.100 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.162 to i64)) to i32)]
@.str.99 = [5 x i8] c"retn\00"
@.str.100 = [5 x i8] c"reti\00"
@reltable.Disassemble.163 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @.str.105 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @.str.106 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @.str.107 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([8 x i8]* @.str.108 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.109 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.110 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.163 to i64)) to i32)]
@.str.105 = [8 x i8] c"ld i, a\00"
@.str.106 = [8 x i8] c"ld r, a\00"
@.str.107 = [8 x i8] c"ld a, i\00"
@.str.108 = [8 x i8] c"ld a, r\00"
@.str.109 = [4 x i8] c"rrd\00"
@.str.110 = [4 x i8] c"rld\00"
@reltable.Disassemble.164 = internal unnamed_addr constant [32 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.112 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.113 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.114 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.115 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.116 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.117 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.118 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.119 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.120 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.121 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.122 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.123 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.124 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.125 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.126 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.127 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.97 to i64), i64 ptrtoint ([32 x i32]* @reltable.Disassemble.164 to i64)) to i32)]
@.str.112 = [4 x i8] c"ldi\00"
@.str.113 = [4 x i8] c"cpi\00"
@.str.114 = [4 x i8] c"ini\00"
@.str.115 = [5 x i8] c"outi\00"
@.str.116 = [4 x i8] c"ldd\00"
@.str.117 = [4 x i8] c"cpd\00"
@.str.118 = [4 x i8] c"ind\00"
@.str.119 = [5 x i8] c"outd\00"
@.str.120 = [5 x i8] c"ldir\00"
@.str.121 = [5 x i8] c"cpir\00"
@.str.122 = [5 x i8] c"inir\00"
@.str.123 = [5 x i8] c"otir\00"
@.str.124 = [5 x i8] c"lddr\00"
@.str.125 = [5 x i8] c"cpdr\00"
@.str.126 = [5 x i8] c"indr\00"
@.str.127 = [5 x i8] c"otdr\00"
@.str.128 = [3 x i8] c"iy\00"
@.str.129 = [3 x i8] c"ix\00"
@.str.130 = [5 x i8] c"add \00"
@.str.131 = [5 x i8] c", bc\00"
@.str.132 = [5 x i8] c", de\00"
@.str.133 = [6 x i8] c"inc (\00"
@.str.135 = [6 x i8] c"dec (\00"
@.str.136 = [5 x i8] c", sp\00"
@.str.137 = [9 x i8] c"add a, (\00"
@.str.138 = [9 x i8] c"adc a, (\00"
@.str.139 = [9 x i8] c"sub a, (\00"
@.str.140 = [9 x i8] c"sbc a, (\00"
@.str.141 = [9 x i8] c"and a, (\00"
@.str.142 = [9 x i8] c"xor a, (\00"
@.str.145 = [10 x i8] c"ex (sp), \00"
@.str.146 = [6 x i8] c"push \00"
@.str.147 = [5 x i8] c"jp (\00"
@reltable.Disassemble.165 = internal unnamed_addr constant [8 x i32] [i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.150 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.151 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.152 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([4 x i8]* @.str.153 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.154 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.155 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.156 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32), i32 trunc (i64 sub (i64 ptrtoint ([5 x i8]* @.str.157 to i64), i64 ptrtoint ([8 x i32]* @reltable.Disassemble.165 to i64)) to i32)]
@.str.150 = [5 x i8] c"rlc \00"
@.str.151 = [5 x i8] c"rrc \00"
@.str.152 = [4 x i8] c"rl \00"
@.str.153 = [4 x i8] c"rr \00"
@.str.154 = [5 x i8] c"sla \00"
@.str.155 = [5 x i8] c"sra \00"
@.str.156 = [5 x i8] c"sll \00"
@.str.157 = [5 x i8] c"srl \00"
@.str.159 = [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 (i32, i8*, ...) bitcast (i32 (...)* @OpcodeLen to i32 (i32, i8*, ...)*)(i32 0, i8* %1)
%15 = lshr i32 %8, 6
switch i32 %15, label %999 [
i32 0, label %16
i32 1, label %223
i32 2, label %238
i32 3, label %247
]
16: ; preds = %4
%17 = zext i8 %11 to i32
switch i32 %17, label %1000 [
i32 0, label %18
i32 1, label %68
i32 2, label %101
i32 3, label %182
i32 4, label %193
i32 5, label %198
i32 6, label %203
i32 7, label %218
]
18: ; preds = %16
%19 = zext i8 %10 to i32
switch i32 %19, label %48 [
i32 0, label %20
i32 1, label %22
i32 2, label %23
i32 3, label %35
]
20: ; preds = %18
%21 = bitcast i8* %2 to i32*
store i32 7368558, i32* %21
br label %1006
22: ; preds = %18
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(11) %2, i8* align 1 dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.28, i64 0, i64 0), i64 11, i1 false)
br label %1006
23: ; preds = %18
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.29, i64 0, i64 0), i64 6, i1 false)
%24 = zext i16 %0 to i32
%25 = add nuw nsw i32 %24, 2
%26 = add nuw nsw i32 %24, 1
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %1, i64 %27
%29 = load i8, i8* %28
%30 = zext i8 %29 to i32
%31 = add nuw nsw i32 %25, %30
%32 = and i32 %31, 255
%33 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %32)
%34 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
35: ; preds = %18
%36 = bitcast i8* %2 to i32*
store i32 2126442, i32* %36
%37 = zext i16 %0 to i32
%38 = add nuw nsw i32 %37, 2
%39 = add nuw nsw i32 %37, 1
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %1, i64 %40
%42 = load i8, i8* %41
%43 = zext i8 %42 to i32
%44 = add nuw nsw i32 %38, %43
%45 = and i32 %44, 255
%46 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %45)
%47 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
48: ; preds = %18
%49 = bitcast i8* %2 to i32*
store i32 2126442, i32* %49
%50 = and i32 %19, 3
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.cond, i64 0, i64 %51
%53 = load i8*, i8** %52
%54 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %53)
%55 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%56 = getelementptr i8, i8* %2, i64 %55
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %56, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%57 = zext i16 %0 to i32
%58 = add nuw nsw i32 %57, 2
%59 = add nuw nsw i32 %57, 1
%60 = zext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %1, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i32
%64 = add nuw nsw i32 %58, %63
%65 = and i32 %64, 255
%66 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %65)
%67 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
68: ; preds = %16
%69 = and i32 %8, 8
%70 = icmp eq i32 %69, 0
br i1 %70, label %77, label %71
71: ; preds = %68
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.33, i64 0, i64 0), i64 9, i1 false)
%72 = lshr i8 %10, 1
%73 = zext i8 %72 to i64
%74 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %73
%75 = load i8*, i8** %74
%76 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %75)
br label %1006
77: ; preds = %68
%78 = bitcast i8* %2 to i32*
store i32 2122860, i32* %78
%79 = lshr i8 %10, 1
%80 = zext i8 %79 to i64
%81 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %80
%82 = load i8*, i8** %81
%83 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %82)
%84 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%85 = getelementptr i8, i8* %2, i64 %84
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %85, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%86 = zext i16 %0 to i32
%87 = add nuw nsw i32 %86, 1
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %1, i64 %88
%90 = load i8, i8* %89
%91 = zext i8 %90 to i32
%92 = add nuw nsw i32 %86, 2
%93 = zext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %1, i64 %93
%95 = load i8, i8* %94
%96 = zext i8 %95 to i32
%97 = shl nuw nsw i32 %96, 8
%98 = or i32 %97, %91
%99 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %98)
%100 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
101: ; preds = %16
%102 = zext i8 %10 to i32
switch i32 %102, label %1001 [
i32 0, label %103
i32 1, label %104
i32 2, label %105
i32 3, label %106
i32 4, label %107
i32 5, label %125
i32 6, label %144
i32 7, label %162
]
103: ; preds = %101
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(11) %2, i8* align 1 dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.36, i64 0, i64 0), i64 11, i1 false)
br label %1006
104: ; preds = %101
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(11) %2, i8* align 1 dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0), i64 11, i1 false)
br label %1006
105: ; preds = %101
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(11) %2, i8* align 1 dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.38, i64 0, i64 0), i64 11, i1 false)
br label %1006
106: ; preds = %101
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(11) %2, i8* align 1 dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.39, i64 0, i64 0), i64 11, i1 false)
br label %1006
107: ; preds = %101
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.40, i64 0, i64 0), i64 5, i1 false)
%108 = zext i16 %0 to i32
%109 = add nuw nsw i32 %108, 1
%110 = zext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %1, i64 %110
%112 = load i8, i8* %111
%113 = zext i8 %112 to i32
%114 = add nuw nsw i32 %108, 2
%115 = zext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %1, i64 %115
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = shl nuw nsw i32 %118, 8
%120 = or i32 %119, %113
%121 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %120)
%122 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%123 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%124 = getelementptr i8, i8* %2, i64 %123
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %124, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.41, i64 0, i64 0), i64 6, i1 false)
br label %1006
125: ; preds = %101
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.42, i64 0, i64 0), i64 9, i1 false)
%126 = zext i16 %0 to i32
%127 = add nuw nsw i32 %126, 1
%128 = zext i32 %127 to i64
%129 = getelementptr inbounds i8, i8* %1, i64 %128
%130 = load i8, i8* %129
%131 = zext i8 %130 to i32
%132 = add nuw nsw i32 %126, 2
%133 = zext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %1, i64 %133
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = shl nuw nsw i32 %136, 8
%138 = or i32 %137, %131
%139 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %138)
%140 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%141 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%142 = getelementptr i8, i8* %2, i64 %141
%143 = bitcast i8* %142 to i16*
store i16 41, i16* %143
br label %1006
144: ; preds = %101
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.40, i64 0, i64 0), i64 5, i1 false)
%145 = zext i16 %0 to i32
%146 = add nuw nsw i32 %145, 1
%147 = zext i32 %146 to i64
%148 = getelementptr inbounds i8, i8* %1, i64 %147
%149 = load i8, i8* %148
%150 = zext i8 %149 to i32
%151 = add nuw nsw i32 %145, 2
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds i8, i8* %1, i64 %152
%154 = load i8, i8* %153
%155 = zext i8 %154 to i32
%156 = shl nuw nsw i32 %155, 8
%157 = or i32 %156, %150
%158 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %157)
%159 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%160 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%161 = getelementptr i8, i8* %2, i64 %160
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %161, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.44, i64 0, i64 0), i64 5, i1 false)
br label %1006
162: ; preds = %101
%163 = bitcast i8* %2 to i64*
store i64 11294374048588908, i64* %163
%164 = zext i16 %0 to i32
%165 = add nuw nsw i32 %164, 1
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds i8, i8* %1, i64 %166
%168 = load i8, i8* %167
%169 = zext i8 %168 to i32
%170 = add nuw nsw i32 %164, 2
%171 = zext i32 %170 to i64
%172 = getelementptr inbounds i8, i8* %1, i64 %171
%173 = load i8, i8* %172
%174 = zext i8 %173 to i32
%175 = shl nuw nsw i32 %174, 8
%176 = or i32 %175, %169
%177 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %176)
%178 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%179 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%180 = getelementptr i8, i8* %2, i64 %179
%181 = bitcast i8* %180 to i16*
store i16 41, i16* %181
br label %1006
182: ; preds = %16
%183 = and i32 %8, 8
%184 = icmp eq i32 %183, 0
br i1 %184, label %186, label %185
185: ; preds = %182
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0), i64 5, i1 false)
br label %187
186: ; preds = %182
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.47, i64 0, i64 0), i64 5, i1 false)
br label %187
187: ; preds = %186, %185
%188 = lshr i8 %10, 1
%189 = zext i8 %188 to i64
%190 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %189
%191 = load i8*, i8** %190
%192 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %191)
br label %1006
193: ; preds = %16
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.47, i64 0, i64 0), i64 5, i1 false)
%194 = zext i8 %10 to i64
%195 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %194
%196 = load i8*, i8** %195
%197 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %196)
br label %1006
198: ; preds = %16
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0), i64 5, i1 false)
%199 = zext i8 %10 to i64
%200 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %199
%201 = load i8*, i8** %200
%202 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %201)
br label %1006
203: ; preds = %16
%204 = bitcast i8* %2 to i32*
store i32 2122860, i32* %204
%205 = zext i8 %10 to i64
%206 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %205
%207 = load i8*, i8** %206
%208 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %207)
%209 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%210 = getelementptr i8, i8* %2, i64 %209
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %210, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%211 = zext i16 %0 to i64
%212 = add nuw nsw i64 %211, 1
%213 = getelementptr inbounds i8, i8* %1, i64 %212
%214 = load i8, i8* %213
%215 = zext i8 %214 to i32
%216 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %215)
%217 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
218: ; preds = %16
%219 = zext i8 %10 to i64
%220 = shl i64 %219, 2
%221 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.Disassemble to i8*), i64 %220)
%222 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %221)
br label %1006
223: ; preds = %4
%224 = icmp eq i8 %7, 118
br i1 %224, label %225, label %226
225: ; preds = %223
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.56, i64 0, i64 0), i64 5, i1 false)
br label %1006
226: ; preds = %223
%227 = bitcast i8* %2 to i32*
store i32 2122860, i32* %227
%228 = zext i8 %10 to i64
%229 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %228
%230 = load i8*, i8** %229
%231 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %230)
%232 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%233 = getelementptr i8, i8* %2, i64 %232
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %233, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%234 = zext i8 %11 to i64
%235 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %234
%236 = load i8*, i8** %235
%237 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %236)
br label %1006
238: ; preds = %4
%239 = zext i8 %10 to i64
%240 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.arith, i64 0, i64 %239
%241 = load i8*, i8** %240
%242 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %241)
%243 = zext i8 %11 to i64
%244 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %243
%245 = load i8*, i8** %244
%246 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %245)
br label %1006
247: ; preds = %4
%248 = zext i8 %11 to i32
switch i32 %248, label %1002 [
i32 0, label %249
i32 1, label %254
i32 2, label %278
i32 3, label %301
i32 4, label %397
i32 5, label %419
i32 6, label %983
i32 7, label %995
]
249: ; preds = %247
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.57, i64 0, i64 0), i64 5, i1 false)
%250 = zext i8 %10 to i64
%251 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.cond, i64 0, i64 %250
%252 = load i8*, i8** %251
%253 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %252)
br label %1006
254: ; preds = %247
%255 = zext i8 %10 to i32
%256 = and i32 %255, 1
%257 = icmp eq i32 %256, 0
br i1 %257, label %267, label %258
258: ; preds = %254
%259 = lshr i32 %255, 1
switch i32 %259, label %1003 [
i32 0, label %260
i32 1, label %262
i32 2, label %264
i32 3, label %266
]
260: ; preds = %258
%261 = bitcast i8* %2 to i32*
store i32 7628146, i32* %261
br label %1006
262: ; preds = %258
%263 = bitcast i8* %2 to i32*
store i32 7895141, i32* %263
br label %1006
264: ; preds = %258
%265 = bitcast i8* %2 to i64*
store i64 11659668650750058, i64* %265
br label %1006
266: ; preds = %258
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(10) %2, i8* align 1 dereferenceable(10) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.61, i64 0, i64 0), i64 10, i1 false)
br label %1006
267: ; preds = %254
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.62, i64 0, i64 0), i64 5, i1 false)
%268 = lshr i32 %255, 1
%269 = icmp eq i32 %268, 3
br i1 %269, label %270, label %273
270: ; preds = %267
%271 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%272 = getelementptr i8, i8* %2, i64 %271
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %272, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.63, i64 0, i64 0), i64 3, i1 false)
br label %1006
273: ; preds = %267
%274 = zext i32 %268 to i64
%275 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %274
%276 = load i8*, i8** %275
%277 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %276)
br label %1006
278: ; preds = %247
%279 = bitcast i8* %2 to i32*
store i32 2125930, i32* %279
%280 = zext i8 %10 to i64
%281 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.cond, i64 0, i64 %280
%282 = load i8*, i8** %281
%283 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %282)
%284 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%285 = getelementptr i8, i8* %2, i64 %284
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %285, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%286 = zext i16 %0 to i32
%287 = add nuw nsw i32 %286, 1
%288 = zext i32 %287 to i64
%289 = getelementptr inbounds i8, i8* %1, i64 %288
%290 = load i8, i8* %289
%291 = zext i8 %290 to i32
%292 = add nuw nsw i32 %286, 2
%293 = zext i32 %292 to i64
%294 = getelementptr inbounds i8, i8* %1, i64 %293
%295 = load i8, i8* %294
%296 = zext i8 %295 to i32
%297 = shl nuw nsw i32 %296, 8
%298 = or i32 %297, %291
%299 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %298)
%300 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
301: ; preds = %247
%302 = zext i8 %10 to i32
switch i32 %302, label %1004 [
i32 0, label %303
i32 1, label %320
i32 2, label %371
i32 3, label %381
i32 4, label %393
i32 5, label %394
i32 6, label %395
i32 7, label %396
]
303: ; preds = %301
%304 = bitcast i8* %2 to i32*
store i32 2125930, i32* %304
%305 = zext i16 %0 to i32
%306 = add nuw nsw i32 %305, 1
%307 = zext i32 %306 to i64
%308 = getelementptr inbounds i8, i8* %1, i64 %307
%309 = load i8, i8* %308
%310 = zext i8 %309 to i32
%311 = add nuw nsw i32 %305, 2
%312 = zext i32 %311 to i64
%313 = getelementptr inbounds i8, i8* %1, i64 %312
%314 = load i8, i8* %313
%315 = zext i8 %314 to i32
%316 = shl nuw nsw i32 %315, 8
%317 = or i32 %316, %310
%318 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %317)
%319 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
320: ; preds = %301
%321 = add i16 %0, 1
%322 = zext i16 %321 to i64
%323 = getelementptr inbounds i8, i8* %1, i64 %322
%324 = load i8, i8* %323
%325 = lshr i8 %324, 3
%326 = and i8 %325, 7
%327 = and i8 %324, 7
%328 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 1
store i8 0, i8* %328
%329 = lshr i8 %324, 6
%330 = zext i8 %329 to i32
switch i32 %330, label %370 [
i32 0, label %331
i32 1, label %343
i32 2, label %352
i32 3, label %361
]
331: ; preds = %320
%332 = zext i8 %326 to i64
%333 = shl i64 %332, 2
%334 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.Disassemble.160 to i8*), i64 %333)
%335 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %334)
%336 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%337 = getelementptr i8, i8* %2, i64 %336
%338 = bitcast i8* %337 to i16*
store i16 32, i16* %338
%339 = zext i8 %327 to i64
%340 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %339
%341 = load i8*, i8** %340
%342 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %341)
br label %1006
343: ; preds = %320
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.75, i64 0, i64 0), i64 5, i1 false)
%344 = or i8 %326, 48
store i8 %344, i8* %12
%345 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%346 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%347 = getelementptr i8, i8* %2, i64 %346
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %347, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%348 = zext i8 %327 to i64
%349 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %348
%350 = load i8*, i8** %349
%351 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %350)
br label %1006
352: ; preds = %320
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.76, i64 0, i64 0), i64 5, i1 false)
%353 = or i8 %326, 48
store i8 %353, i8* %12
%354 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%355 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%356 = getelementptr i8, i8* %2, i64 %355
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %356, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%357 = zext i8 %327 to i64
%358 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %357
%359 = load i8*, i8** %358
%360 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %359)
br label %1006
361: ; preds = %320
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.77, i64 0, i64 0), i64 5, i1 false)
%362 = or i8 %326, 48
store i8 %362, i8* %12
%363 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%364 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%365 = getelementptr i8, i8* %2, i64 %364
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %365, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%366 = zext i8 %327 to i64
%367 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %366
%368 = load i8*, i8** %367
%369 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %368)
br label %1006
370: ; preds = %320
unreachable
371: ; preds = %301
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.78, i64 0, i64 0), i64 6, i1 false)
%372 = zext i16 %0 to i64
%373 = add nuw nsw i64 %372, 1
%374 = getelementptr inbounds i8, i8* %1, i64 %373
%375 = load i8, i8* %374
%376 = zext i8 %375 to i32
%377 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %376)
%378 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%379 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%380 = getelementptr i8, i8* %2, i64 %379
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %380, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.44, i64 0, i64 0), i64 5, i1 false)
br label %1006
381: ; preds = %301
%382 = bitcast i8* %2 to i64*
store i64 11294374048591465, i64* %382
%383 = zext i16 %0 to i64
%384 = add nuw nsw i64 %383, 1
%385 = getelementptr inbounds i8, i8* %1, i64 %384
%386 = load i8, i8* %385
%387 = zext i8 %386 to i32
%388 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %387)
%389 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%390 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%391 = getelementptr i8, i8* %2, i64 %390
%392 = bitcast i8* %391 to i16*
store i16 41, i16* %392
br label %1006
393: ; preds = %301
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(12) %2, i8* align 1 dereferenceable(12) getelementptr inbounds ([12 x i8], [12 x i8]* @.str.80, i64 0, i64 0), i64 12, i1 false)
br label %1006
394: ; preds = %301
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(10) %2, i8* align 1 dereferenceable(10) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.81, i64 0, i64 0), i64 10, i1 false)
br label %1006
395: ; preds = %301
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %2, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.82, i64 0, i64 0), i64 3, i1 false)
br label %1006
396: ; preds = %301
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %2, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.83, i64 0, i64 0), i64 3, i1 false)
br label %1006
397: ; preds = %247
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.84, i64 0, i64 0), i64 6, i1 false)
%398 = zext i8 %10 to i64
%399 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.cond, i64 0, i64 %398
%400 = load i8*, i8** %399
%401 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %400)
%402 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%403 = getelementptr i8, i8* %2, i64 %402
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %403, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%404 = zext i16 %0 to i32
%405 = add nuw nsw i32 %404, 1
%406 = zext i32 %405 to i64
%407 = getelementptr inbounds i8, i8* %1, i64 %406
%408 = load i8, i8* %407
%409 = zext i8 %408 to i32
%410 = add nuw nsw i32 %404, 2
%411 = zext i32 %410 to i64
%412 = getelementptr inbounds i8, i8* %1, i64 %411
%413 = load i8, i8* %412
%414 = zext i8 %413 to i32
%415 = shl nuw nsw i32 %414, 8
%416 = or i32 %415, %409
%417 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %416)
%418 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
419: ; preds = %247
%420 = zext i8 %10 to i32
%421 = and i32 %420, 1
%422 = icmp eq i32 %421, 0
br i1 %422, label %973, label %423
423: ; preds = %419
%424 = lshr i32 %420, 1
switch i32 %424, label %582 [
i32 0, label %425
i32 2, label %441
]
425: ; preds = %423
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.84, i64 0, i64 0), i64 6, i1 false)
%426 = zext i16 %0 to i32
%427 = add nuw nsw i32 %426, 1
%428 = zext i32 %427 to i64
%429 = getelementptr inbounds i8, i8* %1, i64 %428
%430 = load i8, i8* %429
%431 = zext i8 %430 to i32
%432 = add nuw nsw i32 %426, 2
%433 = zext i32 %432 to i64
%434 = getelementptr inbounds i8, i8* %1, i64 %433
%435 = load i8, i8* %434
%436 = zext i8 %435 to i32
%437 = shl nuw nsw i32 %436, 8
%438 = or i32 %437, %431
%439 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %438)
%440 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
441: ; preds = %423
%442 = add i16 %0, 1
%443 = zext i16 %442 to i64
%444 = getelementptr inbounds i8, i8* %1, i64 %443
%445 = load i8, i8* %444
%446 = lshr i8 %445, 3
%447 = and i8 %446, 7
%448 = and i8 %445, -64
switch i8 %448, label %1006 [
i8 64, label %449
i8 -128, label %576
]
449: ; preds = %441
%450 = and i8 %445, 7
%451 = zext i8 %450 to i32
switch i32 %451, label %1005 [
i32 0, label %452
i32 1, label %467
i32 2, label %478
i32 3, label %491
i32 4, label %547
i32 5, label %552
i32 6, label %557
i32 7, label %571
]
452: ; preds = %449
%453 = bitcast i8* %2 to i32*
store i32 2125417, i32* %453
%454 = icmp eq i8 %447, 6
br i1 %454, label %460, label %455
455: ; preds = %452
%456 = zext i8 %447 to i64
%457 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %456
%458 = load i8*, i8** %457
%459 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %458)
br label %464
460: ; preds = %452
%461 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%462 = getelementptr i8, i8* %2, i64 %461
%463 = bitcast i8* %462 to i16*
store i16 102, i16* %463
br label %464
464: ; preds = %460, %455
%465 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%466 = getelementptr i8, i8* %2, i64 %465
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %466, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.87, i64 0, i64 0), i64 6, i1 false)
br label %1006
467: ; preds = %449
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(10) %2, i8* align 1 dereferenceable(10) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.88, i64 0, i64 0), i64 10, i1 false)
%468 = icmp eq i8 %447, 6
br i1 %468, label %474, label %469
469: ; preds = %467
%470 = zext i8 %447 to i64
%471 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %470
%472 = load i8*, i8** %471
%473 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %472)
br label %1006
474: ; preds = %467
%475 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%476 = getelementptr i8, i8* %2, i64 %475
%477 = bitcast i8* %476 to i16*
store i16 48, i16* %477
br label %1006
478: ; preds = %449
%479 = zext i8 %447 to i32
%480 = and i32 %479, 1
%481 = icmp eq i32 %480, 0
%482 = bitcast i8* %2 to i32*
%483 = select i1 %481, i32 6513267, i32 6513761
store i32 %483, i32* %482
%484 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%485 = getelementptr i8, i8* %2, i64 %484
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %485, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.92, i64 0, i64 0), i64 6, i1 false)
%486 = lshr i32 %479, 1
%487 = zext i32 %486 to i64
%488 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %487
%489 = load i8*, i8** %488
%490 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %489)
br label %1006
491: ; preds = %449
%492 = zext i8 %447 to i32
%493 = and i32 %492, 1
%494 = icmp eq i32 %493, 0
br i1 %494, label %523, label %495
495: ; preds = %491
%496 = bitcast i8* %2 to i32*
store i32 2122860, i32* %496
%497 = lshr i32 %492, 1
%498 = zext i32 %497 to i64
%499 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %498
%500 = load i8*, i8** %499
%501 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %500)
%502 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%503 = getelementptr i8, i8* %2, i64 %502
%504 = bitcast i8* %503 to i32*
store i32 2629676, i32* %504
%505 = zext i16 %442 to i32
%506 = add nuw nsw i32 %505, 1
%507 = zext i32 %506 to i64
%508 = getelementptr inbounds i8, i8* %1, i64 %507
%509 = load i8, i8* %508
%510 = zext i8 %509 to i32
%511 = add nuw nsw i32 %505, 2
%512 = zext i32 %511 to i64
%513 = getelementptr inbounds i8, i8* %1, i64 %512
%514 = load i8, i8* %513
%515 = zext i8 %514 to i32
%516 = shl nuw nsw i32 %515, 8
%517 = or i32 %516, %510
%518 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %517)
%519 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%520 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%521 = getelementptr i8, i8* %2, i64 %520
%522 = bitcast i8* %521 to i16*
store i16 41, i16* %522
br label %1006
523: ; preds = %491
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.40, i64 0, i64 0), i64 5, i1 false)
%524 = zext i16 %442 to i32
%525 = add nuw nsw i32 %524, 1
%526 = zext i32 %525 to i64
%527 = getelementptr inbounds i8, i8* %1, i64 %526
%528 = load i8, i8* %527
%529 = zext i8 %528 to i32
%530 = add nuw nsw i32 %524, 2
%531 = zext i32 %530 to i64
%532 = getelementptr inbounds i8, i8* %1, i64 %531
%533 = load i8, i8* %532
%534 = zext i8 %533 to i32
%535 = shl nuw nsw i32 %534, 8
%536 = or i32 %535, %529
%537 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %536)
%538 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%539 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%540 = getelementptr i8, i8* %2, i64 %539
%541 = bitcast i8* %540 to i32*
store i32 2108457, i32* %541
%542 = lshr i32 %492, 1
%543 = zext i32 %542 to i64
%544 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %543
%545 = load i8*, i8** %544
%546 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %545)
br label %1006
547: ; preds = %449
%548 = zext i8 %447 to i64
%549 = shl i64 %548, 2
%550 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.Disassemble.161 to i8*), i64 %549)
%551 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %550)
br label %1006
552: ; preds = %449
%553 = zext i8 %447 to i64
%554 = shl i64 %553, 2
%555 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.Disassemble.162 to i8*), i64 %554)
%556 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %555)
br label %1006
557: ; preds = %449
%558 = bitcast i8* %2 to i32*
store i32 2125161, i32* %558
switch i8 %445, label %1006 [
i8 70, label %559
i8 86, label %563
i8 94, label %567
]
559: ; preds = %557
%560 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%561 = getelementptr i8, i8* %2, i64 %560
%562 = bitcast i8* %561 to i16*
store i16 48, i16* %562
br label %1006
563: ; preds = %557
%564 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%565 = getelementptr i8, i8* %2, i64 %564
%566 = bitcast i8* %565 to i16*
store i16 49, i16* %566
br label %1006
567: ; preds = %557
%568 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%569 = getelementptr i8, i8* %2, i64 %568
%570 = bitcast i8* %569 to i16*
store i16 50, i16* %570
br label %1006
571: ; preds = %449
%572 = zext i8 %447 to i64
%573 = shl i64 %572, 2
%574 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.Disassemble.163 to i8*), i64 %573)
%575 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %574)
br label %1006
576: ; preds = %441
%577 = and i8 %445, 31
%578 = zext i8 %577 to i64
%579 = shl i64 %578, 2
%580 = call i8* @llvm.load.relative.i64(i8* bitcast ([32 x i32]* @reltable.Disassemble.164 to i8*), i64 %579)
%581 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %580)
br label %1006
582: ; preds = %423
%583 = and i32 %8, 32
%584 = icmp eq i32 %583, 0
%585 = select i1 %584, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.129, i64 0, i64 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.128, i64 0, i64 0)
%586 = add i16 %0, 1
%587 = zext i16 %586 to i64
%588 = getelementptr inbounds i8, i8* %1, i64 %587
%589 = load i8, i8* %588
%590 = zext i8 %589 to i32
switch i8 %589, label %1006 [
i8 9, label %591
i8 25, label %595
i8 33, label %599
i8 34, label %619
i8 35, label %639
i8 41, label %641
i8 42, label %646
i8 43, label %670
i8 52, label %672
i8 53, label %686
i8 54, label %700
i8 57, label %723
i8 70, label %727
i8 78, label %727
i8 86, label %727
i8 94, label %727
i8 102, label %727
i8 110, label %727
i8 112, label %751
i8 113, label %751
i8 114, label %751
i8 115, label %751
i8 116, label %751
i8 117, label %751
i8 119, label %751
i8 126, label %770
i8 -122, label %785
i8 -114, label %799
i8 -106, label %813
i8 -98, label %827
i8 -90, label %841
i8 -82, label %855
i8 -74, label %869
i8 -66, label %884
i8 -31, label %899
i8 -29, label %901
i8 -27, label %903
i8 -23, label %905
i8 -7, label %910
i8 -53, label %913
]
591: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.130, i64 0, i64 0), i64 5, i1 false)
%592 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%593 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%594 = getelementptr i8, i8* %2, i64 %593
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %594, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.131, i64 0, i64 0), i64 5, i1 false)
br label %1006
595: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.130, i64 0, i64 0), i64 5, i1 false)
%596 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%597 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%598 = getelementptr i8, i8* %2, i64 %597
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %598, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.132, i64 0, i64 0), i64 5, i1 false)
br label %1006
599: ; preds = %582
%600 = bitcast i8* %2 to i32*
store i32 2122860, i32* %600
%601 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%602 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%603 = getelementptr i8, i8* %2, i64 %602
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %603, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%604 = zext i16 %586 to i32
%605 = add nuw nsw i32 %604, 1
%606 = zext i32 %605 to i64
%607 = getelementptr inbounds i8, i8* %1, i64 %606
%608 = load i8, i8* %607
%609 = zext i8 %608 to i32
%610 = add nuw nsw i32 %604, 2
%611 = zext i32 %610 to i64
%612 = getelementptr inbounds i8, i8* %1, i64 %611
%613 = load i8, i8* %612
%614 = zext i8 %613 to i32
%615 = shl nuw nsw i32 %614, 8
%616 = or i32 %615, %609
%617 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %616)
%618 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
619: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.40, i64 0, i64 0), i64 5, i1 false)
%620 = zext i16 %586 to i32
%621 = add nuw nsw i32 %620, 1
%622 = zext i32 %621 to i64
%623 = getelementptr inbounds i8, i8* %1, i64 %622
%624 = load i8, i8* %623
%625 = zext i8 %624 to i32
%626 = add nuw nsw i32 %620, 2
%627 = zext i32 %626 to i64
%628 = getelementptr inbounds i8, i8* %1, i64 %627
%629 = load i8, i8* %628
%630 = zext i8 %629 to i32
%631 = shl nuw nsw i32 %630, 8
%632 = or i32 %631, %625
%633 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %632)
%634 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%635 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%636 = getelementptr i8, i8* %2, i64 %635
%637 = bitcast i8* %636 to i32*
store i32 2108457, i32* %637
%638 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
639: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.47, i64 0, i64 0), i64 5, i1 false)
%640 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
641: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.130, i64 0, i64 0), i64 5, i1 false)
%642 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%643 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%644 = getelementptr i8, i8* %2, i64 %643
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %644, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
%645 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
646: ; preds = %582
%647 = bitcast i8* %2 to i32*
store i32 2122860, i32* %647
%648 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%649 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%650 = getelementptr i8, i8* %2, i64 %649
%651 = bitcast i8* %650 to i32*
store i32 2629676, i32* %651
%652 = zext i16 %586 to i32
%653 = add nuw nsw i32 %652, 1
%654 = zext i32 %653 to i64
%655 = getelementptr inbounds i8, i8* %1, i64 %654
%656 = load i8, i8* %655
%657 = zext i8 %656 to i32
%658 = add nuw nsw i32 %652, 2
%659 = zext i32 %658 to i64
%660 = getelementptr inbounds i8, i8* %1, i64 %659
%661 = load i8, i8* %660
%662 = zext i8 %661 to i32
%663 = shl nuw nsw i32 %662, 8
%664 = or i32 %663, %657
%665 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.35, i64 0, i64 0), i32 %664)
%666 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%667 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%668 = getelementptr i8, i8* %2, i64 %667
%669 = bitcast i8* %668 to i16*
store i16 41, i16* %669
br label %1006
670: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.46, i64 0, i64 0), i64 5, i1 false)
%671 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
672: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.133, i64 0, i64 0), i64 6, i1 false)
%673 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%674 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%675 = getelementptr i8, i8* %2, i64 %674
%676 = bitcast i8* %675 to i16*
store i16 43, i16* %676
%677 = add nuw nsw i64 %587, 1
%678 = getelementptr inbounds i8, i8* %1, i64 %677
%679 = load i8, i8* %678
%680 = zext i8 %679 to i32
%681 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %680)
%682 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%683 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%684 = getelementptr i8, i8* %2, i64 %683
%685 = bitcast i8* %684 to i16*
store i16 41, i16* %685
br label %1006
686: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.135, i64 0, i64 0), i64 6, i1 false)
%687 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%688 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%689 = getelementptr i8, i8* %2, i64 %688
%690 = bitcast i8* %689 to i16*
store i16 43, i16* %690
%691 = add nuw nsw i64 %587, 1
%692 = getelementptr inbounds i8, i8* %1, i64 %691
%693 = load i8, i8* %692
%694 = zext i8 %693 to i32
%695 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %694)
%696 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%697 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%698 = getelementptr i8, i8* %2, i64 %697
%699 = bitcast i8* %698 to i16*
store i16 41, i16* %699
br label %1006
700: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.40, i64 0, i64 0), i64 5, i1 false)
%701 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%702 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%703 = getelementptr i8, i8* %2, i64 %702
%704 = bitcast i8* %703 to i16*
store i16 43, i16* %704
%705 = zext i16 %586 to i32
%706 = add nuw nsw i32 %705, 1
%707 = zext i32 %706 to i64
%708 = getelementptr inbounds i8, i8* %1, i64 %707
%709 = load i8, i8* %708
%710 = zext i8 %709 to i32
%711 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %710)
%712 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%713 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%714 = getelementptr i8, i8* %2, i64 %713
%715 = bitcast i8* %714 to i32*
store i32 2108457, i32* %715
%716 = add nuw nsw i32 %705, 2
%717 = zext i32 %716 to i64
%718 = getelementptr inbounds i8, i8* %1, i64 %717
%719 = load i8, i8* %718
%720 = zext i8 %719 to i32
%721 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %720)
%722 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
723: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.130, i64 0, i64 0), i64 5, i1 false)
%724 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%725 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%726 = getelementptr i8, i8* %2, i64 %725
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %726, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.136, i64 0, i64 0), i64 5, i1 false)
br label %1006
727: ; preds = %582, %582, %582, %582, %582, %582
%728 = bitcast i8* %2 to i32*
store i32 2122860, i32* %728
%729 = lshr i32 %590, 3
%730 = and i32 %729, 7
%731 = zext i32 %730 to i64
%732 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %731
%733 = load i8*, i8** %732
%734 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %733)
%735 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%736 = getelementptr i8, i8* %2, i64 %735
%737 = bitcast i8* %736 to i32*
store i32 2629676, i32* %737
%738 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%739 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%740 = getelementptr i8, i8* %2, i64 %739
%741 = bitcast i8* %740 to i16*
store i16 43, i16* %741
%742 = add nuw nsw i64 %587, 1
%743 = getelementptr inbounds i8, i8* %1, i64 %742
%744 = load i8, i8* %743
%745 = zext i8 %744 to i32
%746 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %745)
%747 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%748 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%749 = getelementptr i8, i8* %2, i64 %748
%750 = bitcast i8* %749 to i16*
store i16 41, i16* %750
br label %1006
751: ; preds = %582, %582, %582, %582, %582, %582, %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.40, i64 0, i64 0), i64 5, i1 false)
%752 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%753 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%754 = getelementptr i8, i8* %2, i64 %753
%755 = bitcast i8* %754 to i16*
store i16 43, i16* %755
%756 = add nuw nsw i64 %587, 1
%757 = getelementptr inbounds i8, i8* %1, i64 %756
%758 = load i8, i8* %757
%759 = zext i8 %758 to i32
%760 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %759)
%761 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%762 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%763 = getelementptr i8, i8* %2, i64 %762
%764 = bitcast i8* %763 to i32*
store i32 2108457, i32* %764
%765 = and i32 %590, 7
%766 = zext i32 %765 to i64
%767 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %766
%768 = load i8*, i8** %767
%769 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %768)
br label %1006
770: ; preds = %582
%771 = bitcast i8* %2 to i64*
store i64 11294374048588908, i64* %771
%772 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%773 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%774 = getelementptr i8, i8* %2, i64 %773
%775 = bitcast i8* %774 to i16*
store i16 43, i16* %775
%776 = add nuw nsw i64 %587, 1
%777 = getelementptr inbounds i8, i8* %1, i64 %776
%778 = load i8, i8* %777
%779 = zext i8 %778 to i32
%780 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %779)
%781 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%782 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%783 = getelementptr i8, i8* %2, i64 %782
%784 = bitcast i8* %783 to i16*
store i16 41, i16* %784
br label %1006
785: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.137, i64 0, i64 0), i64 9, i1 false)
%786 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%787 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%788 = getelementptr i8, i8* %2, i64 %787
%789 = bitcast i8* %788 to i16*
store i16 43, i16* %789
%790 = add nuw nsw i64 %587, 1
%791 = getelementptr inbounds i8, i8* %1, i64 %790
%792 = load i8, i8* %791
%793 = zext i8 %792 to i32
%794 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %793)
%795 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%796 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%797 = getelementptr i8, i8* %2, i64 %796
%798 = bitcast i8* %797 to i16*
store i16 41, i16* %798
br label %1006
799: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.138, i64 0, i64 0), i64 9, i1 false)
%800 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%801 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%802 = getelementptr i8, i8* %2, i64 %801
%803 = bitcast i8* %802 to i16*
store i16 43, i16* %803
%804 = add nuw nsw i64 %587, 1
%805 = getelementptr inbounds i8, i8* %1, i64 %804
%806 = load i8, i8* %805
%807 = zext i8 %806 to i32
%808 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %807)
%809 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%810 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%811 = getelementptr i8, i8* %2, i64 %810
%812 = bitcast i8* %811 to i16*
store i16 41, i16* %812
br label %1006
813: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.139, i64 0, i64 0), i64 9, i1 false)
%814 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%815 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%816 = getelementptr i8, i8* %2, i64 %815
%817 = bitcast i8* %816 to i16*
store i16 43, i16* %817
%818 = add nuw nsw i64 %587, 1
%819 = getelementptr inbounds i8, i8* %1, i64 %818
%820 = load i8, i8* %819
%821 = zext i8 %820 to i32
%822 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %821)
%823 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%824 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%825 = getelementptr i8, i8* %2, i64 %824
%826 = bitcast i8* %825 to i16*
store i16 41, i16* %826
br label %1006
827: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.140, i64 0, i64 0), i64 9, i1 false)
%828 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%829 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%830 = getelementptr i8, i8* %2, i64 %829
%831 = bitcast i8* %830 to i16*
store i16 43, i16* %831
%832 = add nuw nsw i64 %587, 1
%833 = getelementptr inbounds i8, i8* %1, i64 %832
%834 = load i8, i8* %833
%835 = zext i8 %834 to i32
%836 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %835)
%837 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%838 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%839 = getelementptr i8, i8* %2, i64 %838
%840 = bitcast i8* %839 to i16*
store i16 41, i16* %840
br label %1006
841: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.141, i64 0, i64 0), i64 9, i1 false)
%842 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%843 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%844 = getelementptr i8, i8* %2, i64 %843
%845 = bitcast i8* %844 to i16*
store i16 43, i16* %845
%846 = add nuw nsw i64 %587, 1
%847 = getelementptr inbounds i8, i8* %1, i64 %846
%848 = load i8, i8* %847
%849 = zext i8 %848 to i32
%850 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %849)
%851 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%852 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%853 = getelementptr i8, i8* %2, i64 %852
%854 = bitcast i8* %853 to i16*
store i16 41, i16* %854
br label %1006
855: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(9) %2, i8* align 1 dereferenceable(9) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.142, i64 0, i64 0), i64 9, i1 false)
%856 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%857 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%858 = getelementptr i8, i8* %2, i64 %857
%859 = bitcast i8* %858 to i16*
store i16 43, i16* %859
%860 = add nuw nsw i64 %587, 1
%861 = getelementptr inbounds i8, i8* %1, i64 %860
%862 = load i8, i8* %861
%863 = zext i8 %862 to i32
%864 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %863)
%865 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%866 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%867 = getelementptr i8, i8* %2, i64 %866
%868 = bitcast i8* %867 to i16*
store i16 41, i16* %868
br label %1006
869: ; preds = %582
%870 = bitcast i8* %2 to i64*
store i64 11294374048592495, i64* %870
%871 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%872 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%873 = getelementptr i8, i8* %2, i64 %872
%874 = bitcast i8* %873 to i16*
store i16 43, i16* %874
%875 = add nuw nsw i64 %587, 1
%876 = getelementptr inbounds i8, i8* %1, i64 %875
%877 = load i8, i8* %876
%878 = zext i8 %877 to i32
%879 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %878)
%880 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%881 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%882 = getelementptr i8, i8* %2, i64 %881
%883 = bitcast i8* %882 to i16*
store i16 41, i16* %883
br label %1006
884: ; preds = %582
%885 = bitcast i8* %2 to i64*
store i64 11294374048591971, i64* %885
%886 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%887 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%888 = getelementptr i8, i8* %2, i64 %887
%889 = bitcast i8* %888 to i16*
store i16 43, i16* %889
%890 = add nuw nsw i64 %587, 1
%891 = getelementptr inbounds i8, i8* %1, i64 %890
%892 = load i8, i8* %891
%893 = zext i8 %892 to i32
%894 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %893)
%895 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%896 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%897 = getelementptr i8, i8* %2, i64 %896
%898 = bitcast i8* %897 to i16*
store i16 41, i16* %898
br label %1006
899: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.62, i64 0, i64 0), i64 5, i1 false)
%900 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
901: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(10) %2, i8* align 1 dereferenceable(10) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.145, i64 0, i64 0), i64 10, i1 false)
%902 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
903: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.146, i64 0, i64 0), i64 6, i1 false)
%904 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
905: ; preds = %582
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.147, i64 0, i64 0), i64 5, i1 false)
%906 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%907 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%908 = getelementptr i8, i8* %2, i64 %907
%909 = bitcast i8* %908 to i16*
store i16 41, i16* %909
br label %1006
910: ; preds = %582
%911 = bitcast i8* %2 to i64*
store i64 9056060734202988, i64* %911
%912 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
br label %1006
913: ; preds = %582
%914 = zext i16 %586 to i32
%915 = add nuw nsw i32 %914, 2
%916 = zext i32 %915 to i64
%917 = getelementptr inbounds i8, i8* %1, i64 %916
%918 = load i8, i8* %917
%919 = zext i8 %918 to i32
%920 = lshr i8 %918, 3
%921 = and i8 %920, 7
%922 = getelementptr inbounds [80 x i8], [80 x i8]* %5, i64 0, i64 1
store i8 0, i8* %922
%923 = lshr i32 %919, 6
switch i32 %923, label %944 [
i32 0, label %924
i32 1, label %929
i32 2, label %934
i32 3, label %939
]
924: ; preds = %913
%925 = zext i8 %921 to i64
%926 = shl i64 %925, 2
%927 = call i8* @llvm.load.relative.i64(i8* bitcast ([8 x i32]* @reltable.Disassemble.165 to i8*), i64 %926)
%928 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %927)
br label %945
929: ; preds = %913
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.75, i64 0, i64 0), i64 5, i1 false)
%930 = or i8 %921, 48
store i8 %930, i8* %12
%931 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%932 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%933 = getelementptr i8, i8* %2, i64 %932
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %933, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
br label %945
934: ; preds = %913
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.76, i64 0, i64 0), i64 5, i1 false)
%935 = or i8 %921, 48
store i8 %935, i8* %12
%936 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%937 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%938 = getelementptr i8, i8* %2, i64 %937
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %938, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
br label %945
939: ; preds = %913
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.77, i64 0, i64 0), i64 5, i1 false)
%940 = or i8 %921, 48
store i8 %940, i8* %12
%941 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%942 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%943 = getelementptr i8, i8* %2, i64 %942
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %943, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
br label %945
944: ; preds = %913
unreachable
945: ; preds = %939, %934, %929, %924
%946 = and i32 %919, 7
%947 = icmp eq i32 %946, 6
br i1 %947, label %955, label %948
948: ; preds = %945
%949 = zext i32 %946 to i64
%950 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.reg, i64 0, i64 %949
%951 = load i8*, i8** %950
%952 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %951)
%953 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%954 = getelementptr i8, i8* %2, i64 %953
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(3) %954, i8* align 1 dereferenceable(3) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i64 0, i64 0), i64 3, i1 false)
br label %955
955: ; preds = %948, %945
%956 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%957 = getelementptr i8, i8* %2, i64 %956
%958 = bitcast i8* %957 to i16*
store i16 40, i16* %958
%959 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %13)
%960 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%961 = getelementptr i8, i8* %2, i64 %960
%962 = bitcast i8* %961 to i16*
store i16 43, i16* %962
%963 = add nuw nsw i32 %914, 1
%964 = zext i32 %963 to i64
%965 = getelementptr inbounds i8, i8* %1, i64 %964
%966 = load i8, i8* %965
%967 = zext i8 %966 to i32
%968 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %967)
%969 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
%970 = tail call i64 @strlen(i8* dereferenceable(1) %2)
%971 = getelementptr i8, i8* %2, i64 %970
%972 = bitcast i8* %971 to i16*
store i16 41, i16* %972
br label %1006
973: ; preds = %419
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %2, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.146, i64 0, i64 0), i64 6, i1 false)
%974 = lshr i32 %420, 1
%975 = icmp eq i32 %974, 3
br i1 %975, label %980, label %976
976: ; preds = %973
%977 = zext i32 %974 to i64
%978 = getelementptr inbounds [4 x i8*], [4 x i8*]* @Disassemble.dreg, i64 0, i64 %977
%979 = load i8*, i8** %978
br label %980
980: ; preds = %973, %976
%981 = phi i8* [ %979, %976 ], [ getelementptr inbounds ([3 x i8], [3 x i8]* @.str.63, i64 0, i64 0), %973 ]
%982 = tail call i8* @strcat(i8* dereferenceable(1) %2, i8* dereferenceable(1) %981)
br label %1006
983: ; preds = %247
%984 = zext i8 %10 to i64
%985 = getelementptr inbounds [8 x i8*], [8 x i8*]* @Disassemble.arith, i64 0, i64 %984
%986 = load i8*, i8** %985
%987 = tail call i8* @strcpy(i8* dereferenceable(1) %2, i8* dereferenceable(1) %986)
%988 = zext i16 %0 to i64
%989 = add nuw nsw i64 %988, 1
%990 = getelementptr inbounds i8, i8* %1, i64 %989
%991 = load i8, i8* %990
%992 = zext i8 %991 to i32
%993 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %992)
%994 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
995: ; preds = %247
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %2, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.159, i64 0, i64 0), i64 5, i1 false)
%996 = and i32 %8, 56
%997 = call i32 (i8*, i8*, ...) @sprintf(i8* %12, i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0), i32 %996)
%998 = call i8* @strcat(i8* dereferenceable(1) %2, i8* %12)
br label %1006
999: ; preds = %4
unreachable
1000: ; preds = %16
unreachable
1001: ; preds = %101
unreachable
1002: ; preds = %247
unreachable
1003: ; preds = %258
unreachable
1004: ; preds = %301
unreachable
1005: ; preds = %449
unreachable
1006: ; preds = %249, %278, %397, %983, %995, %270, %273, %260, %262, %264, %266, %331, %343, %352, %361, %396, %395, %394, %393, %381, %371, %303, %425, %464, %478, %547, %552, %571, %474, %469, %523, %495, %557, %567, %563, %559, %441, %576, %582, %955, %910, %905, %903, %901, %899, %884, %869, %855, %841, %827, %813, %799, %785, %770, %751, %727, %723, %700, %686, %672, %670, %646, %641, %639, %619, %599, %595, %591, %980, %187, %193, %198, %203, %218, %48, %35, %23, %22, %20, %77, %71, %162, %144, %125, %107, %106, %105, %104, %103, %238, %226, %225
ret i32 %14
}