void disassemble(char *str, unsigned int inst) {
  unsigned short Imm;
  unsigned char OP, ALUOP, Rs2Sel, Rs2, Rs1Sel, Rs1, RdSel, Rd, IO, Imm2, SUBOP,
      Test;
  unsigned char LoadStore, BurstLen, RxByteAddr, Rx, Ro, RoSel, Rb;
  short BrOff;
  char tempstr[50];
  char *f1_inst[] = {"ADD", "ADC", "SUB", "SUC", "LSL", "LSR", "RSB", "RSC",
                     "AND", "OR",  "XOR", "NOT", "MIN", "MAX", "CLR", "SET"};
  char *f2_inst[] = {"JMP",      "JAL",      "LDI",      "LMBD",
                     "SCAN",     "HALT",     "RESERVED", "RESERVED",
                     "RESERVED", "RESERVED", "RESERVED", "RESERVED",
                     "RESERVED", "RESERVED", "RESERVED", "SLP"};
  char *f4_inst[] = {"xx", "LT", "EQ", "LE", "GT", "NE", "GE", "A"};
  char *f5_inst[] = {"xx", "BC", "BS", "xx"};
  char *f6_7_inst[] = {"SBBO", "LBBO"};
  char *f6_4_inst[] = {"SBCO", "LBCO"};
  char *sis[] = {".b0", ".b1", ".b2", ".b3", ".w0", ".w1", ".w2", ""};
  char *bytenum[] = {"", ".b1", ".b2", ".b3"};
  OP = (inst & 0xE0000000) >> 29;
  switch (OP) {
  case 0:
    ALUOP = (inst & 0x1E000000) >> 25;
    IO = (inst & 0x01000000) >> 24;
    Rs1Sel = (inst & 0x0000E000) >> 13;
    Rs1 = (inst & 0x00001F00) >> 8;
    RdSel = (inst & 0x000000E0) >> 5;
    Rd = (inst & 0x0000001F);
    if (IO) {
      Imm2 = (inst & 0x00FF0000) >> 16;
      sprintf(str, "%s R%u%s, R%u%s, 0x%02x", f1_inst[ALUOP], Rd, sis[RdSel],
              Rs1, sis[Rs1Sel], Imm2);
    } else {
      Rs2Sel = (inst & 0x00E00000) >> 21;
      Rs2 = (inst & 0x001F0000) >> 16;
      sprintf(str, "%s R%u%s, R%u%s, R%u%s", f1_inst[ALUOP], Rd, sis[RdSel],
              Rs1, sis[Rs1Sel], Rs2, sis[Rs2Sel]);
    }
    break;
  case 1:
    SUBOP = (inst & 0x1E000000) >> 25;
    switch (SUBOP) {
    case 0:
    case 1:
      IO = (inst & 0x01000000) >> 24;
      RdSel = (inst & 0x000000E0) >> 5;
      Rd = (inst & 0x0000001F);
      if (IO) {
        Imm = (inst & 0x00FFFF00) >> 8;
        if (SUBOP == 0)
          sprintf(str, "%s 0x%04x", f2_inst[SUBOP], Imm);
        else
          sprintf(str, "%s R%u%s, 0x%04x", f2_inst[SUBOP], Rd, sis[RdSel], Imm);
      } else {
        Rs2Sel = (inst & 0x00E00000) >> 21;
        Rs2 = (inst & 0x001F0000) >> 16;
        if (SUBOP == 0)
          sprintf(str, "%s R%u%s", f2_inst[SUBOP], Rs2, sis[Rs2Sel]);
        else
          sprintf(str, "%s R%u%s, R%u%s", f2_inst[SUBOP], Rd, sis[RdSel], Rs2,
                  sis[Rs2Sel]);
      }
      break;
    case 2:
      Imm = (inst & 0x00FFFF00) >> 8;
      RdSel = (inst & 0x000000E0) >> 5;
      Rd = (inst & 0x0000001F);
      sprintf(str, "%s R%u%s, 0x%04x", f2_inst[SUBOP], Rd, sis[RdSel], Imm);
      break;
    case 3:
      IO = (inst & 0x01000000) >> 24;
      Rs1Sel = (inst & 0x0000E000) >> 13;
      Rs1 = (inst & 0x00001F00) >> 8;
      RdSel = (inst & 0x000000E0) >> 5;
      Rd = (inst & 0x0000001F);
      Rs2Sel = (inst & 0x00E00000) >> 21;
      Rs2 = (inst & 0x001F0000) >> 16;
      Imm2 = (inst & 0x00FF0000) >> 16;
      if (IO) {
        sprintf(str, "%s R%u%s, R%u%s, 0x%04x", f2_inst[SUBOP], Rd, sis[RdSel],
                Rs1, sis[Rs1Sel], Imm2);
      } else {
        sprintf(str, "%s R%u%s, R%u%s, R%u%s", f2_inst[SUBOP], Rd, sis[RdSel],
                Rs1, sis[Rs1Sel], Rs2, sis[Rs2Sel]);
      }
      break;
    case 4:
      IO = (inst & 0x01000000) >> 24;
      RdSel = (inst & 0x000000E0) >> 5;
      Rd = (inst & 0x0000001F);
      Rs2Sel = (inst & 0x00E00000) >> 21;
      Rs2 = (inst & 0x001F0000) >> 16;
      Imm2 = (inst & 0x00FF0000) >> 16;
      if (IO) {
        sprintf(str, "%s R%u%s, 0x%04x", f2_inst[SUBOP], Rd, sis[RdSel], Rs1,
                sis[Rs1Sel], Imm2);
      } else {
        sprintf(str, "%s R%u%s, R%u%s", f2_inst[SUBOP], Rd, sis[RdSel], Rs2,
                sis[Rs2Sel]);
      }
      break;
    case 5:
      sprintf(str, "%s", f2_inst[SUBOP]);
      break;
    case 15:
      Imm = (inst & 0x00800000) >> 23;
      sprintf(str, "%s %u", f2_inst[SUBOP], Imm);
      break;
    default:
      sprintf(str, "UNKNOWN-F2");
      break;
    }
    break;
  case 2:
  case 3:
    Test = (inst & 0x38000000) >> 27;
    IO = (inst & 0x01000000) >> 24;
    Rs2Sel = (inst & 0x00E00000) >> 21;
    Rs2 = (inst & 0x001F0000) >> 16;
    Rs1Sel = (inst & 0x0000E000) >> 13;
    Rs1 = (inst & 0x00001F00) >> 8;
    Imm = (inst & 0x00FF0000) >> 16;
    BrOff = ((inst & 0x06000000) >> 17) | (inst & 0x000000FF);
    if (BrOff & 0x0200)
      BrOff |= 0xFC00;
    if (Test == 7) {
      sprintf(str, "QBA %d", BrOff);
    } else {
      if (IO) {
        sprintf(str, "QB%s %d, R%u%s, %u", f4_inst[Test], BrOff, Rs1,
                sis[Rs1Sel], Imm);
      } else {
        sprintf(str, "QB%s %d, R%u%s, R%u%s", f4_inst[Test], BrOff, Rs1,
                sis[Rs1Sel], Rs2, sis[Rs2Sel]);
      }
    }
    break;
  case 6:
    Test = (inst & 0x18000000) >> 27;
    IO = (inst & 0x01000000) >> 24;
    Rs2Sel = (inst & 0x00E00000) >> 21;
    Rs2 = (inst & 0x001F0000) >> 16;
    Rs1Sel = (inst & 0x0000E000) >> 13;
    Rs1 = (inst & 0x00001F00) >> 8;
    Imm = (inst & 0x001F0000) >> 16;
    BrOff = ((inst & 0x06000000) >> 17) | (inst & 0x000000FF);
    if (BrOff & 0x0200)
      BrOff |= 0xFC00;
    if (IO) {
      sprintf(str, "QB%s %d, R%u%s, %u", f5_inst[Test], BrOff, Rs1, sis[Rs1Sel],
              Imm);
    } else {
      sprintf(str, "QB%s %d, R%u%s, R%u%s", f5_inst[Test], BrOff, Rs1,
              sis[Rs1Sel], Rs2, sis[Rs2Sel]);
    }
    break;
  case 4:
  case 7:
    LoadStore = (inst & 0x10000000) >> 28;
    BurstLen = ((inst & 0x0E000000) >> 21) | ((inst & 0x0000E000) >> 12) |
               ((inst & 0x00000080) >> 7);
    IO = (inst & 0x01000000) >> 24;
    RxByteAddr = (inst & 0x00000060) >> 5;
    Rx = (inst & 0x0000001F);
    RoSel = (inst & 0x00E00000) >> 21;
    Ro = (inst & 0x001F0000) >> 16;
    Rb = (inst & 0x00001F00) >> 8;
    Imm = (inst & 0x00FF0000) >> 16;
    GetBurstLen(tempstr, BurstLen);
    if (OP == 7) {
      if (IO) {
        sprintf(str, "%s R%u%s, R%u, %u, %s", f6_7_inst[LoadStore], Rx,
                bytenum[RxByteAddr], Rb, Imm, tempstr);
      } else {
        sprintf(str, "%s R%u%s, R%u, R%u%s, %s", f6_7_inst[LoadStore], Rx,
                bytenum[RxByteAddr], Rb, Ro, sis[RoSel], tempstr);
      }
    } else {
      if (IO) {
        sprintf(str, "%s R%u%s, C%u, %u, %s", f6_4_inst[LoadStore], Rx,
                bytenum[RxByteAddr], Rb, Imm, tempstr);
      } else {
        sprintf(str, "%s R%u%s, C%u, R%u%s, %s", f6_4_inst[LoadStore], Rx,
                bytenum[RxByteAddr], Rb, Ro, sis[RoSel], tempstr);
      }
    }
    break;
  default:
    sprintf(str, "UNKNOWN");
    break;
  }
}


x86 assembly (clang, -O0):
<disassemble>:
push   %rbp
mov    %rsp,%rbp
sub    $0x270,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movaps 0x2b77(%rip),%xmm0
movaps %xmm0,-0x70(%rbp)
movaps 0x2b5c(%rip),%xmm0
movaps %xmm0,-0x80(%rbp)
movaps 0x2b41(%rip),%xmm0
movaps %xmm0,-0x90(%rbp)
movaps 0x2b23(%rip),%xmm0
movaps %xmm0,-0xa0(%rbp)
movaps 0x2b05(%rip),%xmm0
movaps %xmm0,-0xb0(%rbp)
movaps 0x2ae7(%rip),%xmm0
movaps %xmm0,-0xc0(%rbp)
movaps 0x2ac9(%rip),%xmm0
movaps %xmm0,-0xd0(%rbp)
movaps 0x2aab(%rip),%xmm0
movaps %xmm0,-0xe0(%rbp)
movaps 0x2b8d(%rip),%xmm0
movaps %xmm0,-0xf0(%rbp)
movaps 0x2b6f(%rip),%xmm0
movaps %xmm0,-0x100(%rbp)
movaps 0x2b51(%rip),%xmm0
movaps %xmm0,-0x110(%rbp)
movaps 0x2b33(%rip),%xmm0
movaps %xmm0,-0x120(%rbp)
movaps 0x2b15(%rip),%xmm0
movaps %xmm0,-0x130(%rbp)
movaps 0x2af7(%rip),%xmm0
movaps %xmm0,-0x140(%rbp)
movaps 0x2ad9(%rip),%xmm0
movaps %xmm0,-0x150(%rbp)
movaps 0x2abb(%rip),%xmm0
movaps %xmm0,-0x160(%rbp)
movaps 0x2b5d(%rip),%xmm0
movaps %xmm0,-0x170(%rbp)
movaps 0x2b3f(%rip),%xmm0
movaps %xmm0,-0x180(%rbp)
movaps 0x2b21(%rip),%xmm0
movaps %xmm0,-0x190(%rbp)
movaps 0x2b03(%rip),%xmm0
movaps %xmm0,-0x1a0(%rbp)
movaps 0x2b45(%rip),%xmm0
movaps %xmm0,-0x1b0(%rbp)
movaps 0x2b27(%rip),%xmm0
movaps %xmm0,-0x1c0(%rbp)
movaps 0x2b39(%rip),%xmm0
movaps %xmm0,-0x1d0(%rbp)
movaps 0x2b3b(%rip),%xmm0
movaps %xmm0,-0x1e0(%rbp)
movaps 0x2b6d(%rip),%xmm0
movaps %xmm0,-0x1f0(%rbp)
movaps 0x2b4f(%rip),%xmm0
movaps %xmm0,-0x200(%rbp)
movaps 0x2b31(%rip),%xmm0
movaps %xmm0,-0x210(%rbp)
movaps 0x2b13(%rip),%xmm0
movaps %xmm0,-0x220(%rbp)
movaps 0x2b55(%rip),%xmm0
movaps %xmm0,-0x230(%rbp)
movaps 0x2b37(%rip),%xmm0
movaps %xmm0,-0x240(%rbp)
mov    -0xc(%rbp),%eax
shr    $0x1d,%eax
mov    %al,-0xf(%rbp)
movzbl -0xf(%rbp),%eax
mov    %rax,-0x248(%rbp)
sub    $0x7,%rax
ja     1d5b <disassemble+0xc3b>
mov    -0x248(%rbp),%rax
lea    0xd04(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0xc(%rbp),%eax
and    $0x1e000000,%eax
shr    $0x19,%eax
mov    %al,-0x10(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1000000,%eax
shr    $0x18,%eax
mov    %al,-0x17(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe000,%eax
shr    $0xd,%eax
mov    %al,-0x13(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f00,%eax
shr    $0x8,%eax
mov    %al,-0x14(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe0,%eax
shr    $0x5,%eax
mov    %al,-0x15(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x16(%rbp)
cmpb   $0x0,-0x17(%rbp)
je     13bc <disassemble+0x29c>
mov    -0xc(%rbp),%eax
and    $0xff0000,%eax
shr    $0x10,%eax
mov    %al,-0x18(%rbp)
mov    -0x8(%rbp),%rdi
movzbl -0x10(%rbp),%eax
mov    -0xe0(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzbl -0x14(%rbp),%r9d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r10
ff
movzbl -0x18(%rbp),%eax
lea    0xd66(%rip),%rsi
mov    %r10,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1436 <disassemble+0x316>
mov    -0xc(%rbp),%eax
and    $0xe00000,%eax
shr    $0x15,%eax
mov    %al,-0x11(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %al,-0x12(%rbp)
mov    -0x8(%rbp),%rdi
movzbl -0x10(%rbp),%eax
mov    -0xe0(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzbl -0x14(%rbp),%r9d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r11
ff
movzbl -0x12(%rbp),%r10d
movzbl -0x11(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%rax
ff
lea    0xd05(%rip),%rsi
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1d6d <disassemble+0xc4d>
mov    -0xc(%rbp),%eax
shr    $0x19,%eax
and    $0xf,%eax
mov    %al,-0x19(%rbp)
movzbl -0x19(%rbp),%eax
mov    %rax,-0x250(%rbp)
sub    $0xf,%rax
ja     1896 <disassemble+0x776>
mov    -0x250(%rbp),%rax
lea    0xbb6(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0xc(%rbp),%eax
and    $0x1000000,%eax
shr    $0x18,%eax
mov    %al,-0x17(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe0,%eax
shr    $0x5,%eax
mov    %al,-0x15(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x16(%rbp)
cmpb   $0x0,-0x17(%rbp)
je     151d <disassemble+0x3fd>
mov    -0xc(%rbp),%eax
and    $0xffff00,%eax
shr    $0x8,%eax
mov    %ax,-0xe(%rbp)
movzbl -0x19(%rbp),%eax
cmp    $0x0,%eax
jne    14e5 <disassemble+0x3c5>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzwl -0xe(%rbp),%ecx
lea    0xc64(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1518 <disassemble+0x3f8>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzwl -0xe(%rbp),%r9d
lea    0xc36(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    15c1 <disassemble+0x4a1>
mov    -0xc(%rbp),%eax
and    $0xe00000,%eax
shr    $0x15,%eax
mov    %al,-0x11(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %al,-0x12(%rbp)
movzbl -0x19(%rbp),%eax
cmp    $0x0,%eax
jne    1579 <disassemble+0x459>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x12(%rbp),%ecx
movzbl -0x11(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
lea    0xbeb(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    15bc <disassemble+0x49c>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzbl -0x12(%rbp),%r9d
movzbl -0x11(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%rax
ff
lea    0xbb0(%rip),%rsi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    15c1 <disassemble+0x4a1>
jmp    18a8 <disassemble+0x788>
mov    -0xc(%rbp),%eax
and    $0xffff00,%eax
shr    $0x8,%eax
mov    %ax,-0xe(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe0,%eax
shr    $0x5,%eax
mov    %al,-0x15(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x16(%rbp)
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzwl -0xe(%rbp),%r9d
lea    0xb2f(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    18a8 <disassemble+0x788>
mov    -0xc(%rbp),%eax
and    $0x1000000,%eax
shr    $0x18,%eax
mov    %al,-0x17(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe000,%eax
shr    $0xd,%eax
mov    %al,-0x13(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f00,%eax
shr    $0x8,%eax
mov    %al,-0x14(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe0,%eax
shr    $0x5,%eax
mov    %al,-0x15(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x16(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe00000,%eax
shr    $0x15,%eax
mov    %al,-0x11(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %al,-0x12(%rbp)
mov    -0xc(%rbp),%eax
and    $0xff0000,%eax
shr    $0x10,%eax
mov    %al,-0x18(%rbp)
cmpb   $0x0,-0x17(%rbp)
je     16e9 <disassemble+0x5c9>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzbl -0x14(%rbp),%r9d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r10
ff
movzbl -0x18(%rbp),%eax
lea    0xa9c(%rip),%rsi
mov    %r10,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1747 <disassemble+0x627>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzbl -0x14(%rbp),%r9d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r11
ff
movzbl -0x12(%rbp),%r10d
movzbl -0x11(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%rax
ff
lea    0x9f4(%rip),%rsi
mov    %r11,(%rsp)
mov    %r10d,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    18a8 <disassemble+0x788>
mov    -0xc(%rbp),%eax
and    $0x1000000,%eax
shr    $0x18,%eax
mov    %al,-0x17(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe0,%eax
shr    $0x5,%eax
mov    %al,-0x15(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x16(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe00000,%eax
shr    $0x15,%eax
mov    %al,-0x11(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %al,-0x12(%rbp)
mov    -0xc(%rbp),%eax
and    $0xff0000,%eax
shr    $0x10,%eax
mov    %al,-0x18(%rbp)
cmpb   $0x0,-0x17(%rbp)
je     17f5 <disassemble+0x6d5>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzbl -0x14(%rbp),%r9d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r10
ff
movzbl -0x18(%rbp),%eax
lea    0x966(%rip),%rsi
mov    %r10,(%rsp)
mov    %eax,0x8(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1838 <disassemble+0x718>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzbl -0x16(%rbp),%ecx
movzbl -0x15(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r8
ff
movzbl -0x12(%rbp),%r9d
movzbl -0x11(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%rax
ff
lea    0x934(%rip),%rsi
mov    %rax,(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    18a8 <disassemble+0x788>
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
lea    0x9d1(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    18a8 <disassemble+0x788>
mov    -0xc(%rbp),%eax
and    $0x800000,%eax
shr    $0x17,%eax
mov    %ax,-0xe(%rbp)
mov    -0x8(%rbp),%rdi
movzbl -0x19(%rbp),%eax
mov    -0x160(%rbp,%rax,8),%rdx
ff
movzwl -0xe(%rbp),%ecx
lea    0x8ff(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    18a8 <disassemble+0x788>
mov    -0x8(%rbp),%rdi
lea    0x8ee(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1d6d <disassemble+0xc4d>
mov    -0xc(%rbp),%eax
and    $0x38000000,%eax
shr    $0x1b,%eax
mov    %al,-0x1a(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1000000,%eax
shr    $0x18,%eax
mov    %al,-0x17(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe00000,%eax
shr    $0x15,%eax
mov    %al,-0x11(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %al,-0x12(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe000,%eax
shr    $0xd,%eax
mov    %al,-0x13(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f00,%eax
shr    $0x8,%eax
mov    %al,-0x14(%rbp)
mov    -0xc(%rbp),%eax
and    $0xff0000,%eax
shr    $0x10,%eax
mov    %ax,-0xe(%rbp)
mov    -0xc(%rbp),%eax
and    $0x6000000,%eax
shr    $0x11,%eax
mov    -0xc(%rbp),%ecx
and    $0xff,%ecx
or     %ecx,%eax
mov    %ax,-0x24(%rbp)
movswl -0x24(%rbp),%eax
and    $0x200,%eax
cmp    $0x0,%eax
je     1949 <disassemble+0x829>
movswl -0x24(%rbp),%eax
or     $0xfc00,%eax
mov    %ax,-0x24(%rbp)
movzbl -0x1a(%rbp),%eax
cmp    $0x7,%eax
jne    1971 <disassemble+0x851>
mov    -0x8(%rbp),%rdi
movswl -0x24(%rbp),%edx
lea    0x835(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1a0c <disassemble+0x8ec>
cmpb   $0x0,-0x17(%rbp)
je     19ba <disassemble+0x89a>
mov    -0x8(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    -0x1a0(%rbp,%rax,8),%rdx
ff
movswl -0x24(%rbp),%ecx
movzbl -0x14(%rbp),%r8d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r9
ff
movzwl -0xe(%rbp),%eax
lea    0x7f6(%rip),%rsi
mov    %eax,(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1a07 <disassemble+0x8e7>
mov    -0x8(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    -0x1a0(%rbp,%rax,8),%rdx
ff
movswl -0x24(%rbp),%ecx
movzbl -0x14(%rbp),%r8d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r9
ff
movzbl -0x12(%rbp),%r10d
movzbl -0x11(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%rax
ff
lea    0x7bd(%rip),%rsi
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1a0c <disassemble+0x8ec>
jmp    1d6d <disassemble+0xc4d>
mov    -0xc(%rbp),%eax
and    $0x18000000,%eax
shr    $0x1b,%eax
mov    %al,-0x1a(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1000000,%eax
shr    $0x18,%eax
mov    %al,-0x17(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe00000,%eax
shr    $0x15,%eax
mov    %al,-0x11(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %al,-0x12(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe000,%eax
shr    $0xd,%eax
mov    %al,-0x13(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f00,%eax
shr    $0x8,%eax
mov    %al,-0x14(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %ax,-0xe(%rbp)
mov    -0xc(%rbp),%eax
and    $0x6000000,%eax
shr    $0x11,%eax
mov    -0xc(%rbp),%ecx
and    $0xff,%ecx
or     %ecx,%eax
mov    %ax,-0x24(%rbp)
movswl -0x24(%rbp),%eax
and    $0x200,%eax
cmp    $0x0,%eax
je     1aad <disassemble+0x98d>
movswl -0x24(%rbp),%eax
or     $0xfc00,%eax
mov    %ax,-0x24(%rbp)
cmpb   $0x0,-0x17(%rbp)
je     1af6 <disassemble+0x9d6>
mov    -0x8(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    -0x1c0(%rbp,%rax,8),%rdx
ff
movswl -0x24(%rbp),%ecx
movzbl -0x14(%rbp),%r8d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r9
ff
movzwl -0xe(%rbp),%eax
lea    0x6ba(%rip),%rsi
mov    %eax,(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1b43 <disassemble+0xa23>
mov    -0x8(%rbp),%rdi
movzbl -0x1a(%rbp),%eax
mov    -0x1c0(%rbp,%rax,8),%rdx
ff
movswl -0x24(%rbp),%ecx
movzbl -0x14(%rbp),%r8d
movzbl -0x13(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r9
ff
movzbl -0x12(%rbp),%r10d
movzbl -0x11(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%rax
ff
lea    0x681(%rip),%rsi
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1d6d <disassemble+0xc4d>
mov    -0xc(%rbp),%eax
and    $0x10000000,%eax
shr    $0x1c,%eax
mov    %al,-0x1b(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe000000,%eax
shr    $0x15,%eax
mov    -0xc(%rbp),%ecx
and    $0xe000,%ecx
shr    $0xc,%ecx
or     %ecx,%eax
mov    -0xc(%rbp),%ecx
and    $0x80,%ecx
shr    $0x7,%ecx
or     %ecx,%eax
mov    %al,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1000000,%eax
shr    $0x18,%eax
mov    %al,-0x17(%rbp)
mov    -0xc(%rbp),%eax
and    $0x60,%eax
shr    $0x5,%eax
mov    %al,-0x1d(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f,%eax
mov    %al,-0x1e(%rbp)
mov    -0xc(%rbp),%eax
and    $0xe00000,%eax
shr    $0x15,%eax
mov    %al,-0x20(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f0000,%eax
shr    $0x10,%eax
mov    %al,-0x1f(%rbp)
mov    -0xc(%rbp),%eax
and    $0x1f00,%eax
shr    $0x8,%eax
mov    %al,-0x21(%rbp)
mov    -0xc(%rbp),%eax
and    $0xff0000,%eax
shr    $0x10,%eax
mov    %ax,-0xe(%rbp)
lea    -0x60(%rbp),%rdi
movzbl -0x1c(%rbp),%esi
mov    $0x0,%al
call   1030 <GetBurstLen@plt>
movzbl -0xf(%rbp),%eax
cmp    $0x7,%eax
jne    1ca7 <disassemble+0xb87>
cmpb   $0x0,-0x17(%rbp)
je     1c4c <disassemble+0xb2c>
mov    -0x8(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    -0x1d0(%rbp,%rax,8),%rdx
ff
movzbl -0x1e(%rbp),%ecx
movzbl -0x1d(%rbp),%eax
mov    -0x240(%rbp,%rax,8),%r8
ff
movzbl -0x21(%rbp),%r9d
movzwl -0xe(%rbp),%r10d
lea    -0x60(%rbp),%rax
lea    0x593(%rip),%rsi
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1ca2 <disassemble+0xb82>
mov    -0x8(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    -0x1d0(%rbp,%rax,8),%rdx
ff
movzbl -0x1e(%rbp),%ecx
movzbl -0x1d(%rbp),%eax
mov    -0x240(%rbp,%rax,8),%r8
ff
movzbl -0x21(%rbp),%r9d
movzbl -0x1f(%rbp),%r11d
movzbl -0x20(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r10
ff
lea    -0x60(%rbp),%rax
lea    0x553(%rip),%rsi
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1d56 <disassemble+0xc36>
cmpb   $0x0,-0x17(%rbp)
je     1cfb <disassemble+0xbdb>
mov    -0x8(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    -0x1e0(%rbp,%rax,8),%rdx
ff
movzbl -0x1e(%rbp),%ecx
movzbl -0x1d(%rbp),%eax
mov    -0x240(%rbp,%rax,8),%r8
ff
movzbl -0x21(%rbp),%r9d
movzwl -0xe(%rbp),%r10d
lea    -0x60(%rbp),%rax
lea    0x513(%rip),%rsi
mov    %r10d,(%rsp)
mov    %rax,0x8(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1d51 <disassemble+0xc31>
mov    -0x8(%rbp),%rdi
movzbl -0x1b(%rbp),%eax
mov    -0x1e0(%rbp,%rax,8),%rdx
ff
movzbl -0x1e(%rbp),%ecx
movzbl -0x1d(%rbp),%eax
mov    -0x240(%rbp,%rax,8),%r8
ff
movzbl -0x21(%rbp),%r9d
movzbl -0x1f(%rbp),%r11d
movzbl -0x20(%rbp),%eax
mov    -0x220(%rbp,%rax,8),%r10
ff
lea    -0x60(%rbp),%rax
lea    0x4d3(%rip),%rsi
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <sprintf@plt>
jmp    1d56 <disassemble+0xc36>
jmp    1d6d <disassemble+0xc4d>
mov    -0x8(%rbp),%rdi
lea    0x4c2(%rip),%rsi
mov    $0x0,%al
call   1040 <sprintf@plt>
add    $0x270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<disassemble>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %esi,%ebx
shr    $0x1d,%ebx
cmp    $0x7,%ebx
ja     1382 <disassemble+0x252>
mov    %esi,%ebp
lea    0xeab(%rip),%rax
movslq (%rax,%rbx,4),%rcx
add    %rax,%rcx
jmp    *%rcx
mov    %ebp,%eax
shr    $0x1b,%eax
and    $0x7,%al
mov    %ebp,%ecx
shr    $0x11,%ecx
and    $0x300,%ecx
movzbl %bpl,%edx
lea    (%rcx,%rdx,1),%esi
test   $0x4000000,%ebp
lea    0xfc00(%rcx,%rdx,1),%ecx
cmove  %esi,%ecx
cmp    $0x7,%al
jne    1425 <disassemble+0x2f5>
movswl %cx,%edx
lea    0x1001(%rip),%rsi
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <sprintf@plt>
mov    %rdi,0x18(%rsp)
mov    %ebp,%r13d
shr    $0x1c,%r13d
and    $0x1,%r13d
mov    %ebp,%edx
shr    $0x15,%edx
mov    %edx,%eax
and    $0x70,%eax
mov    %ebp,%ecx
shr    $0xc,%ecx
and    $0xe,%ecx
or     %eax,%ecx
mov    %ebp,%esi
shr    $0x7,%esi
and    $0x1,%esi
or     %ecx,%esi
mov    %ebp,%r14d
shr    $0x5,%r14b
and    $0x3,%r14b
mov    %ebp,%eax
and    $0x1f,%al
mov    %al,0xf(%rsp)
and    $0x7,%dl
mov    %edx,0x14(%rsp)
mov    %ebp,%r15d
shr    $0x10,%r15d
mov    %ebp,%r12d
shr    $0x8,%r12d
and    $0x1f,%r12b
movzbl %r15b,%eax
mov    %eax,0x10(%rsp)
and    $0x1f,%r15b
lea    0x20(%rsp),%rdi
xor    %eax,%eax
call   1040 <GetBurstLen@plt>
cmp    $0x7,%ebx
jne    1486 <disassemble+0x356>
lea    0x2b70(%rip),%rax
mov    (%rax,%r13,8),%rdx
movzbl %r14b,%eax
lea    0x2bc1(%rip),%rcx
mov    (%rcx,%rax,8),%r8
movzbl 0xf(%rsp),%ecx
movzbl %r12b,%r9d
test   $0x1000000,%ebp
jne    14f5 <disassemble+0x3c5>
movzbl %r15b,%r11d
movzbl 0x14(%rsp),%ebx
lea    0x2b58(%rip),%r10
sub    $0x8,%rsp
lea    0xf6d(%rip),%rsi
jmp    14d0 <disassemble+0x3a0>
mov    %ebp,%ecx
shr    $0x19,%ecx
and    $0xf,%cl
mov    %ebp,%eax
shr    $0xd,%eax
and    $0x7,%al
mov    %ebp,%esi
shr    $0x8,%esi
and    $0x1f,%sil
mov    %ebp,%r8d
shr    $0x5,%r8b
mov    %ebp,%ebx
and    $0x1f,%bl
test   $0x1000000,%ebp
jne    1506 <disassemble+0x3d6>
mov    %ebp,%r10d
shr    $0x15,%r10d
and    $0x7,%r10d
shr    $0x10,%ebp
and    $0x1f,%ebp
movzbl %cl,%ecx
lea    0x297d(%rip),%rdx
mov    (%rdx,%rcx,8),%rdx
movzbl %bl,%ecx
movzbl %r8b,%ebx
lea    0x2aeb(%rip),%r11
mov    (%r11,%rbx,8),%r8
movzbl %sil,%r9d
movzbl %al,%ebx
sub    $0x8,%rsp
lea    0xe3b(%rip),%rsi
xor    %eax,%eax
push   (%r11,%r10,8)
push   %rbp
push   (%r11,%rbx,8)
call   1050 <sprintf@plt>
add    $0x78,%rsp
jmp    1801 <disassemble+0x6d1>
mov    %ebp,%ecx
shr    $0x19,%ecx
mov    %ecx,%eax
and    $0xf,%al
cmp    $0xf,%al
ja     16fb <disassemble+0x5cb>
and    $0xf,%ecx
lea    0xd01(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
jmp    *%rcx
mov    %ebp,%ebx
shr    $0x5,%bl
mov    %ebp,%ecx
and    $0x1f,%cl
test   $0x1000000,%ebp
jne    173a <disassemble+0x60a>
mov    %ebp,%esi
shr    $0x15,%esi
and    $0x7,%sil
shr    $0x10,%ebp
and    $0x1f,%bpl
test   %al,%al
je     180c <disassemble+0x6dc>
movzbl %al,%eax
lea    0x2960(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
movzbl %cl,%ecx
movzbl %bl,%eax
lea    0x2a4f(%rip),%rbx
mov    (%rbx,%rax,8),%r8
movzbl %bpl,%r9d
movzbl %sil,%ebp
jmp    16c5 <disassemble+0x595>
movabs $0x4e574f4e4b4e55,%rax
mov    %rax,(%rdi)
add    $0x58,%rsp
jmp    1801 <disassemble+0x6d1>
mov    %ebp,%ecx
shr    $0x1b,%ecx
and    $0x3,%cl
mov    %ebp,%r10d
shr    $0x10,%r10d
and    $0x1f,%r10d
mov    %ebp,%eax
shr    $0xd,%eax
and    $0x7,%al
mov    %ebp,%esi
shr    $0x8,%esi
and    $0x1f,%sil
mov    %ebp,%edx
shr    $0x11,%edx
and    $0x300,%edx
movzbl %bpl,%ebx
lea    (%rdx,%rbx,1),%r8d
test   $0x4000000,%ebp
lea    0xfc00(%rdx,%rbx,1),%ebx
cmove  %r8d,%ebx
test   $0x1000000,%ebp
jne    1547 <disassemble+0x417>
shr    $0x15,%ebp
and    $0x7,%ebp
movzbl %cl,%ecx
lea    0x2985(%rip),%rdx
mov    (%rdx,%rcx,8),%rdx
movswl %bx,%ecx
movzbl %sil,%r8d
movzbl %al,%eax
lea    0x29b0(%rip),%rbx
mov    (%rbx,%rax,8),%r9
lea    0xd99(%rip),%rsi
xor    %eax,%eax
push   (%rbx,%rbp,8)
jmp    1577 <disassemble+0x447>
mov    %ebp,%ebx
shr    $0x10,%ebx
mov    %ebp,%r8d
shr    $0x8,%r8d
and    $0x1f,%r8d
mov    %ebp,%esi
shr    $0xd,%esi
and    $0x7,%esi
movzbl %al,%eax
lea    0x28f9(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
movswl %cx,%ecx
lea    0x296b(%rip),%r10
mov    (%r10,%rsi,8),%r9
test   $0x1000000,%ebp
jne    1583 <disassemble+0x453>
shr    $0x15,%ebp
and    $0x7,%ebp
and    $0x1f,%ebx
lea    0xd3f(%rip),%rsi
xor    %eax,%eax
push   (%r10,%rbp,8)
push   %rbx
call   1050 <sprintf@plt>
jmp    17fd <disassemble+0x6cd>
lea    0x2923(%rip),%rax
mov    (%rax,%r13,8),%rdx
movzbl %r14b,%eax
lea    0x2964(%rip),%rcx
mov    (%rcx,%rax,8),%r8
movzbl 0xf(%rsp),%ecx
movzbl %r12b,%r9d
test   $0x1000000,%ebp
jne    159e <disassemble+0x46e>
movzbl %r15b,%r11d
movzbl 0x14(%rsp),%ebx
lea    0x28fb(%rip),%r10
sub    $0x8,%rsp
lea    0xd3f(%rip),%rsi
mov    0x20(%rsp),%rdi
xor    %eax,%eax
lea    0x28(%rsp),%rbp
push   %rbp
push   (%r10,%rbx,8)
push   %r11
call   1050 <sprintf@plt>
add    $0x20,%rsp
add    $0x58,%rsp
jmp    1801 <disassemble+0x6d1>
movzwl 0x10(%rsp),%ebp
lea    0xcc9(%rip),%rsi
jmp    15aa <disassemble+0x47a>
shr    $0x10,%ebp
movzbl %cl,%ecx
lea    0x272d(%rip),%rdx
mov    (%rdx,%rcx,8),%rdx
movzbl %bl,%ecx
movzbl %r8b,%ebx
lea    0x289b(%rip),%r10
mov    (%r10,%rbx,8),%r8
movzbl %sil,%r9d
movzbl %al,%ebx
movzbl %bpl,%ebp
lea    0xbd3(%rip),%rsi
xor    %eax,%eax
push   %rbp
push   (%r10,%rbx,8)
jmp    17f8 <disassemble+0x6c8>
movzbl %cl,%ecx
lea    0x282f(%rip),%rdx
mov    (%rdx,%rcx,8),%rdx
movswl %bx,%ecx
movzbl %sil,%r8d
movzbl %al,%eax
lea    0x285a(%rip),%rsi
mov    (%rsi,%rax,8),%r9
sub    $0x8,%rsp
lea    0xc2c(%rip),%rsi
xor    %eax,%eax
push   %r10
call   1050 <sprintf@plt>
jmp    17fd <disassemble+0x6cd>
movzbl %bl,%ebp
sub    $0x8,%rsp
lea    0xc10(%rip),%rsi
xor    %eax,%eax
push   %rbp
call   1050 <sprintf@plt>
jmp    17fd <disassemble+0x6cd>
movzwl 0x10(%rsp),%ebp
lea    0xc4f(%rip),%rsi
mov    0x18(%rsp),%rdi
xor    %eax,%eax
lea    0x20(%rsp),%rbx
push   %rbx
push   %rbp
call   1050 <sprintf@plt>
add    $0x10,%rsp
add    $0x58,%rsp
jmp    1801 <disassemble+0x6d1>
mov    %ebp,%ecx
shr    $0x8,%ecx
mov    %ebp,%esi
shr    $0x5,%esi
and    $0x1f,%ebp
movzbl %al,%eax
lea    0x26df(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
and    $0x7,%esi
lea    0x27d1(%rip),%rax
mov    (%rax,%rsi,8),%r8
movzwl %cx,%r9d
lea    0xb49(%rip),%rsi
mov    %ebp,%ecx
jmp    176f <disassemble+0x63f>
mov    %ebp,%esi
shr    $0xd,%esi
and    $0x7,%sil
mov    %ebp,%ebx
shr    $0x8,%ebx
and    $0x1f,%bl
mov    %ebp,%r8d
shr    $0x5,%r8b
mov    %ebp,%ecx
and    $0x1f,%cl
mov    %ebp,%r10d
shr    $0x10,%r10d
test   $0x1000000,%ebp
jne    1784 <disassemble+0x654>
and    $0x1f,%r10d
shr    $0x15,%ebp
and    $0x7,%ebp
movzbl %al,%eax
lea    0x2677(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
movzbl %cl,%ecx
movzbl %r8b,%eax
lea    0x2765(%rip),%r11
mov    (%r11,%rax,8),%r8
movzbl %bl,%r9d
movzbl %sil,%ebx
sub    $0x8,%rsp
lea    0xab4(%rip),%rsi
xor    %eax,%eax
push   (%r11,%rbp,8)
push   %r10
jmp    12f2 <disassemble+0x1c2>
mov    %ebp,%ebx
shr    $0x5,%bl
mov    %ebp,%ecx
and    $0x1f,%cl
mov    %ebp,%r9d
shr    $0x10,%r9d
test   $0x1000000,%ebp
jne    17c0 <disassemble+0x690>
and    $0x1f,%r9d
shr    $0x15,%ebp
and    $0x7,%ebp
movzbl %al,%eax
lea    0x2610(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
movzbl %cl,%ecx
movzbl %bl,%eax
lea    0x26ff(%rip),%rbx
mov    (%rbx,%rax,8),%r8
sub    $0x8,%rsp
lea    0xa91(%rip),%rsi
xor    %eax,%eax
push   (%rbx,%rbp,8)
jmp    17f8 <disassemble+0x6c8>
movzbl %al,%eax
lea    0x25dc(%rip),%rcx
mov    (%rcx,%rax,8),%rsi
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <strcpy@plt>
movabs $0x2d4e574f4e4b4e55,%rax
57 4e 2d
mov    %rax,(%rdi)
movl   $0x32462d,0x7(%rdi)
add    $0x58,%rsp
jmp    1801 <disassemble+0x6d1>
shr    $0x17,%ebp
and    $0x1,%ebp
movzbl %al,%eax
lea    0x2598(%rip),%rcx
mov    (%rcx,%rax,8),%rdx
lea    0xa56(%rip),%rsi
mov    %ebp,%ecx
jmp    1853 <disassemble+0x723>
shr    $0x8,%ebp
test   %al,%al
je     1842 <disassemble+0x712>
movzbl %al,%eax
lea    0x2571(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
movzbl %cl,%ecx
movzbl %bl,%eax
lea    0x2660(%rip),%rsi
mov    (%rsi,%rax,8),%r8
movzwl %bp,%r9d
lea    0x9d8(%rip),%rsi
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <sprintf@plt>
movzbl %al,%eax
lea    0x2532(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
movzbl %cl,%ecx
movzbl %r8b,%eax
lea    0x2620(%rip),%r11
mov    (%r11,%rax,8),%r8
movzbl %bl,%r9d
movzbl %sil,%ebx
movzbl %r10b,%ebp
lea    0x9ba(%rip),%rsi
xor    %eax,%eax
push   %rbp
push   (%r11,%rbx,8)
jmp    17f8 <disassemble+0x6c8>
movzbl %al,%eax
lea    0x24f6(%rip),%rdx
mov    (%rdx,%rax,8),%rdx
movzbl %cl,%ecx
movzbl %bl,%eax
lea    0x25e5(%rip),%rsi
mov    (%rsi,%rax,8),%r8
movzbl %r9b,%ebp
lea    0x908(%rip),%rbx
lea    0x956(%rip),%rsi
xor    %r9d,%r9d
xor    %eax,%eax
push   %rbp
push   %rbx
call   1050 <sprintf@plt>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movzbl %bpl,%ecx
movzbl %sil,%eax
lea    0x25a5(%rip),%rdx
mov    (%rdx,%rax,8),%r8
lea    0x932(%rip),%rsi
lea    0x86f(%rip),%rdx
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <sprintf@plt>
movzwl %bp,%ecx
lea    0x8f1(%rip),%rsi
lea    0x849(%rip),%rdx
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <sprintf@plt>

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

LLVM IR (-O2):
@.str = [4 x i8] c"ADD\00"
@.str.1 = [4 x i8] c"ADC\00"
@.str.2 = [4 x i8] c"SUB\00"
@.str.3 = [4 x i8] c"SUC\00"
@.str.4 = [4 x i8] c"LSL\00"
@.str.5 = [4 x i8] c"LSR\00"
@.str.6 = [4 x i8] c"RSB\00"
@.str.7 = [4 x i8] c"RSC\00"
@.str.8 = [4 x i8] c"AND\00"
@.str.9 = [3 x i8] c"OR\00"
@.str.10 = [4 x i8] c"XOR\00"
@.str.11 = [4 x i8] c"NOT\00"
@.str.12 = [4 x i8] c"MIN\00"
@.str.13 = [4 x i8] c"MAX\00"
@.str.14 = [4 x i8] c"CLR\00"
@.str.15 = [4 x i8] c"SET\00"
@__const.disassemble.f1_inst = [16 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.4, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.5, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.6, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 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 ([4 x i8], [4 x i8]* @.str.10, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.12, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.13, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.14, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i32 0, i32 0)]
@.str.16 = [4 x i8] c"JMP\00"
@.str.17 = [4 x i8] c"JAL\00"
@.str.18 = [4 x i8] c"LDI\00"
@.str.19 = [5 x i8] c"LMBD\00"
@.str.20 = [5 x i8] c"SCAN\00"
@.str.21 = [5 x i8] c"HALT\00"
@.str.22 = [9 x i8] c"RESERVED\00"
@.str.23 = [4 x i8] c"SLP\00"
@__const.disassemble.f2_inst = [16 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.17, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.18, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 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 ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.22, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.23, i32 0, i32 0)]
@.str.24 = [3 x i8] c"xx\00"
@.str.25 = [3 x i8] c"LT\00"
@.str.26 = [3 x i8] c"EQ\00"
@.str.27 = [3 x i8] c"LE\00"
@.str.28 = [3 x i8] c"GT\00"
@.str.29 = [3 x i8] c"NE\00"
@.str.30 = [3 x i8] c"GE\00"
@.str.31 = [2 x i8] c"A\00"
@__const.disassemble.f4_inst = [8 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.24, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.25, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.26, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.27, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.28, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.29, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.30, i32 0, i32 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.31, i32 0, i32 0)]
@.str.32 = [3 x i8] c"BC\00"
@.str.33 = [3 x i8] c"BS\00"
@__const.disassemble.f5_inst = [4 x i8*] [i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.24, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.32, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.33, i32 0, i32 0), i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.24, i32 0, i32 0)]
@.str.34 = [5 x i8] c"SBBO\00"
@.str.35 = [5 x i8] c"LBBO\00"
@__const.disassemble.f6_7_inst = [2 x i8*] [i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.34, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.35, i32 0, i32 0)]
@.str.36 = [5 x i8] c"SBCO\00"
@.str.37 = [5 x i8] c"LBCO\00"
@__const.disassemble.f6_4_inst = [2 x i8*] [i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.36, i32 0, i32 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.37, i32 0, i32 0)]
@.str.38 = [4 x i8] c".b0\00"
@.str.39 = [4 x i8] c".b1\00"
@.str.40 = [4 x i8] c".b2\00"
@.str.41 = [4 x i8] c".b3\00"
@.str.42 = [4 x i8] c".w0\00"
@.str.43 = [4 x i8] c".w1\00"
@.str.44 = [4 x i8] c".w2\00"
@.str.45 = [1 x i8] zeroinitializer
@__const.disassemble.sis = [8 x i8*] [i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.38, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.39, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.40, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.41, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.42, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.43, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.44, i32 0, i32 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.45, i32 0, i32 0)]
@__const.disassemble.bytenum = [4 x i8*] [i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.45, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.39, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.40, i32 0, i32 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.41, i32 0, i32 0)]
@.str.46 = [24 x i8] c"%s R%u%s, R%u%s, 0x%02x\00"
@.str.47 = [23 x i8] c"%s R%u%s, R%u%s, R%u%s\00"
@.str.48 = [10 x i8] c"%s 0x%04x\00"
@.str.49 = [17 x i8] c"%s R%u%s, 0x%04x\00"
@.str.50 = [9 x i8] c"%s R%u%s\00"
@.str.51 = [16 x i8] c"%s R%u%s, R%u%s\00"
@.str.52 = [24 x i8] c"%s R%u%s, R%u%s, 0x%04x\00"
@.str.54 = [6 x i8] c"%s %u\00"
@.str.55 = [11 x i8] c"UNKNOWN-F2\00"
@.str.56 = [7 x i8] c"QBA %d\00"
@.str.57 = [19 x i8] c"QB%s %d, R%u%s, %u\00"
@.str.58 = [22 x i8] c"QB%s %d, R%u%s, R%u%s\00"
@.str.59 = [22 x i8] c"%s R%u%s, R%u, %u, %s\00"
@.str.60 = [25 x i8] c"%s R%u%s, R%u, R%u%s, %s\00"
@.str.61 = [22 x i8] c"%s R%u%s, C%u, %u, %s\00"
@.str.62 = [25 x i8] c"%s R%u%s, C%u, R%u%s, %s\00"
define void @disassemble(i8* %0, i32 %1) {
%3 = alloca [50 x i8]
%4 = getelementptr inbounds [50 x i8], [50 x i8]* %3, i64 0, i64 0
%5 = lshr i32 %1, 29
switch i32 %5, label %371 [
i32 0, label %6
i32 1, label %56
i32 2, label %214
i32 3, label %214
i32 6, label %258
i32 4, label %307
i32 7, label %307
]
6: ; preds = %2
%7 = lshr i32 %1, 25
%8 = trunc i32 %7 to i8
%9 = and i8 %8, 15
%10 = lshr i32 %1, 13
%11 = trunc i32 %10 to i8
%12 = and i8 %11, 7
%13 = lshr i32 %1, 8
%14 = trunc i32 %13 to i8
%15 = and i8 %14, 31
%16 = trunc i32 %1 to i8
%17 = lshr i8 %16, 5
%18 = and i8 %16, 31
%19 = and i32 %1, 16777216
%20 = icmp eq i32 %19, 0
br i1 %20, label %36, label %21
21: ; preds = %6
%22 = lshr i32 %1, 16
%23 = zext i8 %9 to i64
%24 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f1_inst, i64 0, i64 %23
%25 = load i8*, i8** %24
%26 = zext i8 %18 to i32
%27 = zext i8 %17 to i64
%28 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %27
%29 = load i8*, i8** %28
%30 = zext i8 %15 to i32
%31 = zext i8 %12 to i64
%32 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %31
%33 = load i8*, i8** %32
%34 = and i32 %22, 255
%35 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.46, i64 0, i64 0), i8* %25, i32 %26, i8* %29, i32 %30, i8* %33, i32 %34)
br label %373
36: ; preds = %6
%37 = lshr i32 %1, 21
%38 = and i32 %37, 7
%39 = zext i32 %38 to i64
%40 = lshr i32 %1, 16
%41 = and i32 %40, 31
%42 = zext i8 %9 to i64
%43 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f1_inst, i64 0, i64 %42
%44 = load i8*, i8** %43
%45 = zext i8 %18 to i32
%46 = zext i8 %17 to i64
%47 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %46
%48 = load i8*, i8** %47
%49 = zext i8 %15 to i32
%50 = zext i8 %12 to i64
%51 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %50
%52 = load i8*, i8** %51
%53 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %39
%54 = load i8*, i8** %53
%55 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.47, i64 0, i64 0), i8* %44, i32 %45, i8* %48, i32 %49, i8* %52, i32 %41, i8* %54)
br label %373
56: ; preds = %2
%57 = lshr i32 %1, 25
%58 = trunc i32 %57 to i8
%59 = and i8 %58, 15
%60 = zext i8 %59 to i32
switch i32 %60, label %213 [
i32 0, label %61
i32 1, label %61
i32 2, label %110
i32 3, label %123
i32 4, label %169
i32 5, label %201
i32 15, label %206
]
61: ; preds = %56, %56
%62 = trunc i32 %1 to i8
%63 = lshr i8 %62, 5
%64 = and i8 %62, 31
%65 = and i32 %1, 16777216
%66 = icmp eq i32 %65, 0
br i1 %66, label %83, label %67
67: ; preds = %61
%68 = lshr i32 %1, 8
%69 = icmp eq i8 %59, 0
br i1 %69, label %70, label %73
70: ; preds = %67
%71 = and i32 %68, 65535
%72 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @.str.48, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0), i32 %71)
br label %373
73: ; preds = %67
%74 = zext i8 %59 to i64
%75 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %74
%76 = load i8*, i8** %75
%77 = zext i8 %64 to i32
%78 = zext i8 %63 to i64
%79 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %78
%80 = load i8*, i8** %79
%81 = and i32 %68, 65535
%82 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.49, i64 0, i64 0), i8* %76, i32 %77, i8* %80, i32 %81)
br label %373
83: ; preds = %61
%84 = lshr i32 %1, 21
%85 = trunc i32 %84 to i8
%86 = and i8 %85, 7
%87 = lshr i32 %1, 16
%88 = trunc i32 %87 to i8
%89 = and i8 %88, 31
%90 = icmp eq i8 %59, 0
br i1 %90, label %91, label %97
91: ; preds = %83
%92 = zext i8 %89 to i32
%93 = zext i8 %86 to i64
%94 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %93
%95 = load i8*, i8** %94
%96 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @.str.50, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0), i32 %92, i8* %95)
br label %373
97: ; preds = %83
%98 = zext i8 %59 to i64
%99 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %98
%100 = load i8*, i8** %99
%101 = zext i8 %64 to i32
%102 = zext i8 %63 to i64
%103 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %102
%104 = load i8*, i8** %103
%105 = zext i8 %89 to i32
%106 = zext i8 %86 to i64
%107 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %106
%108 = load i8*, i8** %107
%109 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.51, i64 0, i64 0), i8* %100, i32 %101, i8* %104, i32 %105, i8* %108)
br label %373
110: ; preds = %56
%111 = lshr i32 %1, 8
%112 = lshr i32 %1, 5
%113 = and i32 %1, 31
%114 = zext i8 %59 to i64
%115 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %114
%116 = load i8*, i8** %115
%117 = and i32 %112, 7
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %118
%120 = load i8*, i8** %119
%121 = and i32 %111, 65535
%122 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.49, i64 0, i64 0), i8* %116, i32 %113, i8* %120, i32 %121)
br label %373
123: ; preds = %56
%124 = lshr i32 %1, 13
%125 = trunc i32 %124 to i8
%126 = and i8 %125, 7
%127 = lshr i32 %1, 8
%128 = trunc i32 %127 to i8
%129 = and i8 %128, 31
%130 = trunc i32 %1 to i8
%131 = lshr i8 %130, 5
%132 = and i8 %130, 31
%133 = and i32 %1, 16777216
%134 = icmp eq i32 %133, 0
%135 = lshr i32 %1, 16
br i1 %134, label %150, label %136
136: ; preds = %123
%137 = zext i8 %59 to i64
%138 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %137
%139 = load i8*, i8** %138
%140 = zext i8 %132 to i32
%141 = zext i8 %131 to i64
%142 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %141
%143 = load i8*, i8** %142
%144 = zext i8 %129 to i32
%145 = zext i8 %126 to i64
%146 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %145
%147 = load i8*, i8** %146
%148 = and i32 %135, 255
%149 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.52, i64 0, i64 0), i8* %139, i32 %140, i8* %143, i32 %144, i8* %147, i32 %148)
br label %373
150: ; preds = %123
%151 = and i32 %135, 31
%152 = lshr i32 %1, 21
%153 = and i32 %152, 7
%154 = zext i32 %153 to i64
%155 = zext i8 %59 to i64
%156 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %155
%157 = load i8*, i8** %156
%158 = zext i8 %132 to i32
%159 = zext i8 %131 to i64
%160 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %159
%161 = load i8*, i8** %160
%162 = zext i8 %129 to i32
%163 = zext i8 %126 to i64
%164 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %163
%165 = load i8*, i8** %164
%166 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %154
%167 = load i8*, i8** %166
%168 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.47, i64 0, i64 0), i8* %157, i32 %158, i8* %161, i32 %162, i8* %165, i32 %151, i8* %167)
br label %373
169: ; preds = %56
%170 = trunc i32 %1 to i8
%171 = lshr i8 %170, 5
%172 = and i8 %170, 31
%173 = and i32 %1, 16777216
%174 = icmp eq i32 %173, 0
%175 = lshr i32 %1, 16
br i1 %174, label %186, label %176
176: ; preds = %169
%177 = zext i8 %59 to i64
%178 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %177
%179 = load i8*, i8** %178
%180 = zext i8 %172 to i32
%181 = zext i8 %171 to i64
%182 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %181
%183 = load i8*, i8** %182
%184 = and i32 %175, 255
%185 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @.str.49, i64 0, i64 0), i8* %179, i32 %180, i8* %183, i32 0, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.38, i64 0, i64 0), i32 %184)
br label %373
186: ; preds = %169
%187 = and i32 %175, 31
%188 = lshr i32 %1, 21
%189 = and i32 %188, 7
%190 = zext i32 %189 to i64
%191 = zext i8 %59 to i64
%192 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %191
%193 = load i8*, i8** %192
%194 = zext i8 %172 to i32
%195 = zext i8 %171 to i64
%196 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %195
%197 = load i8*, i8** %196
%198 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %190
%199 = load i8*, i8** %198
%200 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.51, i64 0, i64 0), i8* %193, i32 %194, i8* %197, i32 %187, i8* %199)
br label %373
201: ; preds = %56
%202 = zext i8 %59 to i64
%203 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %202
%204 = load i8*, i8** %203
%205 = tail call i8* @strcpy(i8* dereferenceable(1) %0, i8* dereferenceable(1) %204)
br label %373
206: ; preds = %56
%207 = lshr i32 %1, 23
%208 = and i32 %207, 1
%209 = zext i8 %59 to i64
%210 = getelementptr inbounds [16 x i8*], [16 x i8*]* @__const.disassemble.f2_inst, i64 0, i64 %209
%211 = load i8*, i8** %210
%212 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.54, i64 0, i64 0), i8* %211, i32 %208)
br label %373
213: ; preds = %56
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(11) %0, i8* align 1 dereferenceable(11) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.55, i64 0, i64 0), i64 11, i1 false)
br label %373
214: ; preds = %2, %2
%215 = lshr i32 %1, 27
%216 = trunc i32 %215 to i8
%217 = and i8 %216, 7
%218 = lshr i32 %1, 21
%219 = and i32 %218, 7
%220 = zext i32 %219 to i64
%221 = lshr i32 %1, 16
%222 = and i32 %221, 31
%223 = and i32 %221, 255
%224 = lshr i32 %1, 17
%225 = and i32 %224, 768
%226 = and i32 %1, 255
%227 = or i32 %225, %226
%228 = and i32 %1, 67108864
%229 = icmp eq i32 %228, 0
%230 = or i32 %227, 64512
%231 = select i1 %229, i32 %227, i32 %230
%232 = icmp eq i8 %217, 7
br i1 %232, label %233, label %237
233: ; preds = %214
%234 = shl nuw i32 %231, 16
%235 = ashr exact i32 %234, 16
%236 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.56, i64 0, i64 0), i32 %235)
br label %373
237: ; preds = %214
%238 = lshr i32 %1, 8
%239 = and i32 %238, 31
%240 = lshr i32 %1, 13
%241 = and i32 %240, 7
%242 = zext i32 %241 to i64
%243 = and i32 %1, 16777216
%244 = icmp eq i32 %243, 0
%245 = zext i8 %217 to i64
%246 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.f4_inst, i64 0, i64 %245
%247 = load i8*, i8** %246
%248 = shl nuw i32 %231, 16
%249 = ashr exact i32 %248, 16
%250 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %242
%251 = load i8*, i8** %250
br i1 %244, label %254, label %252
252: ; preds = %237
%253 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.57, i64 0, i64 0), i8* %247, i32 %249, i32 %239, i8* %251, i32 %223)
br label %373
254: ; preds = %237
%255 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %220
%256 = load i8*, i8** %255
%257 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.58, i64 0, i64 0), i8* %247, i32 %249, i32 %239, i8* %251, i32 %222, i8* %256)
br label %373
258: ; preds = %2
%259 = lshr i32 %1, 27
%260 = trunc i32 %259 to i8
%261 = and i8 %260, 3
%262 = lshr i32 %1, 16
%263 = and i32 %262, 31
%264 = lshr i32 %1, 13
%265 = trunc i32 %264 to i8
%266 = and i8 %265, 7
%267 = lshr i32 %1, 8
%268 = trunc i32 %267 to i8
%269 = and i8 %268, 31
%270 = lshr i32 %1, 17
%271 = and i32 %270, 768
%272 = and i32 %1, 255
%273 = or i32 %271, %272
%274 = and i32 %1, 67108864
%275 = icmp eq i32 %274, 0
%276 = or i32 %273, 64512
%277 = select i1 %275, i32 %273, i32 %276
%278 = and i32 %1, 16777216
%279 = icmp eq i32 %278, 0
br i1 %279, label %291, label %280
280: ; preds = %258
%281 = zext i8 %261 to i64
%282 = getelementptr inbounds [4 x i8*], [4 x i8*]* @__const.disassemble.f5_inst, i64 0, i64 %281
%283 = load i8*, i8** %282
%284 = shl nuw i32 %277, 16
%285 = ashr exact i32 %284, 16
%286 = zext i8 %269 to i32
%287 = zext i8 %266 to i64
%288 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %287
%289 = load i8*, i8** %288
%290 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.57, i64 0, i64 0), i8* %283, i32 %285, i32 %286, i8* %289, i32 %263)
br label %373
291: ; preds = %258
%292 = lshr i32 %1, 21
%293 = and i32 %292, 7
%294 = zext i32 %293 to i64
%295 = zext i8 %261 to i64
%296 = getelementptr inbounds [4 x i8*], [4 x i8*]* @__const.disassemble.f5_inst, i64 0, i64 %295
%297 = load i8*, i8** %296
%298 = shl nuw i32 %277, 16
%299 = ashr exact i32 %298, 16
%300 = zext i8 %269 to i32
%301 = zext i8 %266 to i64
%302 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %301
%303 = load i8*, i8** %302
%304 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %294
%305 = load i8*, i8** %304
%306 = tail call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.58, i64 0, i64 0), i8* %297, i32 %299, i32 %300, i8* %303, i32 %263, i8* %305)
br label %373
307: ; preds = %2, %2
%308 = lshr i32 %1, 28
%309 = and i32 %308, 1
%310 = zext i32 %309 to i64
%311 = lshr i32 %1, 21
%312 = and i32 %311, 112
%313 = lshr i32 %1, 12
%314 = and i32 %313, 14
%315 = or i32 %312, %314
%316 = lshr i32 %1, 7
%317 = and i32 %316, 1
%318 = or i32 %315, %317
%319 = trunc i32 %1 to i8
%320 = lshr i8 %319, 5
%321 = and i8 %320, 3
%322 = and i8 %319, 31
%323 = trunc i32 %311 to i8
%324 = and i8 %323, 7
%325 = lshr i32 %1, 16
%326 = trunc i32 %325 to i8
%327 = and i8 %326, 31
%328 = lshr i32 %1, 8
%329 = trunc i32 %328 to i8
%330 = and i8 %329, 31
%331 = trunc i32 %325 to i16
%332 = and i16 %331, 255
%333 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @GetBurstLen to i32 (i8*, i32, ...)*)(i8* %4, i32 %318)
%334 = icmp eq i32 %5, 7
%335 = and i32 %1, 16777216
%336 = icmp eq i32 %335, 0
br i1 %334, label %337, label %354
337: ; preds = %307
%338 = getelementptr inbounds [2 x i8*], [2 x i8*]* @__const.disassemble.f6_7_inst, i64 0, i64 %310
%339 = load i8*, i8** %338
%340 = zext i8 %322 to i32
%341 = zext i8 %321 to i64
%342 = getelementptr inbounds [4 x i8*], [4 x i8*]* @__const.disassemble.bytenum, i64 0, i64 %341
%343 = load i8*, i8** %342
%344 = zext i8 %330 to i32
br i1 %336, label %348, label %345
345: ; preds = %337
%346 = zext i16 %332 to i32
%347 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.59, i64 0, i64 0), i8* %339, i32 %340, i8* %343, i32 %344, i32 %346, i8* %4)
br label %373
348: ; preds = %337
%349 = zext i8 %327 to i32
%350 = zext i8 %324 to i64
%351 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %350
%352 = load i8*, i8** %351
%353 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.60, i64 0, i64 0), i8* %339, i32 %340, i8* %343, i32 %344, i32 %349, i8* %352, i8* %4)
br label %373
354: ; preds = %307
%355 = getelementptr inbounds [2 x i8*], [2 x i8*]* @__const.disassemble.f6_4_inst, i64 0, i64 %310
%356 = load i8*, i8** %355
%357 = zext i8 %322 to i32
%358 = zext i8 %321 to i64
%359 = getelementptr inbounds [4 x i8*], [4 x i8*]* @__const.disassemble.bytenum, i64 0, i64 %358
%360 = load i8*, i8** %359
%361 = zext i8 %330 to i32
br i1 %336, label %365, label %362
362: ; preds = %354
%363 = zext i16 %332 to i32
%364 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.61, i64 0, i64 0), i8* %356, i32 %357, i8* %360, i32 %361, i32 %363, i8* %4)
br label %373
365: ; preds = %354
%366 = zext i8 %327 to i32
%367 = zext i8 %324 to i64
%368 = getelementptr inbounds [8 x i8*], [8 x i8*]* @__const.disassemble.sis, i64 0, i64 %367
%369 = load i8*, i8** %368
%370 = call i32 (i8*, i8*, ...) @sprintf(i8* dereferenceable(1) %0, i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @.str.62, i64 0, i64 0), i8* %356, i32 %357, i8* %360, i32 %361, i32 %366, i8* %369, i8* %4)
br label %373
371: ; preds = %2
%372 = bitcast i8* %0 to i64*
store i64 22051046311022165, i64* %372
br label %373
373: ; preds = %348, %345, %365, %362, %280, %291, %233, %254, %252, %110, %201, %206, %213, %91, %97, %70, %73, %150, %136, %186, %176, %21, %36, %371
ret void
}