#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int hex2ui(char);
int /*<<< orphan*/ sprintf(char *, char *);
void mnemonic(char *M, char *op1, char *op2, int *addr, char c1, char c2,
              char c3) {
  switch (c1) {
  case '0': {
    sprintf(M, "MOV  ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '1': {
    sprintf(M, "MOVI ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '2': {
    sprintf(M, "AND  ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '3': {
    sprintf(M, "ANDI ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '4': {
    sprintf(M, "ADD  ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '5': {
    sprintf(M, "ADDI ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '6': {
    sprintf(M, "SUB  ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '7': {
    sprintf(M, "SUBI ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '8': {
    sprintf(M, "CMP  ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case '9': {
    sprintf(M, "CMPI ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case 'A': {
    sprintf(M, "OR   ");
    *op1 = c2;
    *op2 = c3;
    *addr = -1;
    break;
  }
  case 'B': {
    sprintf(M, "CALL ");
    *op1 = ' ';
    *op2 = ' ';
    *addr = hex2ui(c2) * 16 + hex2ui(c3);
    break;
  }
  case 'C': {
    sprintf(M, "GOTO ");
    *op1 = ' ';
    *op2 = ' ';
    *addr = hex2ui(c2) * 16 + hex2ui(c3);
    break;
  }
  case 'D': {
    sprintf(M, "BRC  ");
    *op1 = ' ';
    *op2 = ' ';
    *addr = hex2ui(c2) * 16 + hex2ui(c3);
    break;
  }
  case 'E': {
    sprintf(M, "BRZ  ");
    *op1 = ' ';
    *op2 = ' ';
    *addr = hex2ui(c2) * 16 + hex2ui(c3);
    break;
  }
  case 'F': {
    switch (c2) {
    case '0': {
      switch (c3) {
      case '0': {
        sprintf(M, "HALT");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '1': {
        sprintf(M, "NOP");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '2': {
        sprintf(M, "DISOUT");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '3': {
        sprintf(M, "HXDZ");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '4': {
        sprintf(M, "DZHX");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '5': {
        sprintf(M, "RND");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '6': {
        sprintf(M, "TIME");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '7': {
        sprintf(M, "RET");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '8': {
        sprintf(M, "CLEAR");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case '9': {
        sprintf(M, "STC");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case 'A': {
        sprintf(M, "RSC");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case 'B': {
        sprintf(M, "MULT");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case 'C': {
        sprintf(M, "DIV");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case 'D': {
        sprintf(M, "EXRL");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case 'E': {
        sprintf(M, "EXRM");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      case 'F': {
        sprintf(M, "EXRA");
        *op1 = ' ';
        *op2 = ' ';
        *addr = -1;
        break;
      }
      default: {
        sprintf(M, "!!! ERROR !!!");
      }
      }
      break;
    }
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6': {
      sprintf(M, "DISP ");
      *op1 = c2;
      *op2 = c3;
      *addr = -1;
      break;
    }
    case '7': {
      sprintf(M, "MAS  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case '8': {
      sprintf(M, "INV  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case '9': {
      sprintf(M, "SHR  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case 'A': {
      sprintf(M, "SHL  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case 'B': {
      sprintf(M, "ADC  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case 'C': {
      sprintf(M, "SUBC ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case 'D': {
      sprintf(M, "DIN  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case 'E': {
      sprintf(M, "DOT  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    case 'F': {
      sprintf(M, "KIN  ");
      *op1 = c3;
      *op2 = ' ';
      *addr = -1;
      break;
    }
    default: {
      sprintf(M, "!!! ERROR !!!");
    }
    }
    break;
  }
  default: {
    sprintf(M, "!!! ERROR !!!");
  }
  }
}


x86 assembly (clang, -O0):
<mnemonic>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %r8d,-0x4c(%rbp)
mov    %rcx,%rax
mov    -0x4c(%rbp),%ecx
mov    %rax,-0x48(%rbp)
mov    %rdx,%rax
mov    -0x48(%rbp),%rdx
mov    %rax,-0x40(%rbp)
mov    %rsi,%rax
mov    -0x40(%rbp),%rsi
mov    %rax,-0x38(%rbp)
mov    %rdi,%r8
mov    -0x38(%rbp),%rdi
mov    %r9b,%al
mov    0x10(%rbp),%r9b
mov    %r8,-0x8(%rbp)
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %cl,-0x21(%rbp)
mov    %al,-0x22(%rbp)
movsbl -0x21(%rbp),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x16,%eax
ja     19f3 <mnemonic+0x8d3>
mov    -0x30(%rbp),%rax
lea    0xe6f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rdi
lea    0xf6f(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xf44(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xf19(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xeee(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xec3(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xe98(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xe6d(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xe42(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xe17(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xdec(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xdc1(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xd96(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
movsbl -0x22(%rbp),%edi
call   1030 <hex2ui@plt>
shl    $0x4,%eax
mov    %eax,-0x50(%rbp)
movsbl 0x10(%rbp),%edi
call   1030 <hex2ui@plt>
mov    -0x50(%rbp),%ecx
add    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xd56(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
movsbl -0x22(%rbp),%edi
call   1030 <hex2ui@plt>
shl    $0x4,%eax
mov    %eax,-0x54(%rbp)
movsbl 0x10(%rbp),%edi
call   1030 <hex2ui@plt>
mov    -0x54(%rbp),%ecx
add    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xd16(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
movsbl -0x22(%rbp),%edi
call   1030 <hex2ui@plt>
shl    $0x4,%eax
mov    %eax,-0x58(%rbp)
movsbl 0x10(%rbp),%edi
call   1030 <hex2ui@plt>
mov    -0x58(%rbp),%ecx
add    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0xcd6(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
movsbl -0x22(%rbp),%edi
call   1030 <hex2ui@plt>
shl    $0x4,%eax
mov    %eax,-0x5c(%rbp)
movsbl 0x10(%rbp),%edi
call   1030 <hex2ui@plt>
mov    -0x5c(%rbp),%ecx
add    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1a03 <mnemonic+0x8e3>
movsbl -0x22(%rbp),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x68(%rbp)
sub    $0x16,%eax
ja     19de <mnemonic+0x8be>
mov    -0x68(%rbp),%rax
lea    0xb6e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movsbl 0x10(%rbp),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x70(%rbp)
sub    $0x16,%eax
ja     17f1 <mnemonic+0x6d1>
mov    -0x70(%rbp),%rax
lea    0xba0(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rdi
lea    0xc42(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xc1a(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xbf1(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xbcb(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xba3(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xb7b(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xb52(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xb2a(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xb01(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xada(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xab1(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xa88(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xa60(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xa37(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0xa0f(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0x9e7(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x10(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1801 <mnemonic+0x6e1>
mov    -0x8(%rbp),%rdi
lea    0x9bf(%rip),%rsi
call   1040 <sprintf@plt>
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x9b8(%rip),%rsi
call   1040 <sprintf@plt>
mov    -0x22(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    0x10(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x98d(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x964(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x93b(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x912(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x8e9(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x8c0(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x897(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x86e(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x845(%rip),%rsi
call   1040 <sprintf@plt>
mov    0x10(%rbp),%cl
mov    -0x10(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
movb   $0x20,(%rax)
mov    -0x20(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    19ee <mnemonic+0x8ce>
mov    -0x8(%rbp),%rdi
lea    0x7d2(%rip),%rsi
call   1040 <sprintf@plt>
jmp    1a03 <mnemonic+0x8e3>
mov    -0x8(%rbp),%rdi
lea    0x7bd(%rip),%rsi
call   1040 <sprintf@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mnemonic>:
push   %rbp
push   %r14
push   %rbx
add    $0xffffffd0,%r8d
cmp    $0x16,%r8d
ja     12c6 <mnemonic+0x1b6>
mov    %rcx,%rbx
mov    0x20(%rsp),%r14b
lea    0xecf(%rip),%rax
movslq (%rax,%r8,4),%rcx
add    %rax,%rcx
jmp    *%rcx
movw   $0x20,0x4(%rdi)
movl   $0x20564f4d,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x49564f4d,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x20444e41,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x49444e41,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x20444441,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x49444441,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x20425553,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x49425553,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x20504d43,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x49504d43,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x2020524f,(%rdi)
jmp    1276 <mnemonic+0x166>
movw   $0x20,0x4(%rdi)
movl   $0x4c4c4143,(%rdi)
jmp    122b <mnemonic+0x11b>
movw   $0x20,0x4(%rdi)
movl   $0x4f544f47,(%rdi)
jmp    122b <mnemonic+0x11b>
movw   $0x20,0x4(%rdi)
movl   $0x20435242,(%rdi)
jmp    122b <mnemonic+0x11b>
movw   $0x20,0x4(%rdi)
movl   $0x205a5242,(%rdi)
movb   $0x20,(%rsi)
movb   $0x20,(%rdx)
movsbl %r9b,%edi
call   1030 <hex2ui@plt>
mov    %eax,%ebp
shl    $0x4,%ebp
movsbl %r14b,%edi
call   1030 <hex2ui@plt>
add    %ebp,%eax
mov    %eax,(%rbx)
jmp    1282 <mnemonic+0x172>
movsbl %r9b,%eax
add    $0xffffffd0,%eax
cmp    $0x16,%eax
ja     12c6 <mnemonic+0x1b6>
lea    0xdfb(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movw   $0x20,0x4(%rdi)
movl   $0x50534944,(%rdi)
mov    %r9b,(%rsi)
mov    %r14b,(%rdx)
movl   $0xffffffff,(%rbx)
pop    %rbx
pop    %r14
pop    %rbp
ret
movw   $0x20,0x4(%rdi)
movl   $0x204e4944,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movsbl %r14b,%eax
add    $0xffffffd0,%eax
cmp    $0x16,%eax
ja     12c6 <mnemonic+0x1b6>
lea    0xe0a(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movb   $0x0,0x4(%rdi)
movl   $0x544c4148,(%rdi)
jmp    1428 <mnemonic+0x318>
movabs $0x21212120524f52,%rax
mov    %rax,0x6(%rdi)
movabs $0x4f52524520212121,%rax
52 52 4f
mov    %rax,(%rdi)
jmp    1282 <mnemonic+0x172>
movw   $0x20,0x4(%rdi)
movl   $0x2053414d,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movw   $0x20,0x4(%rdi)
movl   $0x20564e49,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movw   $0x20,0x4(%rdi)
movl   $0x20524853,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movw   $0x20,0x4(%rdi)
movl   $0x204c4853,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movw   $0x20,0x4(%rdi)
movl   $0x20434441,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movw   $0x20,0x4(%rdi)
movl   $0x43425553,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movw   $0x20,0x4(%rdi)
movl   $0x20544f44,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movw   $0x20,0x4(%rdi)
movl   $0x204e494b,(%rdi)
mov    %r14b,(%rsi)
jmp    142b <mnemonic+0x31b>
movl   $0x504f4e,(%rdi)
jmp    1428 <mnemonic+0x318>
movl   $0x54554f,0x3(%rdi)
movl   $0x4f534944,(%rdi)
jmp    1428 <mnemonic+0x318>
movb   $0x0,0x4(%rdi)
movl   $0x5a445848,(%rdi)
jmp    1428 <mnemonic+0x318>
movb   $0x0,0x4(%rdi)
movl   $0x58485a44,(%rdi)
jmp    1428 <mnemonic+0x318>
movl   $0x444e52,(%rdi)
jmp    1428 <mnemonic+0x318>
movb   $0x0,0x4(%rdi)
movl   $0x454d4954,(%rdi)
jmp    1428 <mnemonic+0x318>
movl   $0x544552,(%rdi)
jmp    1428 <mnemonic+0x318>
movw   $0x52,0x4(%rdi)
movl   $0x41454c43,(%rdi)
jmp    1428 <mnemonic+0x318>
movl   $0x435453,(%rdi)
jmp    1428 <mnemonic+0x318>
movl   $0x435352,(%rdi)
jmp    1428 <mnemonic+0x318>
movb   $0x0,0x4(%rdi)
movl   $0x544c554d,(%rdi)
jmp    1428 <mnemonic+0x318>
movl   $0x564944,(%rdi)
jmp    1428 <mnemonic+0x318>
movb   $0x0,0x4(%rdi)
movl   $0x4c525845,(%rdi)
jmp    1428 <mnemonic+0x318>
movb   $0x0,0x4(%rdi)
movl   $0x4d525845,(%rdi)
jmp    1428 <mnemonic+0x318>
movb   $0x0,0x4(%rdi)
movl   $0x41525845,(%rdi)
movb   $0x20,(%rsi)
movb   $0x20,(%rdx)
jmp    127c <mnemonic+0x16c>

LLVM IR (-O0):
@.str = [6 x i8] c"MOV \00"
@.str.1 = [6 x i8] c"MOVI \00"
@.str.2 = [6 x i8] c"AND \00"
@.str.3 = [6 x i8] c"ANDI \00"
@.str.4 = [6 x i8] c"ADD \00"
@.str.5 = [6 x i8] c"ADDI \00"
@.str.6 = [6 x i8] c"SUB \00"
@.str.7 = [6 x i8] c"SUBI \00"
@.str.8 = [6 x i8] c"CMP \00"
@.str.9 = [6 x i8] c"CMPI \00"
@.str.10 = [6 x i8] c"OR \00"
@.str.11 = [6 x i8] c"CALL \00"
@.str.12 = [6 x i8] c"GOTO \00"
@.str.13 = [6 x i8] c"BRC \00"
@.str.14 = [6 x i8] c"BRZ \00"
@.str.15 = [5 x i8] c"HALT\00"
@.str.16 = [4 x i8] c"NOP\00"
@.str.17 = [7 x i8] c"DISOUT\00"
@.str.18 = [5 x i8] c"HXDZ\00"
@.str.19 = [5 x i8] c"DZHX\00"
@.str.20 = [4 x i8] c"RND\00"
@.str.21 = [5 x i8] c"TIME\00"
@.str.22 = [4 x i8] c"RET\00"
@.str.23 = [6 x i8] c"CLEAR\00"
@.str.24 = [4 x i8] c"STC\00"
@.str.25 = [4 x i8] c"RSC\00"
@.str.26 = [5 x i8] c"MULT\00"
@.str.27 = [4 x i8] c"DIV\00"
@.str.28 = [5 x i8] c"EXRL\00"
@.str.29 = [5 x i8] c"EXRM\00"
@.str.30 = [5 x i8] c"EXRA\00"
@.str.31 = [14 x i8] c"!!! ERROR !!!\00"
@.str.32 = [6 x i8] c"DISP \00"
@.str.33 = [6 x i8] c"MAS \00"
@.str.34 = [6 x i8] c"INV \00"
@.str.35 = [6 x i8] c"SHR \00"
@.str.36 = [6 x i8] c"SHL \00"
@.str.37 = [6 x i8] c"ADC \00"
@.str.38 = [6 x i8] c"SUBC \00"
@.str.39 = [6 x i8] c"DIN \00"
@.str.40 = [6 x i8] c"DOT \00"
@.str.41 = [6 x i8] c"KIN \00"
define void @mnemonic(i8* %0, i8* %1, i8* %2, i32* %3, i8 signext %4, i8 signext %5, i8 signext %6) {
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i32*
%12 = alloca i8
%13 = alloca i8
%14 = alloca i8
store i8* %0, i8** %8
store i8* %1, i8** %9
store i8* %2, i8** %10
store i32* %3, i32** %11
store i8 %4, i8* %12
store i8 %5, i8* %13
store i8 %6, i8* %14
%15 = load i8, i8* %12
%16 = sext i8 %15 to i32
switch i32 %16, label %334 [
i32 48, label %17
i32 49, label %25
i32 50, label %33
i32 51, label %41
i32 52, label %49
i32 53, label %57
i32 54, label %65
i32 55, label %73
i32 56, label %81
i32 57, label %89
i32 65, label %97
i32 66, label %105
i32 67, label %117
i32 68, label %129
i32 69, label %141
i32 70, label %153
]
17: ; preds = %7
%18 = load i8*, i8** %8
%19 = call i32 @sprintf(i8* %18, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%20 = load i8, i8* %13
%21 = load i8*, i8** %9
store i8 %20, i8* %21
%22 = load i8, i8* %14
%23 = load i8*, i8** %10
store i8 %22, i8* %23
%24 = load i32*, i32** %11
store i32 -1, i32* %24
br label %337
25: ; preds = %7
%26 = load i8*, i8** %8
%27 = call i32 @sprintf(i8* %26, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
%28 = load i8, i8* %13
%29 = load i8*, i8** %9
store i8 %28, i8* %29
%30 = load i8, i8* %14
%31 = load i8*, i8** %10
store i8 %30, i8* %31
%32 = load i32*, i32** %11
store i32 -1, i32* %32
br label %337
33: ; preds = %7
%34 = load i8*, i8** %8
%35 = call i32 @sprintf(i8* %34, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
%36 = load i8, i8* %13
%37 = load i8*, i8** %9
store i8 %36, i8* %37
%38 = load i8, i8* %14
%39 = load i8*, i8** %10
store i8 %38, i8* %39
%40 = load i32*, i32** %11
store i32 -1, i32* %40
br label %337
41: ; preds = %7
%42 = load i8*, i8** %8
%43 = call i32 @sprintf(i8* %42, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0))
%44 = load i8, i8* %13
%45 = load i8*, i8** %9
store i8 %44, i8* %45
%46 = load i8, i8* %14
%47 = load i8*, i8** %10
store i8 %46, i8* %47
%48 = load i32*, i32** %11
store i32 -1, i32* %48
br label %337
49: ; preds = %7
%50 = load i8*, i8** %8
%51 = call i32 @sprintf(i8* %50, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0))
%52 = load i8, i8* %13
%53 = load i8*, i8** %9
store i8 %52, i8* %53
%54 = load i8, i8* %14
%55 = load i8*, i8** %10
store i8 %54, i8* %55
%56 = load i32*, i32** %11
store i32 -1, i32* %56
br label %337
57: ; preds = %7
%58 = load i8*, i8** %8
%59 = call i32 @sprintf(i8* %58, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0))
%60 = load i8, i8* %13
%61 = load i8*, i8** %9
store i8 %60, i8* %61
%62 = load i8, i8* %14
%63 = load i8*, i8** %10
store i8 %62, i8* %63
%64 = load i32*, i32** %11
store i32 -1, i32* %64
br label %337
65: ; preds = %7
%66 = load i8*, i8** %8
%67 = call i32 @sprintf(i8* %66, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0))
%68 = load i8, i8* %13
%69 = load i8*, i8** %9
store i8 %68, i8* %69
%70 = load i8, i8* %14
%71 = load i8*, i8** %10
store i8 %70, i8* %71
%72 = load i32*, i32** %11
store i32 -1, i32* %72
br label %337
73: ; preds = %7
%74 = load i8*, i8** %8
%75 = call i32 @sprintf(i8* %74, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0))
%76 = load i8, i8* %13
%77 = load i8*, i8** %9
store i8 %76, i8* %77
%78 = load i8, i8* %14
%79 = load i8*, i8** %10
store i8 %78, i8* %79
%80 = load i32*, i32** %11
store i32 -1, i32* %80
br label %337
81: ; preds = %7
%82 = load i8*, i8** %8
%83 = call i32 @sprintf(i8* %82, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0))
%84 = load i8, i8* %13
%85 = load i8*, i8** %9
store i8 %84, i8* %85
%86 = load i8, i8* %14
%87 = load i8*, i8** %10
store i8 %86, i8* %87
%88 = load i32*, i32** %11
store i32 -1, i32* %88
br label %337
89: ; preds = %7
%90 = load i8*, i8** %8
%91 = call i32 @sprintf(i8* %90, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.9, i64 0, i64 0))
%92 = load i8, i8* %13
%93 = load i8*, i8** %9
store i8 %92, i8* %93
%94 = load i8, i8* %14
%95 = load i8*, i8** %10
store i8 %94, i8* %95
%96 = load i32*, i32** %11
store i32 -1, i32* %96
br label %337
97: ; preds = %7
%98 = load i8*, i8** %8
%99 = call i32 @sprintf(i8* %98, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0))
%100 = load i8, i8* %13
%101 = load i8*, i8** %9
store i8 %100, i8* %101
%102 = load i8, i8* %14
%103 = load i8*, i8** %10
store i8 %102, i8* %103
%104 = load i32*, i32** %11
store i32 -1, i32* %104
br label %337
105: ; preds = %7
%106 = load i8*, i8** %8
%107 = call i32 @sprintf(i8* %106, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
%108 = load i8*, i8** %9
store i8 32, i8* %108
%109 = load i8*, i8** %10
store i8 32, i8* %109
%110 = load i8, i8* %13
%111 = call i32 @hex2ui(i8 signext %110)
%112 = mul nsw i32 %111, 16
%113 = load i8, i8* %14
%114 = call i32 @hex2ui(i8 signext %113)
%115 = add nsw i32 %112, %114
%116 = load i32*, i32** %11
store i32 %115, i32* %116
br label %337
117: ; preds = %7
%118 = load i8*, i8** %8
%119 = call i32 @sprintf(i8* %118, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.12, i64 0, i64 0))
%120 = load i8*, i8** %9
store i8 32, i8* %120
%121 = load i8*, i8** %10
store i8 32, i8* %121
%122 = load i8, i8* %13
%123 = call i32 @hex2ui(i8 signext %122)
%124 = mul nsw i32 %123, 16
%125 = load i8, i8* %14
%126 = call i32 @hex2ui(i8 signext %125)
%127 = add nsw i32 %124, %126
%128 = load i32*, i32** %11
store i32 %127, i32* %128
br label %337
129: ; preds = %7
%130 = load i8*, i8** %8
%131 = call i32 @sprintf(i8* %130, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0))
%132 = load i8*, i8** %9
store i8 32, i8* %132
%133 = load i8*, i8** %10
store i8 32, i8* %133
%134 = load i8, i8* %13
%135 = call i32 @hex2ui(i8 signext %134)
%136 = mul nsw i32 %135, 16
%137 = load i8, i8* %14
%138 = call i32 @hex2ui(i8 signext %137)
%139 = add nsw i32 %136, %138
%140 = load i32*, i32** %11
store i32 %139, i32* %140
br label %337
141: ; preds = %7
%142 = load i8*, i8** %8
%143 = call i32 @sprintf(i8* %142, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, i64 0, i64 0))
%144 = load i8*, i8** %9
store i8 32, i8* %144
%145 = load i8*, i8** %10
store i8 32, i8* %145
%146 = load i8, i8* %13
%147 = call i32 @hex2ui(i8 signext %146)
%148 = mul nsw i32 %147, 16
%149 = load i8, i8* %14
%150 = call i32 @hex2ui(i8 signext %149)
%151 = add nsw i32 %148, %150
%152 = load i32*, i32** %11
store i32 %151, i32* %152
br label %337
153: ; preds = %7
%154 = load i8, i8* %13
%155 = sext i8 %154 to i32
switch i32 %155, label %330 [
i32 48, label %156
i32 49, label %259
i32 50, label %259
i32 51, label %259
i32 52, label %259
i32 53, label %259
i32 54, label %259
i32 55, label %267
i32 56, label %274
i32 57, label %281
i32 65, label %288
i32 66, label %295
i32 67, label %302
i32 68, label %309
i32 69, label %316
i32 70, label %323
]
156: ; preds = %153
%157 = load i8, i8* %14
%158 = sext i8 %157 to i32
switch i32 %158, label %255 [
i32 48, label %159
i32 49, label %165
i32 50, label %171
i32 51, label %177
i32 52, label %183
i32 53, label %189
i32 54, label %195
i32 55, label %201
i32 56, label %207
i32 57, label %213
i32 65, label %219
i32 66, label %225
i32 67, label %231
i32 68, label %237
i32 69, label %243
i32 70, label %249
]
159: ; preds = %156
%160 = load i8*, i8** %8
%161 = call i32 @sprintf(i8* %160, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0))
%162 = load i8*, i8** %9
store i8 32, i8* %162
%163 = load i8*, i8** %10
store i8 32, i8* %163
%164 = load i32*, i32** %11
store i32 -1, i32* %164
br label %258
165: ; preds = %156
%166 = load i8*, i8** %8
%167 = call i32 @sprintf(i8* %166, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.16, i64 0, i64 0))
%168 = load i8*, i8** %9
store i8 32, i8* %168
%169 = load i8*, i8** %10
store i8 32, i8* %169
%170 = load i32*, i32** %11
store i32 -1, i32* %170
br label %258
171: ; preds = %156
%172 = load i8*, i8** %8
%173 = call i32 @sprintf(i8* %172, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0))
%174 = load i8*, i8** %9
store i8 32, i8* %174
%175 = load i8*, i8** %10
store i8 32, i8* %175
%176 = load i32*, i32** %11
store i32 -1, i32* %176
br label %258
177: ; preds = %156
%178 = load i8*, i8** %8
%179 = call i32 @sprintf(i8* %178, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0))
%180 = load i8*, i8** %9
store i8 32, i8* %180
%181 = load i8*, i8** %10
store i8 32, i8* %181
%182 = load i32*, i32** %11
store i32 -1, i32* %182
br label %258
183: ; preds = %156
%184 = load i8*, i8** %8
%185 = call i32 @sprintf(i8* %184, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0))
%186 = load i8*, i8** %9
store i8 32, i8* %186
%187 = load i8*, i8** %10
store i8 32, i8* %187
%188 = load i32*, i32** %11
store i32 -1, i32* %188
br label %258
189: ; preds = %156
%190 = load i8*, i8** %8
%191 = call i32 @sprintf(i8* %190, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.20, i64 0, i64 0))
%192 = load i8*, i8** %9
store i8 32, i8* %192
%193 = load i8*, i8** %10
store i8 32, i8* %193
%194 = load i32*, i32** %11
store i32 -1, i32* %194
br label %258
195: ; preds = %156
%196 = load i8*, i8** %8
%197 = call i32 @sprintf(i8* %196, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i64 0, i64 0))
%198 = load i8*, i8** %9
store i8 32, i8* %198
%199 = load i8*, i8** %10
store i8 32, i8* %199
%200 = load i32*, i32** %11
store i32 -1, i32* %200
br label %258
201: ; preds = %156
%202 = load i8*, i8** %8
%203 = call i32 @sprintf(i8* %202, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.22, i64 0, i64 0))
%204 = load i8*, i8** %9
store i8 32, i8* %204
%205 = load i8*, i8** %10
store i8 32, i8* %205
%206 = load i32*, i32** %11
store i32 -1, i32* %206
br label %258
207: ; preds = %156
%208 = load i8*, i8** %8
%209 = call i32 @sprintf(i8* %208, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.23, i64 0, i64 0))
%210 = load i8*, i8** %9
store i8 32, i8* %210
%211 = load i8*, i8** %10
store i8 32, i8* %211
%212 = load i32*, i32** %11
store i32 -1, i32* %212
br label %258
213: ; preds = %156
%214 = load i8*, i8** %8
%215 = call i32 @sprintf(i8* %214, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.24, i64 0, i64 0))
%216 = load i8*, i8** %9
store i8 32, i8* %216
%217 = load i8*, i8** %10
store i8 32, i8* %217
%218 = load i32*, i32** %11
store i32 -1, i32* %218
br label %258
219: ; preds = %156
%220 = load i8*, i8** %8
%221 = call i32 @sprintf(i8* %220, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.25, i64 0, i64 0))
%222 = load i8*, i8** %9
store i8 32, i8* %222
%223 = load i8*, i8** %10
store i8 32, i8* %223
%224 = load i32*, i32** %11
store i32 -1, i32* %224
br label %258
225: ; preds = %156
%226 = load i8*, i8** %8
%227 = call i32 @sprintf(i8* %226, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i64 0, i64 0))
%228 = load i8*, i8** %9
store i8 32, i8* %228
%229 = load i8*, i8** %10
store i8 32, i8* %229
%230 = load i32*, i32** %11
store i32 -1, i32* %230
br label %258
231: ; preds = %156
%232 = load i8*, i8** %8
%233 = call i32 @sprintf(i8* %232, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.27, i64 0, i64 0))
%234 = load i8*, i8** %9
store i8 32, i8* %234
%235 = load i8*, i8** %10
store i8 32, i8* %235
%236 = load i32*, i32** %11
store i32 -1, i32* %236
br label %258
237: ; preds = %156
%238 = load i8*, i8** %8
%239 = call i32 @sprintf(i8* %238, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.28, i64 0, i64 0))
%240 = load i8*, i8** %9
store i8 32, i8* %240
%241 = load i8*, i8** %10
store i8 32, i8* %241
%242 = load i32*, i32** %11
store i32 -1, i32* %242
br label %258
243: ; preds = %156
%244 = load i8*, i8** %8
%245 = call i32 @sprintf(i8* %244, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.29, i64 0, i64 0))
%246 = load i8*, i8** %9
store i8 32, i8* %246
%247 = load i8*, i8** %10
store i8 32, i8* %247
%248 = load i32*, i32** %11
store i32 -1, i32* %248
br label %258
249: ; preds = %156
%250 = load i8*, i8** %8
%251 = call i32 @sprintf(i8* %250, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.30, i64 0, i64 0))
%252 = load i8*, i8** %9
store i8 32, i8* %252
%253 = load i8*, i8** %10
store i8 32, i8* %253
%254 = load i32*, i32** %11
store i32 -1, i32* %254
br label %258
255: ; preds = %156
%256 = load i8*, i8** %8
%257 = call i32 @sprintf(i8* %256, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.31, i64 0, i64 0))
br label %258
258: ; preds = %255, %249, %243, %237, %231, %225, %219, %213, %207, %201, %195, %189, %183, %177, %171, %165, %159
br label %333
259: ; preds = %153, %153, %153, %153, %153, %153
%260 = load i8*, i8** %8
%261 = call i32 @sprintf(i8* %260, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.32, i64 0, i64 0))
%262 = load i8, i8* %13
%263 = load i8*, i8** %9
store i8 %262, i8* %263
%264 = load i8, i8* %14
%265 = load i8*, i8** %10
store i8 %264, i8* %265
%266 = load i32*, i32** %11
store i32 -1, i32* %266
br label %333
267: ; preds = %153
%268 = load i8*, i8** %8
%269 = call i32 @sprintf(i8* %268, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0))
%270 = load i8, i8* %14
%271 = load i8*, i8** %9
store i8 %270, i8* %271
%272 = load i8*, i8** %10
store i8 32, i8* %272
%273 = load i32*, i32** %11
store i32 -1, i32* %273
br label %333
274: ; preds = %153
%275 = load i8*, i8** %8
%276 = call i32 @sprintf(i8* %275, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.34, i64 0, i64 0))
%277 = load i8, i8* %14
%278 = load i8*, i8** %9
store i8 %277, i8* %278
%279 = load i8*, i8** %10
store i8 32, i8* %279
%280 = load i32*, i32** %11
store i32 -1, i32* %280
br label %333
281: ; preds = %153
%282 = load i8*, i8** %8
%283 = call i32 @sprintf(i8* %282, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.35, i64 0, i64 0))
%284 = load i8, i8* %14
%285 = load i8*, i8** %9
store i8 %284, i8* %285
%286 = load i8*, i8** %10
store i8 32, i8* %286
%287 = load i32*, i32** %11
store i32 -1, i32* %287
br label %333
288: ; preds = %153
%289 = load i8*, i8** %8
%290 = call i32 @sprintf(i8* %289, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.36, i64 0, i64 0))
%291 = load i8, i8* %14
%292 = load i8*, i8** %9
store i8 %291, i8* %292
%293 = load i8*, i8** %10
store i8 32, i8* %293
%294 = load i32*, i32** %11
store i32 -1, i32* %294
br label %333
295: ; preds = %153
%296 = load i8*, i8** %8
%297 = call i32 @sprintf(i8* %296, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0))
%298 = load i8, i8* %14
%299 = load i8*, i8** %9
store i8 %298, i8* %299
%300 = load i8*, i8** %10
store i8 32, i8* %300
%301 = load i32*, i32** %11
store i32 -1, i32* %301
br label %333
302: ; preds = %153
%303 = load i8*, i8** %8
%304 = call i32 @sprintf(i8* %303, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.38, i64 0, i64 0))
%305 = load i8, i8* %14
%306 = load i8*, i8** %9
store i8 %305, i8* %306
%307 = load i8*, i8** %10
store i8 32, i8* %307
%308 = load i32*, i32** %11
store i32 -1, i32* %308
br label %333
309: ; preds = %153
%310 = load i8*, i8** %8
%311 = call i32 @sprintf(i8* %310, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.39, i64 0, i64 0))
%312 = load i8, i8* %14
%313 = load i8*, i8** %9
store i8 %312, i8* %313
%314 = load i8*, i8** %10
store i8 32, i8* %314
%315 = load i32*, i32** %11
store i32 -1, i32* %315
br label %333
316: ; preds = %153
%317 = load i8*, i8** %8
%318 = call i32 @sprintf(i8* %317, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.40, i64 0, i64 0))
%319 = load i8, i8* %14
%320 = load i8*, i8** %9
store i8 %319, i8* %320
%321 = load i8*, i8** %10
store i8 32, i8* %321
%322 = load i32*, i32** %11
store i32 -1, i32* %322
br label %333
323: ; preds = %153
%324 = load i8*, i8** %8
%325 = call i32 @sprintf(i8* %324, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.41, i64 0, i64 0))
%326 = load i8, i8* %14
%327 = load i8*, i8** %9
store i8 %326, i8* %327
%328 = load i8*, i8** %10
store i8 32, i8* %328
%329 = load i32*, i32** %11
store i32 -1, i32* %329
br label %333
330: ; preds = %153
%331 = load i8*, i8** %8
%332 = call i32 @sprintf(i8* %331, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.31, i64 0, i64 0))
br label %333
333: ; preds = %330, %323, %316, %309, %302, %295, %288, %281, %274, %267, %259, %258
br label %337
334: ; preds = %7
%335 = load i8*, i8** %8
%336 = call i32 @sprintf(i8* %335, i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.31, i64 0, i64 0))
br label %337
337: ; preds = %334, %333, %141, %129, %117, %105, %97, %89, %81, %73, %65, %57, %49, %41, %33, %25, %17
ret void
}

LLVM IR (-O2):
@.str = [6 x i8] c"MOV \00"
@.str.1 = [6 x i8] c"MOVI \00"
@.str.2 = [6 x i8] c"AND \00"
@.str.3 = [6 x i8] c"ANDI \00"
@.str.4 = [6 x i8] c"ADD \00"
@.str.5 = [6 x i8] c"ADDI \00"
@.str.6 = [6 x i8] c"SUB \00"
@.str.7 = [6 x i8] c"SUBI \00"
@.str.8 = [6 x i8] c"CMP \00"
@.str.9 = [6 x i8] c"CMPI \00"
@.str.10 = [6 x i8] c"OR \00"
@.str.11 = [6 x i8] c"CALL \00"
@.str.12 = [6 x i8] c"GOTO \00"
@.str.13 = [6 x i8] c"BRC \00"
@.str.14 = [6 x i8] c"BRZ \00"
@.str.15 = [5 x i8] c"HALT\00"
@.str.17 = [7 x i8] c"DISOUT\00"
@.str.18 = [5 x i8] c"HXDZ\00"
@.str.19 = [5 x i8] c"DZHX\00"
@.str.21 = [5 x i8] c"TIME\00"
@.str.23 = [6 x i8] c"CLEAR\00"
@.str.26 = [5 x i8] c"MULT\00"
@.str.28 = [5 x i8] c"EXRL\00"
@.str.29 = [5 x i8] c"EXRM\00"
@.str.30 = [5 x i8] c"EXRA\00"
@.str.31 = [14 x i8] c"!!! ERROR !!!\00"
@.str.32 = [6 x i8] c"DISP \00"
@.str.33 = [6 x i8] c"MAS \00"
@.str.34 = [6 x i8] c"INV \00"
@.str.35 = [6 x i8] c"SHR \00"
@.str.36 = [6 x i8] c"SHL \00"
@.str.37 = [6 x i8] c"ADC \00"
@.str.38 = [6 x i8] c"SUBC \00"
@.str.39 = [6 x i8] c"DIN \00"
@.str.40 = [6 x i8] c"DOT \00"
@.str.41 = [6 x i8] c"KIN \00"
define void @mnemonic(i8* writeonly %0, i8* writeonly %1, i8* writeonly %2, i32* writeonly %3, i8 signext %4, i8 signext %5, i8 signext %6) {
%8 = sext i8 %4 to i32
switch i32 %8, label %78 [
i32 48, label %9
i32 49, label %10
i32 50, label %11
i32 51, label %12
i32 52, label %13
i32 53, label %14
i32 54, label %15
i32 55, label %16
i32 56, label %17
i32 57, label %18
i32 65, label %19
i32 66, label %20
i32 67, label %25
i32 68, label %30
i32 69, label %35
i32 70, label %40
]
9: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
10: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
11: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
12: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
13: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
14: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.5, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
15: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
16: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.7, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
17: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
18: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.9, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
19: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.10, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
20: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0), i64 6, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
%21 = tail call i32 @hex2ui(i8 signext %5)
%22 = shl nsw i32 %21, 4
%23 = tail call i32 @hex2ui(i8 signext %6)
%24 = add nsw i32 %22, %23
store i32 %24, i32* %3
br label %79
25: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.12, i64 0, i64 0), i64 6, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
%26 = tail call i32 @hex2ui(i8 signext %5)
%27 = shl nsw i32 %26, 4
%28 = tail call i32 @hex2ui(i8 signext %6)
%29 = add nsw i32 %27, %28
store i32 %29, i32* %3
br label %79
30: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.13, i64 0, i64 0), i64 6, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
%31 = tail call i32 @hex2ui(i8 signext %5)
%32 = shl nsw i32 %31, 4
%33 = tail call i32 @hex2ui(i8 signext %6)
%34 = add nsw i32 %32, %33
store i32 %34, i32* %3
br label %79
35: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.14, i64 0, i64 0), i64 6, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
%36 = tail call i32 @hex2ui(i8 signext %5)
%37 = shl nsw i32 %36, 4
%38 = tail call i32 @hex2ui(i8 signext %6)
%39 = add nsw i32 %37, %38
store i32 %39, i32* %3
br label %79
40: ; preds = %7
%41 = sext i8 %5 to i32
switch i32 %41, label %77 [
i32 48, label %42
i32 49, label %67
i32 50, label %67
i32 51, label %67
i32 52, label %67
i32 53, label %67
i32 54, label %67
i32 55, label %68
i32 56, label %69
i32 57, label %70
i32 65, label %71
i32 66, label %72
i32 67, label %73
i32 68, label %74
i32 69, label %75
i32 70, label %76
]
42: ; preds = %40
%43 = sext i8 %6 to i32
switch i32 %43, label %66 [
i32 48, label %44
i32 49, label %45
i32 50, label %47
i32 51, label %48
i32 52, label %49
i32 53, label %50
i32 54, label %52
i32 55, label %53
i32 56, label %55
i32 57, label %56
i32 65, label %58
i32 66, label %60
i32 67, label %61
i32 68, label %63
i32 69, label %64
i32 70, label %65
]
44: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.15, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
45: ; preds = %42
%46 = bitcast i8* %0 to i32*
store i32 5263182, i32* %46
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
47: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(7) %0, i8* align 1 dereferenceable(7) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.17, i64 0, i64 0), i64 7, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
48: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.18, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
49: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.19, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
50: ; preds = %42
%51 = bitcast i8* %0 to i32*
store i32 4476498, i32* %51
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
52: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.21, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
53: ; preds = %42
%54 = bitcast i8* %0 to i32*
store i32 5522770, i32* %54
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
55: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.23, i64 0, i64 0), i64 6, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
56: ; preds = %42
%57 = bitcast i8* %0 to i32*
store i32 4412499, i32* %57
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
58: ; preds = %42
%59 = bitcast i8* %0 to i32*
store i32 4412242, i32* %59
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
60: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.26, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
61: ; preds = %42
%62 = bitcast i8* %0 to i32*
store i32 5654852, i32* %62
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
63: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.28, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
64: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.29, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
65: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(5) %0, i8* align 1 dereferenceable(5) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.30, i64 0, i64 0), i64 5, i1 false)
store i8 32, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
66: ; preds = %42
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(14) %0, i8* align 1 dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.31, i64 0, i64 0), i64 14, i1 false)
br label %79
67: ; preds = %40, %40, %40, %40, %40, %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.32, i64 0, i64 0), i64 6, i1 false)
store i8 %5, i8* %1
store i8 %6, i8* %2
store i32 -1, i32* %3
br label %79
68: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.33, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
69: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.34, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
70: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.35, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
71: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.36, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
72: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.37, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
73: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.38, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
74: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.39, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
75: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.40, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
76: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(6) %0, i8* align 1 dereferenceable(6) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.41, i64 0, i64 0), i64 6, i1 false)
store i8 %6, i8* %1
store i8 32, i8* %2
store i32 -1, i32* %3
br label %79
77: ; preds = %40
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(14) %0, i8* align 1 dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.31, i64 0, i64 0), i64 14, i1 false)
br label %79
78: ; preds = %7
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 1 dereferenceable(14) %0, i8* align 1 dereferenceable(14) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.31, i64 0, i64 0), i64 14, i1 false)
br label %79
79: ; preds = %67, %68, %69, %70, %71, %72, %73, %74, %75, %76, %77, %66, %65, %64, %63, %61, %60, %58, %56, %55, %53, %52, %50, %49, %48, %47, %45, %44, %78, %35, %30, %25, %20, %19, %18, %17, %16, %15, %14, %13, %12, %11, %10, %9
ret void
}