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:
      strcpy(s, (a & 8) ? "dec " : "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     17be <Disassemble+0x67e>
jmp    11b2 <Disassemble+0x72>
mov    -0x7c(%rbp),%eax
sub    $0x80,%eax
je     1839 <Disassemble+0x6f9>
jmp    11c5 <Disassemble+0x85>
mov    -0x7c(%rbp),%eax
sub    $0xc0,%eax
je     1872 <Disassemble+0x732>
jmp    303c <Disassemble+0x1efc>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0x88(%rbp)
sub    $0x7,%rax
ja     17b9 <Disassemble+0x679>
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    17b9 <Disassemble+0x679>
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    17b9 <Disassemble+0x679>
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    17b9 <Disassemble+0x679>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%ecx
and    $0x8,%ecx
lea    0x2ea3(%rip),%rsi
lea    0x2e97(%rip),%rax
cmp    $0x0,%ecx
cmovne %rax,%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x49cd(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17b9 <Disassemble+0x679>
mov    -0x18(%rbp),%rdi
lea    0x2e62(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x495e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17b9 <Disassemble+0x679>
mov    -0x18(%rbp),%rdi
lea    0x2e2e(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x492f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17b9 <Disassemble+0x679>
mov    -0x18(%rbp),%rdi
lea    0x2db1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x4900(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2e99(%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    0x2d50(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17b9 <Disassemble+0x679>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x4980(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    303c <Disassemble+0x1efc>
movzbl -0x1d(%rbp),%eax
cmp    $0x76,%eax
jne    17e0 <Disassemble+0x6a0>
mov    -0x18(%rbp),%rdi
lea    0x2d8f(%rip),%rsi
call   1030 <strcpy@plt>
jmp    303c <Disassemble+0x1efc>
mov    -0x18(%rbp),%rdi
lea    0x2d00(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x484f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2de8(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x4825(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    303c <Disassemble+0x1efc>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x48a6(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x47ec(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    303c <Disassemble+0x1efc>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xa0(%rbp)
sub    $0x7,%rax
ja     3037 <Disassemble+0x1ef7>
mov    -0xa0(%rbp),%rax
lea    0x276b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2cc1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x47f1(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    3037 <Disassemble+0x1ef7>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1960 <Disassemble+0x820>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,%ecx
mov    %rcx,-0xa8(%rbp)
sub    $0x3,%eax
ja     195b <Disassemble+0x81b>
mov    -0xa8(%rbp),%rax
lea    0x2b21(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2c58(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195b <Disassemble+0x81b>
mov    -0x18(%rbp),%rdi
lea    0x2c47(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195b <Disassemble+0x81b>
mov    -0x18(%rbp),%rdi
lea    0x2c36(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195b <Disassemble+0x81b>
mov    -0x18(%rbp),%rdi
lea    0x2c29(%rip),%rsi
call   1030 <strcpy@plt>
jmp    19b8 <Disassemble+0x878>
mov    -0x18(%rbp),%rdi
lea    0x2c1e(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    1995 <Disassemble+0x855>
mov    -0x18(%rbp),%rdi
lea    0x2c03(%rip),%rsi
call   1050 <strcat@plt>
jmp    19b3 <Disassemble+0x873>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x46e6(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    19b8 <Disassemble+0x878>
jmp    3037 <Disassemble+0x1ef7>
mov    -0x18(%rbp),%rdi
lea    0x2bc9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x46d2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2c0b(%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    0x2ac4(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3037 <Disassemble+0x1ef7>
movzbl -0x1e(%rbp),%eax
mov    %rax,-0xb0(%rbp)
sub    $0x7,%rax
ja     1da1 <Disassemble+0xc61>
mov    -0xb0(%rbp),%rax
lea    0x299d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2b16(%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    0x2a3b(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1da1 <Disassemble+0xc61>
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     1b5b <Disassemble+0xa1b>
jmp    1b1b <Disassemble+0x9db>
mov    -0xb4(%rbp),%eax
sub    $0x40,%eax
je     1ba4 <Disassemble+0xa64>
jmp    1b2f <Disassemble+0x9ef>
mov    -0xb4(%rbp),%eax
sub    $0x80,%eax
je     1bfa <Disassemble+0xaba>
jmp    1b45 <Disassemble+0xa05>
mov    -0xb4(%rbp),%eax
sub    $0xc0,%eax
je     1c50 <Disassemble+0xb10>
jmp    1ca1 <Disassemble+0xb61>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x4604(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x2a7e(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x44ba(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca1 <Disassemble+0xb61>
mov    -0x18(%rbp),%rdi
lea    0x2a01(%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    0x2a27(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x4464(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca1 <Disassemble+0xb61>
mov    -0x18(%rbp),%rdi
lea    0x29b0(%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    0x29d1(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x440e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca1 <Disassemble+0xb61>
mov    -0x18(%rbp),%rdi
lea    0x295f(%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    0x297b(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x43b8(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1da1 <Disassemble+0xc61>
mov    -0x18(%rbp),%rdi
lea    0x290e(%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    0x2803(%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    0x280b(%rip),%rsi
call   1050 <strcat@plt>
jmp    1da1 <Disassemble+0xc61>
mov    -0x18(%rbp),%rdi
lea    0x28be(%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    0x27ad(%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    0x28ac(%rip),%rsi
call   1050 <strcat@plt>
jmp    1da1 <Disassemble+0xc61>
mov    -0x18(%rbp),%rdi
lea    0x2870(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da1 <Disassemble+0xc61>
mov    -0x18(%rbp),%rdi
lea    0x2867(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da1 <Disassemble+0xc61>
mov    -0x18(%rbp),%rdi
lea    0x28c6(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da1 <Disassemble+0xc61>
mov    -0x18(%rbp),%rdi
lea    0x2847(%rip),%rsi
call   1030 <strcpy@plt>
jmp    3037 <Disassemble+0x1ef7>
mov    -0x18(%rbp),%rdi
lea    0x2835(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x42e9(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2822(%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    0x26db(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3037 <Disassemble+0x1ef7>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2f3f <Disassemble+0x1dff>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,-0xb8(%rbp)
test   %eax,%eax
je     1e6a <Disassemble+0xd2a>
jmp    1e56 <Disassemble+0xd16>
mov    -0xb8(%rbp),%eax
sub    $0x2,%eax
je     1ec7 <Disassemble+0xd87>
jmp    22b3 <Disassemble+0x1173>
mov    -0x18(%rbp),%rdi
lea    0x2771(%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    0x2641(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f3a <Disassemble+0x1dfa>
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     1f28 <Disassemble+0xde8>
jmp    1f12 <Disassemble+0xdd2>
mov    -0xbc(%rbp),%eax
sub    $0x80,%eax
je     2290 <Disassemble+0x1150>
jmp    22ae <Disassemble+0x116e>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xc8(%rbp)
sub    $0x7,%rax
ja     228b <Disassemble+0x114b>
mov    -0xc8(%rbp),%rax
lea    0x20d5(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x268d(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
cmp    $0x6,%eax
je     1f90 <Disassemble+0xe50>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x40ce(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1fa0 <Disassemble+0xe60>
mov    -0x18(%rbp),%rdi
lea    0x25f4(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2645(%rip),%rsi
call   1050 <strcat@plt>
jmp    228b <Disassemble+0x114b>
mov    -0x18(%rbp),%rdi
lea    0x2636(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
cmp    $0x6,%eax
je     1ff1 <Disassemble+0xeb1>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x406d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2001 <Disassemble+0xec1>
mov    -0x18(%rbp),%rdi
lea    0x2604(%rip),%rsi
call   1050 <strcat@plt>
jmp    228b <Disassemble+0x114b>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     202b <Disassemble+0xeeb>
mov    -0x18(%rbp),%rdi
lea    0x25e1(%rip),%rsi
call   1030 <strcpy@plt>
jmp    203b <Disassemble+0xefb>
mov    -0x18(%rbp),%rdi
lea    0x25d0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x249f(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x4030(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    228b <Disassemble+0x114b>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2119 <Disassemble+0xfd9>
mov    -0x18(%rbp),%rdi
lea    0x2462(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3fed(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x261e(%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    0x23ff(%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    0x24e5(%rip),%rsi
call   1050 <strcat@plt>
jmp    219f <Disassemble+0x105f>
mov    -0x18(%rbp),%rdi
lea    0x23ff(%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    0x2392(%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    0x2480(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3efa(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    228b <Disassemble+0x114b>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3ffb(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    228b <Disassemble+0x114b>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x401c(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    228b <Disassemble+0x114b>
mov    -0x18(%rbp),%rdi
lea    0x242f(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1d(%rbp),%eax
mov    %eax,-0xcc(%rbp)
sub    $0x46,%eax
je     2232 <Disassemble+0x10f2>
jmp    220a <Disassemble+0x10ca>
mov    -0xcc(%rbp),%eax
sub    $0x56,%eax
je     2247 <Disassemble+0x1107>
jmp    221e <Disassemble+0x10de>
mov    -0xcc(%rbp),%eax
sub    $0x5e,%eax
je     225c <Disassemble+0x111c>
jmp    226c <Disassemble+0x112c>
mov    -0x18(%rbp),%rdi
lea    0x23c3(%rip),%rsi
call   1050 <strcat@plt>
jmp    226c <Disassemble+0x112c>
mov    -0x18(%rbp),%rdi
lea    0x23ce(%rip),%rsi
call   1050 <strcat@plt>
jmp    226c <Disassemble+0x112c>
mov    -0x18(%rbp),%rdi
lea    0x23bb(%rip),%rsi
call   1050 <strcat@plt>
jmp    228b <Disassemble+0x114b>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3fae(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    22ae <Disassemble+0x116e>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x1f,%eax
movslq %eax,%rcx
lea    0x3fcb(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2f3a <Disassemble+0x1dfa>
movzbl -0x1d(%rbp),%eax
mov    %al,%cl
lea    0x23d6(%rip),%rax
lea    0x23d2(%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     2f35 <Disassemble+0x1df5>
mov    -0xd8(%rbp),%rax
lea    0x1d23(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x236b(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2353(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x2339(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2326(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x2156(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x224b(%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    0x2104(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x2114(%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    0x20a7(%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    0x2195(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x20b5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x21f1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2135(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x2001(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x21ce(%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    0x1faf(%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    0x2095(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1fc5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x2115(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x20fe(%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    0x1f01(%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    0x2000(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x20aa(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x208b(%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    0x1e8e(%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    0x1f8d(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1ea7(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x2018(%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    0x1e1b(%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    0x1f22(%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    0x1dda(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1f7c(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f7c(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1d99(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
sar    $0x3,%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x38e1(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f52(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1f11(%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    0x1d14(%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    0x1e13(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1d2d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1e9e(%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    0x1ca1(%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    0x1da8(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x37e2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1caa(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1e0d(%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    0x1c10(%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    0x1d0f(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1dc4(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1d9a(%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    0x1b9d(%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    0x1c9c(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1d5a(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1d27(%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    0x1b2a(%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    0x1c29(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1cf0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1cb4(%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    0x1ab7(%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    0x1bb6(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1c86(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1c41(%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    0x1a44(%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    0x1b43(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1c1c(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1bce(%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    0x19d1(%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    0x1ad0(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1bb2(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1b5b(%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    0x195e(%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    0x1a5d(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1b40(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1ae8(%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    0x18eb(%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    0x19ea(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1ad5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1a75(%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    0x1878(%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    0x1977(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x18f7(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1a48(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1a30(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x1a14(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x18df(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
mov    -0x18(%rbp),%rdi
lea    0x19e7(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f35 <Disassemble+0x1df5>
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     2dbb <Disassemble+0x1c7b>
jmp    2d7b <Disassemble+0x1c3b>
mov    -0xdc(%rbp),%eax
sub    $0x40,%eax
je     2dda <Disassemble+0x1c9a>
jmp    2d8f <Disassemble+0x1c4f>
mov    -0xdc(%rbp),%eax
sub    $0x80,%eax
je     2e16 <Disassemble+0x1cd6>
jmp    2da5 <Disassemble+0x1c65>
mov    -0xdc(%rbp),%eax
sub    $0xc0,%eax
je     2e52 <Disassemble+0x1d12>
jmp    2e89 <Disassemble+0x1d49>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x35a4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2e89 <Disassemble+0x1d49>
mov    -0x18(%rbp),%rdi
lea    0x17cb(%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    0x17f1(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e89 <Disassemble+0x1d49>
mov    -0x18(%rbp),%rdi
lea    0x1794(%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    0x17b5(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e89 <Disassemble+0x1d49>
mov    -0x18(%rbp),%rdi
lea    0x175d(%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    0x1779(%rip),%rsi
call   1050 <strcat@plt>
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
cmp    $0x6,%eax
je     2ec7 <Disassemble+0x1d87>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x31a2(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x173b(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1805(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x17c2(%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    0x15c5(%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    0x16c4(%rip),%rsi
call   1050 <strcat@plt>
jmp    2f3a <Disassemble+0x1dfa>
jmp    2fac <Disassemble+0x1e6c>
mov    -0x18(%rbp),%rdi
lea    0x17bc(%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    2f7d <Disassemble+0x1e3d>
lea    0x161d(%rip),%rax
mov    %rax,-0xf0(%rbp)
jmp    2f99 <Disassemble+0x1e59>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3102(%rip),%rax
mov    (%rax,%rcx,8),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xe8(%rbp),%rdi
mov    -0xf0(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3037 <Disassemble+0x1ef7>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x312e(%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    0x14ee(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    3037 <Disassemble+0x1ef7>
mov    -0x18(%rbp),%rdi
lea    0x172f(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzbl -0x1d(%rbp),%edx
and    $0x38,%edx
lea    0x14b3(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    303c <Disassemble+0x1efc>
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     1583 <Disassemble+0x433>
mov    %ebx,%eax
lea    0x2304(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x706f6e,(%r15)
jmp    14c1 <Disassemble+0x371>
cmp    $0x76,%r14b
jne    1247 <Disassemble+0xf7>
movb   $0x0,0x4(%r15)
movl   $0x746c6168,(%r15)
jmp    14c1 <Disassemble+0x371>
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    1328 <Disassemble+0x1d8>
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    1322 <Disassemble+0x1d2>
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    1328 <Disassemble+0x1d8>
mov    %edi,%ebp
test   $0x8,%r14b
jne    14f8 <Disassemble+0x3a8>
movl   $0x20646c,(%r15)
shr    %bl
movzbl %bl,%eax
lea    0x3add(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
jmp    1419 <Disassemble+0x2c9>
movzbl %bl,%eax
lea    0x21ee(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movabs $0x2c2963622820646c,%rax
63 29 2c
jmp    1783 <Disassemble+0x633>
test   $0x8,%r14b
lea    0x23e6(%rip),%rax
lea    0x23da(%rip),%rcx
cmove  %rax,%rcx
mov    0x4(%rcx),%al
mov    %al,0x4(%r15)
mov    (%rcx),%eax
mov    %eax,(%r15)
shr    %bl
movzbl %bl,%eax
lea    0x3a84(%rip),%rcx
jmp    1322 <Disassemble+0x1d2>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1318 <Disassemble+0x1c8>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
movzbl %bl,%eax
lea    0x3a1e(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %ebx,%edi
jmp    14c1 <Disassemble+0x371>
movl   $0x20646c,(%r15)
movzbl %bl,%eax
lea    0x39f8(%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    1494 <Disassemble+0x344>
movzbl %bl,%eax
lea    0x215a(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %edi,%ebx
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    %ebx,%edi
jmp    14c1 <Disassemble+0x371>
movzbl %bl,%eax
test   $0x1,%bl
jne    151f <Disassemble+0x3cf>
mov    %edi,%ebx
movb   $0x0,0x4(%r15)
movl   $0x20706f70,(%r15)
shr    %eax
cmp    $0x3,%eax
jne    1571 <Disassemble+0x421>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x6661,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
mov    %ebx,%edi
jmp    14c1 <Disassemble+0x371>
movl   $0x20706a,(%r15)
jmp    1409 <Disassemble+0x2b9>
movzbl %bl,%eax
lea    0x205e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x20706a,(%r15)
jmp    155b <Disassemble+0x40b>
movw   $0x20,0x4(%r15)
movl   $0x6c6c6163,(%r15)
movzbl %bl,%eax
lea    0x398d(%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    0x2231(%rip),%rsi
jmp    14a5 <Disassemble+0x355>
movzbl %bl,%eax
test   $0x1,%bl
jne    153a <Disassemble+0x3ea>
movw   $0x20,0x4(%r15)
movl   $0x68737570,(%r15)
shr    %eax
mov    %edi,%ebx
cmp    $0x3,%eax
jne    1575 <Disassemble+0x425>
lea    0x2288(%rip),%rsi
jmp    1328 <Disassemble+0x1d8>
movzbl %bl,%eax
lea    0x395a(%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    0x21c2(%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    0x217e(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
mov    %rbx,%rdi
mov    %r14d,%edx
jmp    14ad <Disassemble+0x35d>
movabs $0x202c6c6820646461,%rax
6c 2c 20
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
shr    %bl
movzbl %bl,%eax
lea    0x386a(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
jmp    14ba <Disassemble+0x36a>
shr    %eax
lea    0x1f4c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x746572,(%r15)
jmp    14c1 <Disassemble+0x371>
shr    %eax
cmp    $0x2,%eax
je     1626 <Disassemble+0x4d6>
test   %eax,%eax
jne    168e <Disassemble+0x53e>
movw   $0x20,0x4(%r15)
movl   $0x6c6c6163,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x210c(%rip),%rsi
jmp    161a <Disassemble+0x4ca>
mov    %eax,%eax
jmp    1577 <Disassemble+0x427>
mov    %eax,%eax
lea    0x3802(%rip),%rcx
jmp    120f <Disassemble+0xbf>
movl   $0x20726a,(%r15)
and    $0x3,%ebx
lea    0x380c(%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    149e <Disassemble+0x34e>
movabs $0x61202c6661207865,%rax
2c 20 61
mov    %rax,(%r15)
movl   $0x276661,0x7(%r15)
jmp    14c1 <Disassemble+0x371>
movw   $0x20,0x4(%r15)
movl   $0x7a6e6a64,(%r15)
jmp    1600 <Disassemble+0x4b0>
movl   $0x20726a,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%eax
add    %r12d,%eax
add    $0x2,%eax
movzbl %al,%edx
lea    0x204d(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %edi,%ebp
jmp    14aa <Disassemble+0x35a>
add    $0x1,%r12d
movzwl %r12w,%eax
movzbl 0x0(%r13,%rax,1),%eax
mov    %eax,%ecx
and    $0xc0,%cl
cmp    $0x80,%cl
je     19f8 <Disassemble+0x8a8>
cmp    $0x40,%cl
jne    14c1 <Disassemble+0x371>
mov    %eax,%ecx
shr    $0x3,%ecx
and    $0x7,%ecx
mov    %eax,%edx
and    $0x7,%edx
lea    0x19d1(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
mov    %edi,%ebx
movl   $0x206e69,(%r15)
cmp    $0x6,%cl
jne    1fd6 <Disassemble+0xe86>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x66,(%r15,%rax,1)
jmp    1fe9 <Disassemble+0xe99>
test   $0x20,%r14b
lea    0x214f(%rip),%rax
lea    0x2145(%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     14c1 <Disassemble+0x371>
movzbl %al,%eax
lea    0x197a(%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    0x1f50(%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    0x35f5(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r14d,%edi
jmp    14c1 <Disassemble+0x371>
movabs $0x6228202c6120646c,%rax
20 28 62
mov    %rax,(%r15)
movl   $0x296362,0x7(%r15)
jmp    14c1 <Disassemble+0x371>
movabs $0x2c2965642820646c,%rax
65 29 2c
mov    %rax,(%r15)
movl   $0x61202c,0x7(%r15)
jmp    14c1 <Disassemble+0x371>
movabs $0x6428202c6120646c,%rax
20 28 64
mov    %rax,(%r15)
movl   $0x296564,0x7(%r15)
jmp    14c1 <Disassemble+0x371>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1eae(%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    14c1 <Disassemble+0x371>
movabs $0x28202c6c6820646c,%rax
2c 20 28
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    1848 <Disassemble+0x6f8>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1e42(%rip),%rsi
jmp    18ec <Disassemble+0x79c>
movabs $0x28202c6120646c,%rax
mov    %rax,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1e1f(%rip),%rsi
jmp    1949 <Disassemble+0x7f9>
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    0x1bd8(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
lea    0x1c58(%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    0x347f(%rip),%rax
mov    (%rax,%rbx,8),%rsi
mov    %r15,%rdi
jmp    14ba <Disassemble+0x36a>
movw   $0x28,0x4(%r15)
movl   $0x2074756f,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
lea    0x1d7b(%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    14c1 <Disassemble+0x371>
movabs $0x28202c6120646c,%rax
add    $0x9fd,%rax
mov    %rax,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
lea    0x1d1e(%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    14c1 <Disassemble+0x371>
movabs $0x2c29707328207865,%rax
70 29 2c
mov    %rax,(%r15)
movl   $0x6c6820,0x8(%r15)
jmp    14c1 <Disassemble+0x371>
movabs $0x68202c6564207865,%rax
2c 20 68
jmp    19e9 <Disassemble+0x899>
movb   $0x0,0x2(%r15)
movw   $0x6964,(%r15)
jmp    14c1 <Disassemble+0x371>
movb   $0x0,0x2(%r15)
movw   $0x6965,(%r15)
jmp    14c1 <Disassemble+0x371>
movl   $0x787865,(%r15)
jmp    14c1 <Disassemble+0x371>
movabs $0x296c682820706a,%rax
mov    %rax,(%r15)
jmp    14c1 <Disassemble+0x371>
movabs $0x68202c707320646c,%rax
2c 20 68
mov    %rax,(%r15)
movw   $0x6c,0x8(%r15)
jmp    14c1 <Disassemble+0x371>
and    $0x1f,%eax
lea    0x1b72(%rip),%rcx
jmp    137a <Disassemble+0x22a>
movb   $0x0,0x4(%r15)
movl   $0x20746962,(%r15)
jmp    1a2f <Disassemble+0x8df>
movb   $0x0,0x4(%r15)
movl   $0x20736572,(%r15)
jmp    1a2f <Disassemble+0x8df>
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    0x32de(%rip),%rcx
jmp    1516 <Disassemble+0x3c6>
movl   $0x20646c,(%r15)
and    $0x38,%ebp
lea    0x32c8(%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    1f3d <Disassemble+0xded>
mov    %edi,%ebx
movabs $0x2c2963282074756f,%rax
63 29 2c
mov    %rax,(%r15)
movw   $0x20,0x8(%r15)
cmp    $0x6,%cl
jne    2008 <Disassemble+0xeb8>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x30,(%r15,%rax,1)
mov    %ebx,%edi
jmp    14c1 <Disassemble+0x371>
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    0x3270(%rip),%rax
mov    (%rax,%rbx,4),%rsi
mov    %r15,%rdi
jmp    14ba <Disassemble+0x36a>
mov    %edi,%r14d
movzbl %cl,%ebp
test   $0x1,%cl
jne    2010 <Disassemble+0xec0>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1b30(%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    0x3205(%rip),%rax
jmp    174b <Disassemble+0x5fb>
movzbl %cl,%eax
lea    0x198a(%rip),%rcx
jmp    137a <Disassemble+0x22a>
movzbl %cl,%eax
lea    0x199b(%rip),%rcx
jmp    137a <Disassemble+0x22a>
movl   $0x206d69,(%r15)
cmp    $0x5e,%al
je     2052 <Disassemble+0xf02>
cmp    $0x56,%al
je     206a <Disassemble+0xf1a>
cmp    $0x46,%al
jne    14c1 <Disassemble+0x371>
mov    %edi,%ebx
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movw   $0x30,(%r15,%rax,1)
jmp    14c1 <Disassemble+0x371>
movzbl %cl,%eax
lea    0x1975(%rip),%rcx
jmp    137a <Disassemble+0x22a>
movabs $0x28202c6120646461,%rax
2c 20 28
jmp    1c2a <Disassemble+0xada>
movabs $0x28202c6120636461,%rax
2c 20 28
jmp    1c2a <Disassemble+0xada>
movabs $0x28202c6120627573,%rax
2c 20 28
jmp    1c2a <Disassemble+0xada>
movabs $0x28202c6120636273,%rax
2c 20 28
jmp    1c2a <Disassemble+0xada>
movabs $0x28202c6120646e61,%rax
2c 20 28
jmp    1c2a <Disassemble+0xada>
movabs $0x28202c6120726f78,%rax
2c 20 28
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    1f36 <Disassemble+0xde6>
movabs $0x28202c6120646c,%rax
add    $0xe03,%rax
jmp    1f33 <Disassemble+0xde3>
movabs $0x28202c6120646c,%rax
add    $0xbf7,%rax
jmp    1f33 <Disassemble+0xde3>
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    0x17ae(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
lea    0x195e(%rip),%rcx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
jmp    20d3 <Disassemble+0xf83>
movb   $0x0,0x4(%r15)
movl   $0x20706f70,(%r15)
jmp    1e3e <Disassemble+0xcee>
movabs $0x2c29707328207865,%rax
70 29 2c
mov    %rax,(%r15)
movw   $0x20,0x8(%r15)
jmp    1e3e <Disassemble+0xcee>
movw   $0x20,0x4(%r15)
movl   $0x68737570,(%r15)
jmp    1e3e <Disassemble+0xcee>
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    14c1 <Disassemble+0x371>
movabs $0x202c707320646c,%rax
mov    %rax,(%r15)
jmp    1e3e <Disassemble+0xcee>
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    14c1 <Disassemble+0x371>
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    14c1 <Disassemble+0x371>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl 0x1(%rbx,%r13,1),%edx
lea    0x18c5(%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    14ba <Disassemble+0x36a>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1e3e <Disassemble+0xcee>
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    14b4 <Disassemble+0x364>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
lea    0xc(%rsp),%rsi
jmp    1326 <Disassemble+0x1d6>
movw   $0x28,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1f36 <Disassemble+0xde6>
movw   $0x28,0x4(%r15)
movl   $0x20636564,(%r15)
jmp    1f36 <Disassemble+0xde6>
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    0x17c1(%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    1752 <Disassemble+0x602>
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    14c1 <Disassemble+0x371>
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    0x1706(%rip),%rsi
lea    0x10(%rsp),%rbx
jmp    1950 <Disassemble+0x800>
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    1440 <Disassemble+0x2f0>
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    0x16a4(%rip),%rsi
jmp    1f61 <Disassemble+0xe11>
lea    0x2d63(%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    14c1 <Disassemble+0x371>
movzbl %cl,%eax
jmp    1208 <Disassemble+0xb8>
movl   $0x20646c,(%r15)
shr    %ebp
lea    0x2d60(%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    0x162b(%rip),%rsi
jmp    213b <Disassemble+0xfeb>
mov    %edi,%ebx
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movw   $0x32,(%r15,%rax,1)
jmp    14c1 <Disassemble+0x371>
mov    %edi,%ebx
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%edi
movw   $0x31,(%r15,%rax,1)
jmp    14c1 <Disassemble+0x371>
movb   $0x0,0x4(%r15)
movl   $0x20746962,(%r15)
jmp    20aa <Disassemble+0xf5a>
movb   $0x0,0x4(%r15)
movl   $0x20736572,(%r15)
jmp    20aa <Disassemble+0xf5a>
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     2103 <Disassemble+0xfb3>
lea    0x2c5e(%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    0x152c(%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    14c1 <Disassemble+0x371>

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

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