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


x86 assembly (clang, -O0):
<Disassemble>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%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     17bc <Disassemble+0x67c>
jmp    11b2 <Disassemble+0x72>
mov    -0x7c(%rbp),%eax
sub    $0x80,%eax
je     183a <Disassemble+0x6fa>
jmp    11c5 <Disassemble+0x85>
mov    -0x7c(%rbp),%eax
sub    $0xc0,%eax
je     1873 <Disassemble+0x733>
jmp    2f5a <Disassemble+0x1e1a>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0x88(%rbp)
sub    $0x7,%rax
ja     17b7 <Disassemble+0x677>
mov    -0x88(%rbp),%rax
lea    0x2239(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl -0x1e(%rbp),%eax
mov    %rax,-0x90(%rbp)
sub    $0x3,%rax
ja     12f8 <Disassemble+0x1b8>
mov    -0x90(%rbp),%rax
lea    0x224d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2283(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x2272(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x2268(%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
lea    0x2243(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x2227(%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
lea    0x21f4(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1370 <Disassemble+0x230>
mov    -0x18(%rbp),%rdi
lea    0x21d8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
and    $0x3,%eax
movslq %eax,%rcx
lea    0x3d93(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x22ce(%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
lea    0x2177(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17b7 <Disassemble+0x677>
movzbl -0x1d(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     13b8 <Disassemble+0x278>
mov    -0x18(%rbp),%rdi
lea    0x214f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3ce6(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    143e <Disassemble+0x2fe>
mov    -0x18(%rbp),%rdi
lea    0x2125(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3cb3(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x220e(%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    0x20a9(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17b7 <Disassemble+0x677>
movzbl -0x1e(%rbp),%eax
mov    %rax,-0x98(%rbp)
sub    $0x7,%rax
ja     1672 <Disassemble+0x532>
mov    -0x98(%rbp),%rax
lea    0x1fee(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x2072(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1672 <Disassemble+0x532>
mov    -0x18(%rbp),%rdi
lea    0x2068(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1672 <Disassemble+0x532>
mov    -0x18(%rbp),%rdi
lea    0x205e(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1672 <Disassemble+0x532>
mov    -0x18(%rbp),%rdi
lea    0x2054(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1672 <Disassemble+0x532>
mov    -0x18(%rbp),%rdi
lea    0x204a(%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    0x1fcc(%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    0x20ac(%rip),%rsi
call   1050 <strcat@plt>
jmp    1672 <Disassemble+0x532>
mov    -0x18(%rbp),%rdi
lea    0x1fe2(%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    0x1f5f(%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    0x2063(%rip),%rsi
call   1050 <strcat@plt>
jmp    1672 <Disassemble+0x532>
mov    -0x18(%rbp),%rdi
lea    0x1f70(%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    0x1ef2(%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    0x1ef2(%rip),%rsi
call   1050 <strcat@plt>
jmp    1672 <Disassemble+0x532>
mov    -0x18(%rbp),%rdi
lea    0x1f11(%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    0x1e85(%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    0x1f89(%rip),%rsi
call   1050 <strcat@plt>
jmp    17b7 <Disassemble+0x677>
movzbl -0x1d(%rbp),%eax
and    $0x8,%eax
cmp    $0x0,%eax
je     169c <Disassemble+0x55c>
mov    -0x18(%rbp),%rdi
lea    0x1e9b(%rip),%rsi
call   1030 <strcpy@plt>
jmp    16ac <Disassemble+0x56c>
mov    -0x18(%rbp),%rdi
lea    0x1e8b(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x39cf(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17b7 <Disassemble+0x677>
mov    -0x18(%rbp),%rdi
lea    0x1e58(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3960(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17b7 <Disassemble+0x677>
mov    -0x18(%rbp),%rdi
lea    0x1e24(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3931(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    17b7 <Disassemble+0x677>
mov    -0x18(%rbp),%rdi
lea    0x1db0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3902(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1e9d(%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    0x1db3(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    17b7 <Disassemble+0x677>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3982(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2f5a <Disassemble+0x1e1a>
movzbl -0x1e(%rbp),%eax
movzbl -0x1f(%rbp),%ecx
cmp    %ecx,%eax
jne    17e1 <Disassemble+0x6a1>
mov    -0x18(%rbp),%rdi
lea    0x1d8a(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1835 <Disassemble+0x6f5>
mov    -0x18(%rbp),%rdi
lea    0x1cfc(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x384e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1de9(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x3824(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f5a <Disassemble+0x1e1a>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x38a5(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x37eb(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f5a <Disassemble+0x1e1a>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xa0(%rbp)
sub    $0x7,%rax
ja     2f55 <Disassemble+0x1e15>
mov    -0xa0(%rbp),%rax
lea    0x176a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1cbc(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x37f0(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2f55 <Disassemble+0x1e15>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1961 <Disassemble+0x821>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,%ecx
mov    %rcx,-0xa8(%rbp)
sub    $0x3,%eax
ja     195c <Disassemble+0x81c>
mov    -0xa8(%rbp),%rax
lea    0x1b20(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1c53(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195c <Disassemble+0x81c>
mov    -0x18(%rbp),%rdi
lea    0x1c42(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195c <Disassemble+0x81c>
mov    -0x18(%rbp),%rdi
lea    0x1c31(%rip),%rsi
call   1030 <strcpy@plt>
jmp    195c <Disassemble+0x81c>
mov    -0x18(%rbp),%rdi
lea    0x1c24(%rip),%rsi
call   1030 <strcpy@plt>
jmp    19b9 <Disassemble+0x879>
mov    -0x18(%rbp),%rdi
lea    0x1c18(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    1996 <Disassemble+0x856>
mov    -0x18(%rbp),%rdi
lea    0x1bfd(%rip),%rsi
call   1050 <strcat@plt>
jmp    19b4 <Disassemble+0x874>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x36e5(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    19b9 <Disassemble+0x879>
jmp    2f55 <Disassemble+0x1e15>
mov    -0x18(%rbp),%rdi
lea    0x1bc3(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x36d1(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1c0c(%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    0x1aa7(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f55 <Disassemble+0x1e15>
movzbl -0x1e(%rbp),%eax
mov    %rax,-0xb0(%rbp)
sub    $0x7,%rax
ja     1da2 <Disassemble+0xc62>
mov    -0xb0(%rbp),%rax
lea    0x199c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x1b10(%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    0x1a1e(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    1da2 <Disassemble+0xc62>
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     1b5c <Disassemble+0xa1c>
jmp    1b1c <Disassemble+0x9dc>
mov    -0xb4(%rbp),%eax
sub    $0x40,%eax
je     1ba5 <Disassemble+0xa65>
jmp    1b30 <Disassemble+0x9f0>
mov    -0xb4(%rbp),%eax
sub    $0x80,%eax
je     1bfb <Disassemble+0xabb>
jmp    1b46 <Disassemble+0xa06>
mov    -0xb4(%rbp),%eax
sub    $0xc0,%eax
je     1c51 <Disassemble+0xb11>
jmp    1ca2 <Disassemble+0xb62>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x3603(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x1a7f(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x34b9(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca2 <Disassemble+0xb62>
mov    -0x18(%rbp),%rdi
lea    0x19fb(%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    0x1a3a(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x3463(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca2 <Disassemble+0xb62>
mov    -0x18(%rbp),%rdi
lea    0x19aa(%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    0x19e4(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x340d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1ca2 <Disassemble+0xb62>
mov    -0x18(%rbp),%rdi
lea    0x1959(%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    0x198e(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1f(%rbp),%eax
mov    %eax,%ecx
lea    0x33b7(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    1da2 <Disassemble+0xc62>
mov    -0x18(%rbp),%rdi
lea    0x1908(%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    0x1863(%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    0x18cd(%rip),%rsi
call   1050 <strcat@plt>
jmp    1da2 <Disassemble+0xc62>
mov    -0x18(%rbp),%rdi
lea    0x18bc(%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    0x180d(%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    0x18ad(%rip),%rsi
call   1050 <strcat@plt>
jmp    1da2 <Disassemble+0xc62>
mov    -0x18(%rbp),%rdi
lea    0x186e(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da2 <Disassemble+0xc62>
mov    -0x18(%rbp),%rdi
lea    0x1865(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da2 <Disassemble+0xc62>
mov    -0x18(%rbp),%rdi
lea    0x185a(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1da2 <Disassemble+0xc62>
mov    -0x18(%rbp),%rdi
lea    0x1848(%rip),%rsi
call   1030 <strcpy@plt>
jmp    2f55 <Disassemble+0x1e15>
mov    -0x18(%rbp),%rdi
lea    0x1836(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x32e8(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1823(%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    0x16be(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f55 <Disassemble+0x1e15>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     2e72 <Disassemble+0x1d32>
movzbl -0x1e(%rbp),%eax
shr    %eax
mov    %eax,-0xb8(%rbp)
test   %eax,%eax
je     1e6b <Disassemble+0xd2b>
jmp    1e57 <Disassemble+0xd17>
mov    -0xb8(%rbp),%eax
sub    $0x2,%eax
je     1ec8 <Disassemble+0xd88>
jmp    2214 <Disassemble+0x10d4>
mov    -0x18(%rbp),%rdi
lea    0x1772(%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    0x1624(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e6d <Disassemble+0x1d2d>
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     1f29 <Disassemble+0xde9>
jmp    1f13 <Disassemble+0xdd3>
mov    -0xbc(%rbp),%eax
sub    $0x80,%eax
je     21f1 <Disassemble+0x10b1>
jmp    220f <Disassemble+0x10cf>
movzbl -0x1f(%rbp),%eax
mov    %rax,-0xc8(%rbp)
sub    $0x7,%rax
ja     21ec <Disassemble+0x10ac>
mov    -0xc8(%rbp),%rax
lea    0x10d4(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x168e(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x30da(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1668(%rip),%rsi
call   1050 <strcat@plt>
jmp    21ec <Disassemble+0x10ac>
mov    -0x18(%rbp),%rdi
lea    0x1659(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x309b(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    21ec <Disassemble+0x10ac>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     1fe8 <Disassemble+0xea8>
mov    -0x18(%rbp),%rdi
lea    0x1624(%rip),%rsi
call   1030 <strcpy@plt>
jmp    1ff8 <Disassemble+0xeb8>
mov    -0x18(%rbp),%rdi
lea    0x1613(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x1607(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3073(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    21ec <Disassemble+0x10ac>
movzbl -0x1e(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     20d6 <Disassemble+0xf96>
mov    -0x18(%rbp),%rdi
lea    0x14a2(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x3030(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x163f(%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    0x1426(%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    0x152a(%rip),%rsi
call   1050 <strcat@plt>
jmp    215c <Disassemble+0x101c>
mov    -0x18(%rbp),%rdi
lea    0x1437(%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    0x13b9(%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    0x14d7(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x2f3d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    21ec <Disassemble+0x10ac>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x303e(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    21ec <Disassemble+0x10ac>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x305f(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    21ec <Disassemble+0x10ac>
mov    -0x18(%rbp),%rdi
lea    0x1477(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
add    $0x30,%eax
sub    $0x1,%eax
mov    %al,-0x70(%rbp)
movb   $0x0,-0x6f(%rbp)
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    21ec <Disassemble+0x10ac>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x304d(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    220f <Disassemble+0x10cf>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x1f,%eax
movslq %eax,%rcx
lea    0x306a(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
jmp    2e6d <Disassemble+0x1d2d>
movzbl -0x1d(%rbp),%eax
mov    %al,%cl
lea    0x1466(%rip),%rax
lea    0x1462(%rip),%rsi
test   $0x20,%cl
cmovne %rax,%rsi
lea    -0x73(%rbp),%rdi
call   1030 <strcpy@plt>
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%edx
add    $0x1,%edx
mov    %dx,%cx
mov    %cx,-0x2(%rbp)
mov    %edx,%ecx
movzwl %cx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1d(%rbp)
movzbl -0x1d(%rbp),%eax
add    $0xfffffff7,%eax
mov    %eax,%ecx
mov    %rcx,-0xd0(%rbp)
sub    $0xf0,%eax
ja     2e68 <Disassemble+0x1d28>
mov    -0xd0(%rbp),%rax
lea    0xdc2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rdi
lea    0x13fb(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x13e3(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x13c9(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x13b6(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x11f2(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x12fe(%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    0x1187(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x11a8(%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    0x112a(%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    0x1236(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x1148(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x1281(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x11e8(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x109d(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x1253(%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    0x1032(%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    0x1136(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x1058(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x11a5(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x118e(%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    0x1001(%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    0x10a1(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x113a(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x111b(%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    0xf8e(%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    0x102e(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xf3b(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x10a8(%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    0xf1b(%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    0xfd5(%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    0xeda(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x100c(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x100c(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xe35(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
sar    $0x3,%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x2980(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xfcf(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xfa1(%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    0xe14(%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    0xeb4(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xdc1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xf2e(%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    0xda1(%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    0xe5b(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
movzbl -0x1d(%rbp),%eax
and    $0x7,%eax
movslq %eax,%rcx
lea    0x2881(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xec7(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xe9d(%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    0xd10(%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    0xdb0(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xe5b(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xe2a(%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    0xc9d(%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    0xd3d(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xdf1(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xdb7(%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    0xc2a(%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    0xcca(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xd86(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xd44(%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    0xbb7(%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    0xc57(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xd19(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xcd1(%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    0xb44(%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    0xbe4(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xcaf(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xc5e(%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    0xad1(%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    0xb71(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xc44(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xbeb(%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    0xa5e(%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    0xafe(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xbda(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb78(%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    0x9eb(%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    0xa8b(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xb6e(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0xb05(%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    0x978(%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    0xa18(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0x991(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xae0(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xac8(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xaac(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x980(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x18(%rbp),%rdi
lea    0xa7f(%rip),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2e68 <Disassemble+0x1d28>
mov    -0x10(%rbp),%rax
movzwl -0x2(%rbp),%ecx
add    $0x2,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1d(%rbp)
mov    -0x1d(%rbp),%al
shr    $0x3,%al
and    $0x7,%al
mov    %al,-0x1e(%rbp)
movb   $0x0,-0x6f(%rbp)
movzbl -0x1d(%rbp),%eax
and    $0xc0,%eax
mov    %eax,-0xd4(%rbp)
je     2d1c <Disassemble+0x1bdc>
jmp    2cdc <Disassemble+0x1b9c>
mov    -0xd4(%rbp),%eax
sub    $0x40,%eax
je     2d4b <Disassemble+0x1c0b>
jmp    2cf0 <Disassemble+0x1bb0>
mov    -0xd4(%rbp),%eax
sub    $0x80,%eax
je     2d87 <Disassemble+0x1c47>
jmp    2d06 <Disassemble+0x1bc6>
mov    -0xd4(%rbp),%eax
sub    $0xc0,%eax
je     2dc3 <Disassemble+0x1c83>
jmp    2dfa <Disassemble+0x1cba>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x2643(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1030 <strcpy@plt>
mov    -0x18(%rbp),%rdi
lea    0x8bf(%rip),%rsi
call   1050 <strcat@plt>
jmp    2dfa <Disassemble+0x1cba>
mov    -0x18(%rbp),%rdi
lea    0x855(%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    0x894(%rip),%rsi
call   1050 <strcat@plt>
jmp    2dfa <Disassemble+0x1cba>
mov    -0x18(%rbp),%rdi
lea    0x81e(%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    0x858(%rip),%rsi
call   1050 <strcat@plt>
jmp    2dfa <Disassemble+0x1cba>
mov    -0x18(%rbp),%rdi
lea    0x7e7(%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    0x81c(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x8b8(%rip),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    -0x73(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x18(%rbp),%rdi
lea    0x880(%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    0x6f3(%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    0x793(%rip),%rsi
call   1050 <strcat@plt>
jmp    2e6d <Disassemble+0x1d2d>
jmp    2eca <Disassemble+0x1d8a>
mov    -0x18(%rbp),%rdi
lea    0x882(%rip),%rsi
call   1030 <strcpy@plt>
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
cmp    $0x3,%eax
jne    2ea7 <Disassemble+0x1d67>
mov    -0x18(%rbp),%rdi
lea    0x6ec(%rip),%rsi
call   1050 <strcat@plt>
jmp    2ec5 <Disassemble+0x1d85>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
sar    $0x1,%eax
movslq %eax,%rcx
lea    0x21d4(%rip),%rax
mov    (%rax,%rcx,8),%rsi
call   1050 <strcat@plt>
jmp    2eca <Disassemble+0x1d8a>
jmp    2f55 <Disassemble+0x1e15>
mov    -0x18(%rbp),%rdi
movzbl -0x1e(%rbp),%eax
mov    %eax,%ecx
lea    0x2210(%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    0x631(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f55 <Disassemble+0x1e15>
mov    -0x18(%rbp),%rdi
lea    0x7e8(%rip),%rsi
call   1030 <strcpy@plt>
lea    -0x70(%rbp),%rdi
movzbl -0x1d(%rbp),%edx
and    $0x38,%edx
lea    0x5f6(%rip),%rsi
mov    $0x0,%al
call   1060 <sprintf@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1050 <strcat@plt>
jmp    2f5a <Disassemble+0x1e1a>
mov    -0x78(%rbp),%eax
add    $0xe0,%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,%esi
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     1549 <Disassemble+0x3f9>
mov    %ebx,%eax
lea    0x2304(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x706f6e,(%r15)
jmp    15f2 <Disassemble+0x4a2>
cmp    %bpl,%bl
jne    1242 <Disassemble+0xf2>
movb   $0x0,0x4(%r15)
movl   $0x746c6168,(%r15)
jmp    15f2 <Disassemble+0x4a2>
movzbl %bl,%eax
lea    0x3bab(%rip),%rcx
mov    %esi,%ebx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzbl %bpl,%eax
lea    0x3af2(%rip),%rcx
jmp    1308 <Disassemble+0x1b8>
movzbl %bpl,%eax
lea    0x1df2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movb   $0x0,0x4(%r15)
movl   $0x20746572,(%r15)
movzbl %bl,%eax
lea    0x3b23(%rip),%rcx
jmp    1306 <Disassemble+0x1b6>
movl   $0x20646c,(%r15)
movzbl %bl,%eax
lea    0x3aad(%rip),%r14
mov    %esi,%ebx
mov    (%r14,%rax,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    (%r14,%rbp,8),%rsi
jmp    130c <Disassemble+0x1bc>
mov    %esi,%ebp
test   $0x8,%r14b
jne    14b5 <Disassemble+0x365>
movl   $0x20646c,(%r15)
shr    %bl
movzbl %bl,%eax
lea    0x3aa2(%rip),%rcx
jmp    13eb <Disassemble+0x29b>
movzbl %bl,%eax
lea    0x21f7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movabs $0x2c2963622820646c,%rax
63 29 2c
jmp    1771 <Disassemble+0x621>
mov    %esi,%ebp
test   $0x8,%r14b
jne    14c9 <Disassemble+0x379>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    14d5 <Disassemble+0x385>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    12fc <Disassemble+0x1ac>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
movzbl %bl,%eax
lea    0x39fa(%rip),%rcx
mov    %esi,%ebx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %ebx,%esi
jmp    15f2 <Disassemble+0x4a2>
movl   $0x20646c,(%r15)
movzbl %bl,%eax
lea    0x39d4(%rip),%rcx
mov    %esi,%ebp
mov    (%rcx,%rax,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)
jmp    1476 <Disassemble+0x326>
movzbl %bl,%eax
lea    0x2176(%rip),%rcx
mov    %esi,%ebx
movslq (%rcx,%rax,4),%rsi
add    %rcx,%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    %ebx,%esi
jmp    15f2 <Disassemble+0x4a2>
movzbl %bl,%eax
test   $0x1,%bl
jne    14ed <Disassemble+0x39d>
mov    %esi,%ebx
movb   $0x0,0x4(%r15)
movl   $0x20706f70,(%r15)
shr    %eax
cmp    $0x3,%eax
je     1442 <Disassemble+0x2f2>
mov    %eax,%eax
lea    0x399c(%rip),%rcx
jmp    1308 <Disassemble+0x1b8>
movl   $0x20706a,(%r15)
jmp    13df <Disassemble+0x28f>
movzbl %bl,%eax
lea    0x2088(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x20706a,(%r15)
jmp    152c <Disassemble+0x3dc>
movw   $0x20,0x4(%r15)
movl   $0x6c6c6163,(%r15)
movzbl %bl,%eax
lea    0x3977(%rip),%rcx
mov    %esi,%ebp
mov    (%rcx,%rax,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)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
jmp    15cf <Disassemble+0x47f>
movzbl %bl,%eax
test   $0x1,%bl
jne    150b <Disassemble+0x3bb>
mov    %esi,%ebx
movw   $0x20,0x4(%r15)
movl   $0x68737570,(%r15)
shr    %eax
cmp    $0x3,%eax
jne    153b <Disassemble+0x3eb>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x6661,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
mov    %ebx,%esi
jmp    15f2 <Disassemble+0x4a2>
movzbl %bl,%eax
lea    0x3938(%rip),%rcx
mov    %esi,%ebp
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
lea    0x21f9(%rip),%rsi
jmp    15d6 <Disassemble+0x486>
movb   $0x0,0x4(%r15)
movl   $0x20747372,(%r15)
and    $0x38,%r14d
mov    %esi,%ebp
lea    0x21db(%rip),%rsi
lea    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    %r14d,%edx
jmp    15de <Disassemble+0x48e>
movabs $0x202c6c6820646461,%rax
6c 2c 20
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    14d5 <Disassemble+0x385>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
shr    %bl
movzbl %bl,%eax
lea    0x385f(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
jmp    15eb <Disassemble+0x49b>
shr    %eax
lea    0x1f7e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movl   $0x746572,(%r15)
jmp    15f2 <Disassemble+0x4a2>
shr    %eax
cmp    $0x2,%eax
je     1603 <Disassemble+0x4b3>
test   %eax,%eax
jne    1677 <Disassemble+0x527>
movw   $0x20,0x4(%r15)
movl   $0x6c6c6163,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
jmp    15cd <Disassemble+0x47d>
mov    %eax,%eax
lea    0x37fc(%rip),%rcx
jmp    1308 <Disassemble+0x1b8>
movl   $0x20726a,(%r15)
and    $0x3,%ebx
lea    0x3806(%rip),%rax
mov    %esi,%ebp
mov    (%rax,%rbx,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)
movzwl %r12w,%eax
movsbl 0x1(%rax,%r13,1),%ecx
lea    (%rax,%rcx,1),%edx
add    $0x2,%edx
jmp    15cf <Disassemble+0x47f>
movabs $0x61202c6661207865,%rax
2c 20 61
mov    %rax,(%r15)
movl   $0x276661,0x7(%r15)
jmp    15f2 <Disassemble+0x4a2>
movw   $0x20,0x4(%r15)
movl   $0x7a6e6a64,(%r15)
jmp    15bd <Disassemble+0x46d>
movl   $0x20726a,(%r15)
movzwl %r12w,%eax
movsbl 0x1(%rax,%r13,1),%ecx
lea    (%rax,%rcx,1),%edx
add    $0x2,%edx
mov    %esi,%ebp
lea    0x204e(%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,%esi
mov    %esi,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%r12d
movzwl %r12w,%eax
movzbl 0x0(%r13,%rax,1),%ecx
mov    %ecx,%eax
and    $0xc0,%al
cmp    $0x80,%al
je     19e8 <Disassemble+0x898>
cmp    $0x40,%al
jne    15f2 <Disassemble+0x4a2>
mov    %ecx,%eax
shr    $0x3,%eax
and    $0x7,%eax
and    $0x7,%ecx
lea    0x19fd(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
movl   $0x206e69,(%r15)
lea    0x36b6(%rip),%rcx
mov    %esi,%ebx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%esi
movl   $0x6328202c,(%r15,%rax,1)
63
movw   $0x29,0x4(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
test   $0x20,%r14b
lea    0x2121(%rip),%rax
lea    0x2117(%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     15f2 <Disassemble+0x4a2>
movzbl %al,%eax
lea    0x1991(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
mov    %esi,%r14d
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    0x1f80(%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   $0x2c29,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
and    $0x7,%ebp
lea    0x35c7(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r14d,%esi
jmp    15f2 <Disassemble+0x4a2>
movabs $0x6228202c6120646c,%rax
20 28 62
mov    %rax,(%r15)
movl   $0x296362,0x7(%r15)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x2c2965642820646c,%rax
65 29 2c
mov    %rax,(%r15)
movl   $0x61202c,0x7(%r15)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x6428202c6120646c,%rax
20 28 64
mov    %rax,(%r15)
movl   $0x296564,0x7(%r15)
jmp    15f2 <Disassemble+0x4a2>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
mov    %esi,%ebp
lea    0x1e6a(%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>
mov    %ebp,%esi
movl   $0x68202c29,(%r15,%rax,1)
68
movw   $0x6c,0x4(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x28202c6c6820646c,%rax
2c 20 28
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    186c <Disassemble+0x71c>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
mov    %esi,%ebp
lea    0x1dfe(%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>
mov    %ebp,%esi
movl   $0x61202c29,(%r15,%rax,1)
61
movb   $0x0,0x4(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movl   $0x282c61,0x3(%r15)
movl   $0x6120646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
mov    %esi,%ebp
lea    0x1da5(%rip),%rsi
jmp    1f8e <Disassemble+0xe3e>
mov    %esi,%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    0x1bb2(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
lea    0x351e(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x20,(%r15,%rax,1)
lea    0x341c(%rip),%rax
mov    (%rax,%rbx,8),%rsi
mov    %r15,%rdi
jmp    15eb <Disassemble+0x49b>
movw   $0x28,0x4(%r15)
movl   $0x2074756f,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
mov    %esi,%ebp
lea    0x1d6f(%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>
mov    %ebp,%esi
movl   $0x412c29,(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x28202c61206e69,%rax
mov    %rax,(%r15)
movzwl %r12w,%eax
movzbl 0x1(%rax,%r13,1),%edx
mov    %esi,%ebp
jmp    1f87 <Disassemble+0xe37>
movabs $0x2c29707328207865,%rax
70 29 2c
mov    %rax,(%r15)
movl   $0x6c6820,0x8(%r15)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x68202c6564207865,%rax
2c 20 68
mov    %rax,(%r15)
movw   $0x6c,0x8(%r15)
jmp    15f2 <Disassemble+0x4a2>
movb   $0x0,0x2(%r15)
movw   $0x6964,(%r15)
jmp    15f2 <Disassemble+0x4a2>
movb   $0x0,0x2(%r15)
movw   $0x6965,(%r15)
jmp    15f2 <Disassemble+0x4a2>
movl   $0x787865,(%r15)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x296c682820706a,%rax
mov    %rax,(%r15)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x6c682c707320646c,%rax
2c 68 6c
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    15f2 <Disassemble+0x4a2>
and    $0x1f,%ecx
lea    0x1b62(%rip),%rax
mov    %esi,%ebx
movslq (%rax,%rcx,4),%rsi
add    %rax,%rsi
jmp    1367 <Disassemble+0x217>
movb   $0x0,0x4(%r15)
movl   $0x20746962,(%r15)
jmp    1a28 <Disassemble+0x8d8>
movb   $0x0,0x4(%r15)
movl   $0x20736572,(%r15)
jmp    1a28 <Disassemble+0x8d8>
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   $0x2c,(%r15,%rax,1)
movzbl %bl,%eax
lea    0x32ab(%rip),%rcx
jmp    14e1 <Disassemble+0x391>
movl   $0x20646c,(%r15)
and    $0x38,%ebp
lea    0x3295(%rip),%rax
mov    %esi,%r14d
mov    0x0(%rbp,%rax,1),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x282c,(%r15,%rax,1)
movb   $0x0,0x2(%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    0x1bc7(%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>
mov    %r14d,%esi
movw   $0x29,(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x2c2963282074756f,%rcx
63 29 2c
mov    %rcx,(%r15)
movw   $0x20,0x8(%r15)
movzbl %al,%eax
jmp    12ff <Disassemble+0x1af>
movzbl %al,%ebx
test   $0x1,%al
mov    $0x636273,%eax
mov    $0x636461,%ecx
cmove  %eax,%ecx
mov    %ecx,(%r15)
mov    %r15,%rdi
mov    %esi,%ebp
call   1040 <strlen@plt>
movl   $0x2c4c4820,(%r15,%rax,1)
2c
movw   $0x20,0x4(%r15,%rax,1)
and    $0x6,%ebx
lea    0x3201(%rip),%rax
mov    (%rax,%rbx,4),%rsi
mov    %r15,%rdi
jmp    15eb <Disassemble+0x49b>
mov    %esi,%r14d
movzbl %al,%ebp
test   $0x1,%al
jne    201f <Disassemble+0xecf>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x1aae(%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   $0x2c29,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
shr    %ebp
lea    0x3192(%rip),%rax
jmp    1739 <Disassemble+0x5e9>
movzbl %al,%eax
lea    0x1937(%rip),%rcx
jmp    135e <Disassemble+0x20e>
movzbl %al,%eax
lea    0x1948(%rip),%rcx
jmp    135e <Disassemble+0x20e>
movl   $0x204d49,(%r15)
add    $0x2f,%eax
mov    %al,0x10(%rsp)
movb   $0x0,0x11(%rsp)
mov    %esi,%ebx
lea    0x10(%rsp),%rsi
jmp    130c <Disassemble+0x1bc>
movzbl %al,%eax
lea    0x193a(%rip),%rcx
jmp    135e <Disassemble+0x20e>
movabs $0x28202c4120646461,%rax
2c 20 28
jmp    1c58 <Disassemble+0xb08>
movabs $0x282c6120636461,%rax
jmp    1c46 <Disassemble+0xaf6>
movw   $0x28,0x4(%r15)
movl   $0x20627573,(%r15)
jmp    1f63 <Disassemble+0xe13>
movabs $0x28202c6120636273,%rax
2c 20 28
jmp    1c58 <Disassemble+0xb08>
movabs $0x282c6120636461,%rax
add    $0x10a00,%rax
mov    %rax,(%r15)
jmp    1f63 <Disassemble+0xe13>
movabs $0x28202c6120726f78,%rax
2c 20 28
mov    %rax,(%r15)
movb   $0x0,0x8(%r15)
jmp    1f63 <Disassemble+0xe13>
movl   $0x282c61,0x3(%r15)
movl   $0x6120726f,(%r15)
jmp    1f63 <Disassemble+0xe13>
movl   $0x282c61,0x3(%r15)
movl   $0x61207063,(%r15)
jmp    1f63 <Disassemble+0xe13>
mov    %esi,%r14d
movzbl 0x2(%rbx,%r13,1),%eax
movzbl %al,%ecx
shr    $0x3,%eax
and    $0x7,%eax
movb   $0x0,0x11(%rsp)
shr    $0x6,%rcx
lea    0x1785(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
lea    0x3121(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
mov    %r15,%rdi
call   1030 <strcpy@plt>
mov    $0x20,%bp
jmp    20a6 <Disassemble+0xf56>
movb   $0x0,0x4(%r15)
movl   $0x20706f70,(%r15)
jmp    1e62 <Disassemble+0xd12>
movabs $0x2c29707328207865,%rax
70 29 2c
mov    %rax,(%r15)
movw   $0x20,0x8(%r15)
jmp    1e62 <Disassemble+0xd12>
movw   $0x20,0x4(%r15)
movl   $0x68737570,(%r15)
jmp    1e62 <Disassemble+0xd12>
movb   $0x0,0x4(%r15)
movl   $0x2820706a,(%r15)
mov    %esi,%ebx
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%esi
movw   $0x29,(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movabs $0x202c707320646c,%rax
mov    %rax,(%r15)
jmp    1e62 <Disassemble+0xd12>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
mov    %esi,%ebx
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%esi
movl   $0x6362202c,(%r15,%rax,1)
63
movb   $0x0,0x4(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
mov    %esi,%ebx
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%esi
movl   $0x6564202c,(%r15,%rax,1)
65
movb   $0x0,0x4(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
movzwl 0x1(%rbx,%r13,1),%edx
mov    %esi,%ebp
lea    0x1845(%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)
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
jmp    15eb <Disassemble+0x49b>
movb   $0x0,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1e62 <Disassemble+0xd12>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
lea    0xc(%rsp),%rbx
mov    %r15,%rdi
mov    %esi,%ebp
mov    %rbx,%rsi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x2c,(%r15,%rax,1)
jmp    15e5 <Disassemble+0x495>
movb   $0x0,0x4(%r15)
movl   $0x20636564,(%r15)
mov    %esi,%ebx
lea    0xc(%rsp),%rsi
jmp    130c <Disassemble+0x1bc>
movw   $0x28,0x4(%r15)
movl   $0x20636e69,(%r15)
jmp    1f63 <Disassemble+0xe13>
movw   $0x28,0x4(%r15)
movl   $0x20636564,(%r15)
jmp    1f63 <Disassemble+0xe13>
movb   $0x0,0x4(%r15)
movl   $0x2820646c,(%r15)
mov    %esi,%r14d
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    0x17b4(%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>
movw   $0x2c29,(%r15,%rax,1)
movb   $0x0,0x2(%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    1740 <Disassemble+0x5f0>
movb   $0x0,0x4(%r15)
movl   $0x20646461,(%r15)
mov    %esi,%ebx
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %ebx,%esi
movl   $0x7073202c,(%r15,%rax,1)
70
movb   $0x0,0x4(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movl   $0x282c41,0x3(%r15)
movl   $0x4120646c,(%r15)
mov    %esi,%ebp
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    0x16f2(%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>
mov    %ebp,%esi
movw   $0x29,(%r15,%rax,1)
jmp    15f2 <Disassemble+0x4a2>
movl   $0x20646c,(%r15)
mov    %esi,%ebp
lea    0xc(%rsp),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x2c,(%r15,%rax,1)
movzwl 0x1(%rbx,%r13,1),%edx
jmp    15cf <Disassemble+0x47f>
movl   $0x20646c,(%r15)
mov    %esi,%ebp
lea    0xc(%rsp),%rsi
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
jmp    1878 <Disassemble+0x728>
movl   $0x20646c,(%r15)
shr    %ebp
lea    0x2d11(%rip),%rax
mov    (%rax,%rbp,8),%rsi
mov    %r15,%rdi
call   1060 <strcat@plt>
mov    %r15,%rdi
call   1040 <strlen@plt>
movw   $0x282c,(%r15,%rax,1)
movb   $0x0,0x2(%r15,%rax,1)
movzwl %r12w,%eax
movzwl 0x1(%rax,%r13,1),%edx
lea    0x15c3(%rip),%rsi
jmp    20eb <Disassemble+0xf9b>
movb   $0x0,0x4(%r15)
movl   $0x20746962,(%r15)
jmp    208e <Disassemble+0xf3e>
movb   $0x0,0x4(%r15)
movl   $0x20736572,(%r15)
jmp    208e <Disassemble+0xf3e>
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    $0x2c,%bp
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %bp,(%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    0x1595(%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,%esi
jmp    15f2 <Disassemble+0x4a2>

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

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