#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 */
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
scalar_t__ feof(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
scalar_t__ getc(int /*<<< orphan*/ *);
int /*<<< orphan*/ mnemonic(char *, char *, char *, int *, char, char, char);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ stderr;
int main(int argc, char *argv[]) {
  int lno, fno;
  char buff[256][4];
  char M[256][16], op1[256], op2[256];
  int addr[256];
  FILE *micfile;
  if (argc != 2) {
    printf("micdsm (version %s)\n", "20.8.2005");
    printf(" Copyright %s\n",
           "(c) 2005 Dr.-Ing. Ingo D. Rullhusen <d01c@uni-bremen.de>");
    printf(" micdsm comes with ABSOLUTELY NO WARRANTY; for details see GNU\n");
    printf(" GENERAL PUBLIC LICENSE. This is free software, and you are "
           "welcome to\n");
    printf(" redistribute it under certain conditions; see GNU GENERAL PUBLIC "
           "LICENSE\n");
    printf(" for details.\n\n");
    printf("micdsm <MIC file>\n");
    return (0);
  }
  micfile = fopen(argv[1], "r");
  if (!micfile) {
    fprintf(stderr, "Cannot open file %s!\n", argv[1]);
    return (2);
  }
  for (lno = 0; lno < 256; lno++) {
    buff[lno][0] = (char)getc(micfile);
    buff[lno][1] = (char)getc(micfile);
    buff[lno][2] = (char)getc(micfile);
    buff[lno][3] = (char)getc(micfile);
    if (feof(micfile)) {
      fprintf(stderr, "MIC file incomplete!\n");
      return (5);
    }
    if (buff[lno][3] != '\r') {
      fprintf(stderr, "MIC file inconsistent!\n");
      return (5);
    }
    mnemonic(M[lno], &(op1[lno]), &(op2[lno]), &(addr[lno]), buff[lno][0],
             buff[lno][1], buff[lno][2]);
  }
  buff[0][3] = '_';
  for (lno = 0; lno < 256; lno++) {
    if (addr[lno] > -1)
      buff[addr[lno]][3] = '_';
  }
  for (fno = 256; fno > 1; fno--) {
    if (buff[255][0] != buff[fno - 2][0] || buff[255][1] != buff[fno - 2][1] ||
        buff[255][2] != buff[fno - 2][2] || buff[fno - 1][3] == '_')
      break;
  }
  printf(";\n");
  printf("; disassembly of \"%s\"\n", argv[1]);
  printf(";\n\n");
  if (fno < 256) {
    printf("fill = %c%c%c\n", buff[255][0], buff[255][1], buff[255][2]);
  }
  printf("00   = _00\n");
  for (lno = 0; lno < fno; lno++) {
    if (buff[lno][3] == '_') {
      printf("\n");
      printf("_%.2X: ", lno);
    } else {
      printf("     ");
    }
    printf("%s", M[lno]);
    if (op1[lno] != ' ') {
      printf("%c", op1[lno]);
      if (op2[lno] != ' ') {
        printf(",%c", op2[lno]);
      }
    } else if (addr[lno] > -1) {
      printf("_%.2X", addr[lno]);
    }
    printf("\n");
  }
  fclose(micfile);
  return (0);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a30,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
je     120f <main+0x9f>
lea    0xe66(%rip),%rdi
lea    0xe74(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xe70(%rip),%rdi
lea    0xe78(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xea3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xed5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf0f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf4c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xf4e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    165e <main+0x4ee>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xf3f(%rip),%rsi
call   1080 <fopen@plt>
mov    %rax,-0x1a28(%rbp)
cmpq   $0x0,-0x1a28(%rbp)
jne    1263 <main+0xf3>
mov    0x2da1(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdx
lea    0xf0f(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x2,-0x4(%rbp)
jmp    165e <main+0x4ee>
movl   $0x0,-0x14(%rbp)
cmpl   $0x100,-0x14(%rbp)
jge    13ce <main+0x25e>
mov    -0x1a28(%rbp),%rdi
call   1090 <getc@plt>
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x420(%rbp,%rax,4)
mov    -0x1a28(%rbp),%rdi
call   1090 <getc@plt>
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x41f(%rbp,%rax,4)
mov    -0x1a28(%rbp),%rdi
call   1090 <getc@plt>
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x41e(%rbp,%rax,4)
mov    -0x1a28(%rbp),%rdi
call   1090 <getc@plt>
mov    %al,%cl
movslq -0x14(%rbp),%rax
mov    %cl,-0x41d(%rbp,%rax,4)
mov    -0x1a28(%rbp),%rdi
call   1060 <feof@plt>
cmp    $0x0,%rax
je     1314 <main+0x1a4>
mov    0x2ce8(%rip),%rax
mov    (%rax),%edi
lea    0xe74(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x5,-0x4(%rbp)
jmp    165e <main+0x4ee>
movslq -0x14(%rbp),%rax
movsbl -0x41d(%rbp,%rax,4),%eax
ff
cmp    $0xd,%eax
je     134c <main+0x1dc>
mov    0x2cb0(%rip),%rax
mov    (%rax),%edi
lea    0xe52(%rip),%rsi
mov    $0x0,%al
call   1050 <fprintf@plt>
movl   $0x5,-0x4(%rbp)
jmp    165e <main+0x4ee>
movslq -0x14(%rbp),%rax
lea    -0x1420(%rbp),%rdi
shl    $0x4,%rax
add    %rax,%rdi
movslq -0x14(%rbp),%rax
lea    -0x1520(%rbp),%rsi
add    %rax,%rsi
movslq -0x14(%rbp),%rax
lea    -0x1620(%rbp),%rdx
add    %rax,%rdx
movslq -0x14(%rbp),%rax
lea    -0x1a20(%rbp),%rcx
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x14(%rbp),%rax
mov    -0x420(%rbp,%rax,4),%r8b
ff
movslq -0x14(%rbp),%rax
mov    -0x41f(%rbp,%rax,4),%r9b
ff
movslq -0x14(%rbp),%rax
movsbl %r8b,%r8d
movsbl %r9b,%r9d
movsbl -0x41e(%rbp,%rax,4),%eax
ff
mov    %eax,(%rsp)
call   1070 <mnemonic@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    126a <main+0xfa>
movb   $0x5f,-0x41d(%rbp)
movl   $0x0,-0x14(%rbp)
cmpl   $0x100,-0x14(%rbp)
jge    1422 <main+0x2b2>
movslq -0x14(%rbp),%rax
cmpl   $0xffffffff,-0x1a20(%rbp,%rax,4)
ff
jle    140f <main+0x29f>
movslq -0x14(%rbp),%rax
movslq -0x1a20(%rbp,%rax,4),%rax
ff
movb   $0x5f,-0x41d(%rbp,%rax,4)
5f
jmp    1414 <main+0x2a4>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    13dc <main+0x26c>
movl   $0x100,-0x18(%rbp)
cmpl   $0x1,-0x18(%rbp)
jle    14bb <main+0x34b>
movsbl -0x24(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsbl -0x420(%rbp,%rcx,4),%ecx
ff
cmp    %ecx,%eax
jne    14a3 <main+0x333>
movsbl -0x23(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsbl -0x41f(%rbp,%rcx,4),%ecx
ff
cmp    %ecx,%eax
jne    14a3 <main+0x333>
movsbl -0x22(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsbl -0x41e(%rbp,%rcx,4),%ecx
ff
cmp    %ecx,%eax
jne    14a3 <main+0x333>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0x41d(%rbp,%rax,4),%eax
ff
cmp    $0x5f,%eax
jne    14a8 <main+0x338>
jmp    14bb <main+0x34b>
jmp    14ad <main+0x33d>
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    1429 <main+0x2b9>
lea    0xce1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rsi
lea    0xcce(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xcd7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x100,-0x18(%rbp)
jge    1514 <main+0x3a4>
movsbl -0x24(%rbp),%esi
movsbl -0x23(%rbp),%edx
movsbl -0x22(%rbp),%ecx
lea    0xcb4(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    0xcb5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    164b <main+0x4db>
movslq -0x14(%rbp),%rax
movsbl -0x41d(%rbp,%rax,4),%eax
ff
cmp    $0x5f,%eax
jne    156e <main+0x3fe>
lea    0xbf7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%esi
lea    0xc7a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    157c <main+0x40c>
lea    0xc6f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0x14(%rbp),%rax
lea    -0x1420(%rbp),%rsi
shl    $0x4,%rax
add    %rax,%rsi
lea    0xc55(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0x14(%rbp),%rax
movsbl -0x1520(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     15ff <main+0x48f>
movslq -0x14(%rbp),%rax
movsbl -0x1520(%rbp,%rax,1),%esi
ff
lea    0xc2a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0x14(%rbp),%rax
movsbl -0x1620(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     15fa <main+0x48a>
movslq -0x14(%rbp),%rax
movsbl -0x1620(%rbp,%rax,1),%esi
ff
lea    0xbfa(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    162f <main+0x4bf>
movslq -0x14(%rbp),%rax
cmpl   $0xffffffff,-0x1a20(%rbp,%rax,4)
ff
jle    162a <main+0x4ba>
movslq -0x14(%rbp),%rax
mov    -0x1a20(%rbp,%rax,4),%esi
lea    0xbce(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    162f <main+0x4bf>
lea    0xb12(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1529 <main+0x3b9>
mov    -0x1a28(%rbp),%rdi
call   1030 <fclose@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1a30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a38,%rsp
cmp    $0x2,%edi
jne    13af <main+0x21f>
mov    %rsi,%rbx
mov    0x8(%rsi),%rdi
lea    0xeaf(%rip),%rsi
call   10a0 <fopen@plt>
mov    %rax,0x10(%rsp)
test   %rax,%rax
je     141c <main+0x28c>
mov    %rbx,0x18(%rsp)
lea    0x630(%rsp),%rbx
lea    0xa30(%rsp),%rbp
xor    %r12d,%r12d
mov    0x10(%rsp),%r13
nopl   0x0(%rax,%rax,1)
mov    %rbp,0x20(%rsp)
mov    %rbx,0x28(%rsp)
mov    %r13,%rdi
call   10b0 <getc@plt>
mov    %rax,%rbx
mov    %bl,0x30(%rsp,%r12,4)
mov    %r13,%rdi
call   10b0 <getc@plt>
mov    %rax,%rbp
mov    %bpl,0x31(%rsp,%r12,4)
mov    %r13,%rdi
call   10b0 <getc@plt>
mov    %rax,%r14
mov    %r14b,0x32(%rsp,%r12,4)
mov    %r13,%rdi
call   10b0 <getc@plt>
mov    %rax,%r15
mov    %r15b,0x33(%rsp,%r12,4)
mov    %r13,%rdi
call   1080 <feof@plt>
test   %rax,%rax
jne    1441 <main+0x2b1>
cmp    $0xd,%r15b
jne    1453 <main+0x2c3>
lea    (%rsp,%r12,1),%rsi
add    $0x530,%rsi
lea    0x430(%rsp,%r12,1),%rdx
movsbl %r14b,%eax
mov    %eax,(%rsp)
movsbl %bl,%r8d
movsbl %bpl,%r9d
mov    0x20(%rsp),%rbp
mov    %rbp,%rdi
mov    0x28(%rsp),%rbx
mov    %rbx,%rcx
call   1090 <mnemonic@plt>
add    $0x1,%r12
add    $0x4,%rbx
add    $0x10,%rbp
cmp    $0x100,%r12
jne    11f0 <main+0x60>
movb   $0x5f,0x33(%rsp)
xor    %eax,%eax
pcmpeqd %xmm0,%xmm0
jmp    12d0 <main+0x140>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x8,%rax
cmp    $0x100,%rax
je     1474 <main+0x2e4>
movdqa 0x630(%rsp,%rax,4),%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
movd   %xmm2,%ecx
test   $0x1,%cl
je     12f3 <main+0x163>
movd   %xmm1,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
pextrw $0x2,%xmm2,%ecx
test   $0x1,%cl
je     130b <main+0x17b>
pshufd $0x55,%xmm1,%xmm3
movd   %xmm3,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
pextrw $0x4,%xmm2,%ecx
test   $0x1,%cl
je     1323 <main+0x193>
pshufd $0xee,%xmm1,%xmm3
movd   %xmm3,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
pextrw $0x6,%xmm2,%ecx
test   $0x1,%cl
je     133b <main+0x1ab>
pshufd $0xff,%xmm1,%xmm1
movd   %xmm1,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
movdqa 0x640(%rsp,%rax,4),%xmm1
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
movd   %xmm2,%ecx
test   $0x1,%cl
je     135e <main+0x1ce>
movd   %xmm1,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
pextrw $0x2,%xmm2,%ecx
test   $0x1,%cl
je     1376 <main+0x1e6>
pshufd $0x55,%xmm1,%xmm3
movd   %xmm3,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
pextrw $0x4,%xmm2,%ecx
test   $0x1,%cl
je     138e <main+0x1fe>
pshufd $0xee,%xmm1,%xmm3
movd   %xmm3,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
pextrw $0x6,%xmm2,%ecx
test   $0x1,%cl
je     12c0 <main+0x130>
pshufd $0xff,%xmm1,%xmm1
movd   %xmm1,%ecx
movb   $0x5f,0x33(%rsp,%rcx,4)
jmp    12c0 <main+0x130>
lea    0xc4a(%rip),%rdi
lea    0xc58(%rip),%rsi
xor    %ebx,%ebx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xc52(%rip),%rdi
lea    0xc5a(%rip),%rsi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xd1c(%rip),%rdi
call   1040 <puts@plt>
lea    0xd4f(%rip),%rdi
call   1040 <puts@plt>
lea    0xd8a(%rip),%rdi
call   1040 <puts@plt>
lea    0xdc8(%rip),%rdi
call   1040 <puts@plt>
lea    0xdcb(%rip),%rdi
call   1040 <puts@plt>
jmp    1547 <main+0x3b7>
mov    0x2bbd(%rip),%rax
mov    (%rax),%edi
mov    0x8(%rbx),%rdx
lea    0xc39(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0x2,%ebx
jmp    1547 <main+0x3b7>
mov    0x2b98(%rip),%rax
mov    (%rax),%edi
lea    0xc2e(%rip),%rsi
jmp    1463 <main+0x2d3>
mov    0x2b86(%rip),%rax
mov    (%rax),%edi
lea    0xc32(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0x5,%ebx
jmp    1547 <main+0x3b7>
movsbl 0x42c(%rsp),%ebx
movsbl 0x42d(%rsp),%r14d
movsbl 0x42e(%rsp),%r12d
xor    %ebp,%ebp
lea    0x100(%rbp),%rax
cmp    $0x2,%rax
jb     14d9 <main+0x349>
lea    0xfe(%rbp),%eax
cmp    0x30(%rsp,%rax,4),%bl
jne    14d1 <main+0x341>
cmp    0x31(%rsp,%rax,4),%r14b
jne    14d1 <main+0x341>
cmp    0x32(%rsp,%rax,4),%r12b
jne    14d1 <main+0x341>
lea    -0x1(%rbp),%rax
cmpb   $0x5f,0x42f(%rsp,%rbp,4)
5f
mov    %rax,%rbp
jne    1490 <main+0x300>
add    $0x101,%eax
mov    %eax,%ebp
jmp    14de <main+0x34e>
add    $0x100,%ebp
jmp    14de <main+0x34e>
mov    $0x1,%ebp
lea    0xc09(%rip),%rdi
call   1040 <puts@plt>
mov    0x18(%rsp),%rax
mov    0x8(%rax),%rsi
lea    0xbb3(%rip),%rdi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xbe8(%rip),%rdi
call   1040 <puts@plt>
cmp    $0x100,%ebp
jge    155b <main+0x3cb>
lea    0xba8(%rip),%rdi
mov    %ebx,%esi
mov    %r14d,%edx
mov    %r12d,%ecx
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xbc1(%rip),%rdi
call   1040 <puts@plt>
test   %ebp,%ebp
jg     1567 <main+0x3d7>
mov    0x10(%rsp),%rdi
call   1050 <fclose@plt>
xor    %ebx,%ebx
mov    %ebx,%eax
add    $0x1a38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xb91(%rip),%rdi
call   1040 <puts@plt>
mov    %ebp,%ebp
lea    0xa30(%rsp),%rbx
lea    0xb5b(%rip),%r14
lea    0xb62(%rip),%r15
lea    0xb55(%rip),%r13
xor    %r12d,%r12d
jmp    15ae <main+0x41e>
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r12
add    $0x10,%rbx
cmp    %r12,%rbp
je     153b <main+0x3ab>
cmpb   $0x5f,0x33(%rsp,%r12,4)
jne    15d0 <main+0x440>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r14,%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1060 <printf@plt>
jmp    15da <main+0x44a>
nop
mov    %r13,%rdi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r15,%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   1060 <printf@plt>
movsbl 0x530(%rsp,%r12,1),%edi
cmp    $0x20,%edi
jne    1610 <main+0x480>
mov    0x630(%rsp,%r12,4),%esi
test   %esi,%esi
js     1597 <main+0x407>
lea    0xae0(%rip),%rdi
jmp    1590 <main+0x400>
nopw   0x0(%rax,%rax,1)
call   1030 <putchar@plt>
movsbl 0x430(%rsp,%r12,1),%esi
cmp    $0x20,%esi
je     1597 <main+0x407>
lea    0xab6(%rip),%rdi
jmp    1590 <main+0x400>

LLVM IR (-O0):
@.str = [21 x i8] c"micdsm (version %s)\0A\00"
@.str.1 = [10 x i8] c"20.8.2005\00"
@.str.2 = [15 x i8] c" Copyright %s\0A\00"
@.str.3 = [57 x i8] c"(c) 2005 Dr.-Ing. Ingo D. Rullhusen <d01c@uni-bremen.de>\00"
@.str.4 = [64 x i8] c" micdsm comes with ABSOLUTELY NO WARRANTY; for details see GNU\0A\00"
@.str.5 = [72 x i8] c" GENERAL PUBLIC LICENSE. This is free software, and you are welcome to\0A\00"
@.str.6 = [75 x i8] c" redistribute it under certain conditions; see GNU GENERAL PUBLIC LICENSE\0A\00"
@.str.7 = [16 x i8] c" for details.\0A\0A\00"
@.str.8 = [19 x i8] c"micdsm <MIC file>\0A\00"
@.str.9 = [2 x i8] c"r\00"
@stderr = global i32 0
@.str.10 = [22 x i8] c"Cannot open file %s!\0A\00"
@.str.11 = [22 x i8] c"MIC file incomplete!\0A\00"
@.str.12 = [24 x i8] c"MIC file inconsistent!\0A\00"
@.str.13 = [3 x i8] c";\0A\00"
@.str.14 = [23 x i8] c"; disassembly of \22%s\22\0A\00"
@.str.15 = [4 x i8] c";\0A\0A\00"
@.str.16 = [15 x i8] c"fill = %c%c%c\0A\00"
@.str.17 = [12 x i8] c"00 = _00\0A\00"
@.str.18 = [2 x i8] c"\0A\00"
@.str.19 = [8 x i8] c"_%.2X: \00"
@.str.20 = [6 x i8] c" \00"
@.str.21 = [3 x i8] c"%s\00"
@.str.22 = [3 x i8] c"%c\00"
@.str.23 = [4 x i8] c",%c\00"
@.str.24 = [6 x i8] c"_%.2X\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca [256 x [4 x i8]]
%9 = alloca [256 x [16 x i8]]
%10 = alloca [256 x i8]
%11 = alloca [256 x i8]
%12 = alloca [256 x i32]
%13 = alloca i32*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%14 = load i32, i32* %4
%15 = icmp ne i32 %14, 2
br i1 %15, label %16, label %24
16: ; preds = %2
%17 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.3, i64 0, i64 0))
%19 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.4, i64 0, i64 0))
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([72 x i8], [72 x i8]* @.str.5, i64 0, i64 0))
%21 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([75 x i8], [75 x i8]* @.str.6, i64 0, i64 0))
%22 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.7, i64 0, i64 0))
%23 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.8, i64 0, i64 0))
store i32 0, i32* %3
br label %298
24: ; preds = %2
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 1
%27 = load i8*, i8** %26
%28 = call i32* @fopen(i8* %27, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
store i32* %28, i32** %13
%29 = load i32*, i32** %13
%30 = icmp ne i32* %29, null
br i1 %30, label %37, label %31
31: ; preds = %24
%32 = load i32, i32* @stderr
%33 = load i8**, i8*** %5
%34 = getelementptr inbounds i8*, i8** %33, i64 1
%35 = load i8*, i8** %34
%36 = call i32 (i32, i8*, ...) @fprintf(i32 %32, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0), i8* %35)
store i32 2, i32* %3
br label %298
37: ; preds = %24
store i32 0, i32* %6
br label %38
38: ; preds = %117, %37
%39 = load i32, i32* %6
%40 = icmp slt i32 %39, 256
br i1 %40, label %41, label %120
41: ; preds = %38
%42 = load i32*, i32** %13
%43 = call i64 @getc(i32* %42)
%44 = trunc i64 %43 to i8
%45 = load i32, i32* %6
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %46
%48 = getelementptr inbounds [4 x i8], [4 x i8]* %47, i64 0, i64 0
store i8 %44, i8* %48
%49 = load i32*, i32** %13
%50 = call i64 @getc(i32* %49)
%51 = trunc i64 %50 to i8
%52 = load i32, i32* %6
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %53
%55 = getelementptr inbounds [4 x i8], [4 x i8]* %54, i64 0, i64 1
store i8 %51, i8* %55
%56 = load i32*, i32** %13
%57 = call i64 @getc(i32* %56)
%58 = trunc i64 %57 to i8
%59 = load i32, i32* %6
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %60
%62 = getelementptr inbounds [4 x i8], [4 x i8]* %61, i64 0, i64 2
store i8 %58, i8* %62
%63 = load i32*, i32** %13
%64 = call i64 @getc(i32* %63)
%65 = trunc i64 %64 to i8
%66 = load i32, i32* %6
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %67
%69 = getelementptr inbounds [4 x i8], [4 x i8]* %68, i64 0, i64 3
store i8 %65, i8* %69
%70 = load i32*, i32** %13
%71 = call i64 @feof(i32* %70)
%72 = icmp ne i64 %71, 0
br i1 %72, label %73, label %76
73: ; preds = %41
%74 = load i32, i32* @stderr
%75 = call i32 (i32, i8*, ...) @fprintf(i32 %74, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.11, i64 0, i64 0))
store i32 5, i32* %3
br label %298
76: ; preds = %41
%77 = load i32, i32* %6
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %78
%80 = getelementptr inbounds [4 x i8], [4 x i8]* %79, i64 0, i64 3
%81 = load i8, i8* %80
%82 = sext i8 %81 to i32
%83 = icmp ne i32 %82, 13
br i1 %83, label %84, label %87
84: ; preds = %76
%85 = load i32, i32* @stderr
%86 = call i32 (i32, i8*, ...) @fprintf(i32 %85, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0))
store i32 5, i32* %3
br label %298
87: ; preds = %76
%88 = load i32, i32* %6
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [256 x [16 x i8]], [256 x [16 x i8]]* %9, i64 0, i64 %89
%91 = getelementptr inbounds [16 x i8], [16 x i8]* %90, i64 0, i64 0
%92 = load i32, i32* %6
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %93
%95 = load i32, i32* %6
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 %96
%98 = load i32, i32* %6
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [256 x i32], [256 x i32]* %12, i64 0, i64 %99
%101 = load i32, i32* %6
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %102
%104 = getelementptr inbounds [4 x i8], [4 x i8]* %103, i64 0, i64 0
%105 = load i8, i8* %104
%106 = load i32, i32* %6
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %107
%109 = getelementptr inbounds [4 x i8], [4 x i8]* %108, i64 0, i64 1
%110 = load i8, i8* %109
%111 = load i32, i32* %6
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %112
%114 = getelementptr inbounds [4 x i8], [4 x i8]* %113, i64 0, i64 2
%115 = load i8, i8* %114
%116 = call i32 @mnemonic(i8* %91, i8* %94, i8* %97, i32* %100, i8 signext %105, i8 signext %110, i8 signext %115)
br label %117
117: ; preds = %87
%118 = load i32, i32* %6
%119 = add nsw i32 %118, 1
store i32 %119, i32* %6
br label %38
120: ; preds = %38
%121 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 0
%122 = getelementptr inbounds [4 x i8], [4 x i8]* %121, i64 0, i64 3
store i8 95, i8* %122
store i32 0, i32* %6
br label %123
123: ; preds = %141, %120
%124 = load i32, i32* %6
%125 = icmp slt i32 %124, 256
br i1 %125, label %126, label %144
126: ; preds = %123
%127 = load i32, i32* %6
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds [256 x i32], [256 x i32]* %12, i64 0, i64 %128
%130 = load i32, i32* %129
%131 = icmp sgt i32 %130, -1
br i1 %131, label %132, label %140
132: ; preds = %126
%133 = load i32, i32* %6
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [256 x i32], [256 x i32]* %12, i64 0, i64 %134
%136 = load i32, i32* %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %137
%139 = getelementptr inbounds [4 x i8], [4 x i8]* %138, i64 0, i64 3
store i8 95, i8* %139
br label %140
140: ; preds = %132, %126
br label %141
141: ; preds = %140
%142 = load i32, i32* %6
%143 = add nsw i32 %142, 1
store i32 %143, i32* %6
br label %123
144: ; preds = %123
store i32 256, i32* %7
br label %145
145: ; preds = %198, %144
%146 = load i32, i32* %7
%147 = icmp sgt i32 %146, 1
br i1 %147, label %148, label %201
148: ; preds = %145
%149 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 255
%150 = getelementptr inbounds [4 x i8], [4 x i8]* %149, i64 0, i64 0
%151 = load i8, i8* %150
%152 = sext i8 %151 to i32
%153 = load i32, i32* %7
%154 = sub nsw i32 %153, 2
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %155
%157 = getelementptr inbounds [4 x i8], [4 x i8]* %156, i64 0, i64 0
%158 = load i8, i8* %157
%159 = sext i8 %158 to i32
%160 = icmp ne i32 %152, %159
br i1 %160, label %196, label %161
161: ; preds = %148
%162 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 255
%163 = getelementptr inbounds [4 x i8], [4 x i8]* %162, i64 0, i64 1
%164 = load i8, i8* %163
%165 = sext i8 %164 to i32
%166 = load i32, i32* %7
%167 = sub nsw i32 %166, 2
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %168
%170 = getelementptr inbounds [4 x i8], [4 x i8]* %169, i64 0, i64 1
%171 = load i8, i8* %170
%172 = sext i8 %171 to i32
%173 = icmp ne i32 %165, %172
br i1 %173, label %196, label %174
174: ; preds = %161
%175 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 255
%176 = getelementptr inbounds [4 x i8], [4 x i8]* %175, i64 0, i64 2
%177 = load i8, i8* %176
%178 = sext i8 %177 to i32
%179 = load i32, i32* %7
%180 = sub nsw i32 %179, 2
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %181
%183 = getelementptr inbounds [4 x i8], [4 x i8]* %182, i64 0, i64 2
%184 = load i8, i8* %183
%185 = sext i8 %184 to i32
%186 = icmp ne i32 %178, %185
br i1 %186, label %196, label %187
187: ; preds = %174
%188 = load i32, i32* %7
%189 = sub nsw i32 %188, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %190
%192 = getelementptr inbounds [4 x i8], [4 x i8]* %191, i64 0, i64 3
%193 = load i8, i8* %192
%194 = sext i8 %193 to i32
%195 = icmp eq i32 %194, 95
br i1 %195, label %196, label %197
196: ; preds = %187, %174, %161, %148
br label %201
197: ; preds = %187
br label %198
198: ; preds = %197
%199 = load i32, i32* %7
%200 = add nsw i32 %199, -1
store i32 %200, i32* %7
br label %145
201: ; preds = %196, %145
%202 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.13, i64 0, i64 0))
%203 = load i8**, i8*** %5
%204 = getelementptr inbounds i8*, i8** %203, i64 1
%205 = load i8*, i8** %204
%206 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.14, i64 0, i64 0), i8* %205)
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.15, i64 0, i64 0))
%208 = load i32, i32* %7
%209 = icmp slt i32 %208, 256
br i1 %209, label %210, label %224
210: ; preds = %201
%211 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 255
%212 = getelementptr inbounds [4 x i8], [4 x i8]* %211, i64 0, i64 0
%213 = load i8, i8* %212
%214 = sext i8 %213 to i32
%215 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 255
%216 = getelementptr inbounds [4 x i8], [4 x i8]* %215, i64 0, i64 1
%217 = load i8, i8* %216
%218 = sext i8 %217 to i32
%219 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 255
%220 = getelementptr inbounds [4 x i8], [4 x i8]* %219, i64 0, i64 2
%221 = load i8, i8* %220
%222 = sext i8 %221 to i32
%223 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.16, i64 0, i64 0), i32 %214, i32 %218, i32 %222)
br label %224
224: ; preds = %210, %201
%225 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.17, i64 0, i64 0))
store i32 0, i32* %6
br label %226
226: ; preds = %292, %224
%227 = load i32, i32* %6
%228 = load i32, i32* %7
%229 = icmp slt i32 %227, %228
br i1 %229, label %230, label %295
230: ; preds = %226
%231 = load i32, i32* %6
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %8, i64 0, i64 %232
%234 = getelementptr inbounds [4 x i8], [4 x i8]* %233, i64 0, i64 3
%235 = load i8, i8* %234
%236 = sext i8 %235 to i32
%237 = icmp eq i32 %236, 95
br i1 %237, label %238, label %242
238: ; preds = %230
%239 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0))
%240 = load i32, i32* %6
%241 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i64 0, i64 0), i32 %240)
br label %244
242: ; preds = %230
%243 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0))
br label %244
244: ; preds = %242, %238
%245 = load i32, i32* %6
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [256 x [16 x i8]], [256 x [16 x i8]]* %9, i64 0, i64 %246
%248 = getelementptr inbounds [16 x i8], [16 x i8]* %247, i64 0, i64 0
%249 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %248)
%250 = load i32, i32* %6
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %251
%253 = load i8, i8* %252
%254 = sext i8 %253 to i32
%255 = icmp ne i32 %254, 32
br i1 %255, label %256, label %277
256: ; preds = %244
%257 = load i32, i32* %6
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %258
%260 = load i8, i8* %259
%261 = sext i8 %260 to i32
%262 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.22, i64 0, i64 0), i32 %261)
%263 = load i32, i32* %6
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 %264
%266 = load i8, i8* %265
%267 = sext i8 %266 to i32
%268 = icmp ne i32 %267, 32
br i1 %268, label %269, label %276
269: ; preds = %256
%270 = load i32, i32* %6
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds [256 x i8], [256 x i8]* %11, i64 0, i64 %271
%273 = load i8, i8* %272
%274 = sext i8 %273 to i32
%275 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.23, i64 0, i64 0), i32 %274)
br label %276
276: ; preds = %269, %256
br label %290
277: ; preds = %244
%278 = load i32, i32* %6
%279 = sext i32 %278 to i64
%280 = getelementptr inbounds [256 x i32], [256 x i32]* %12, i64 0, i64 %279
%281 = load i32, i32* %280
%282 = icmp sgt i32 %281, -1
br i1 %282, label %283, label %289
283: ; preds = %277
%284 = load i32, i32* %6
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds [256 x i32], [256 x i32]* %12, i64 0, i64 %285
%287 = load i32, i32* %286
%288 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.24, i64 0, i64 0), i32 %287)
br label %289
289: ; preds = %283, %277
br label %290
290: ; preds = %289, %276
%291 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.18, i64 0, i64 0))
br label %292
292: ; preds = %290
%293 = load i32, i32* %6
%294 = add nsw i32 %293, 1
store i32 %294, i32* %6
br label %226
295: ; preds = %226
%296 = load i32*, i32** %13
%297 = call i32 @fclose(i32* %296)
store i32 0, i32* %3
br label %298
298: ; preds = %295, %84, %73, %31, %16
%299 = load i32, i32* %3
ret i32 %299
}

LLVM IR (-O2):
@.str = [21 x i8] c"micdsm (version %s)\0A\00"
@.str.1 = [10 x i8] c"20.8.2005\00"
@.str.2 = [15 x i8] c" Copyright %s\0A\00"
@.str.3 = [57 x i8] c"(c) 2005 Dr.-Ing. Ingo D. Rullhusen <d01c@uni-bremen.de>\00"
@.str.9 = [2 x i8] c"r\00"
@stderr = global i32 0
@.str.10 = [22 x i8] c"Cannot open file %s!\0A\00"
@.str.11 = [22 x i8] c"MIC file incomplete!\0A\00"
@.str.12 = [24 x i8] c"MIC file inconsistent!\0A\00"
@.str.14 = [23 x i8] c"; disassembly of \22%s\22\0A\00"
@.str.16 = [15 x i8] c"fill = %c%c%c\0A\00"
@.str.19 = [8 x i8] c"_%.2X: \00"
@.str.20 = [6 x i8] c" \00"
@.str.21 = [3 x i8] c"%s\00"
@.str.23 = [4 x i8] c",%c\00"
@.str.24 = [6 x i8] c"_%.2X\00"
@str = [2 x i8] c";\00"
@str.25 = [3 x i8] c";\0A\00"
@str.26 = [11 x i8] c"00 = _00\00"
@str.27 = [63 x i8] c" micdsm comes with ABSOLUTELY NO WARRANTY; for details see GNU\00"
@str.28 = [71 x i8] c" GENERAL PUBLIC LICENSE. This is free software, and you are welcome to\00"
@str.29 = [74 x i8] c" redistribute it under certain conditions; see GNU GENERAL PUBLIC LICENSE\00"
@str.30 = [15 x i8] c" for details.\0A\00"
@str.31 = [18 x i8] c"micdsm <MIC file>\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [256 x [4 x i8]]
%4 = alloca [256 x [16 x i8]]
%5 = alloca [256 x i8]
%6 = alloca [256 x i8]
%7 = alloca [256 x i32]
%8 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 0, i64 0
%9 = getelementptr inbounds [256 x [16 x i8]], [256 x [16 x i8]]* %4, i64 0, i64 0, i64 0
%10 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 0
%11 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 0
%12 = bitcast [256 x i32]* %7 to i8*
%13 = icmp eq i32 %0, 2
br i1 %13, label %22, label %14
14: ; preds = %2
%15 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([21 x i8], [21 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i64 0, i64 0))
%16 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.3, i64 0, i64 0))
%17 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([63 x i8], [63 x i8]* @str.27, i64 0, i64 0))
%18 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([71 x i8], [71 x i8]* @str.28, i64 0, i64 0))
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([74 x i8], [74 x i8]* @str.29, i64 0, i64 0))
%20 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @str.30, i64 0, i64 0))
%21 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str.31, i64 0, i64 0))
br label %218
22: ; preds = %2
%23 = getelementptr inbounds i8*, i8** %1, i64 1
%24 = load i8*, i8** %23
%25 = tail call i32* @fopen(i8* %24, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.9, i64 0, i64 0))
%26 = icmp eq i32* %25, null
br i1 %26, label %27, label %31
27: ; preds = %22
%28 = load i32, i32* @stderr
%29 = load i8*, i8** %23
%30 = tail call i32 (i32, i8*, ...) @fprintf(i32 %28, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0), i8* %29)
br label %218
31: ; preds = %22, %55
%32 = phi i64 [ %61, %55 ], [ 0, %22 ]
%33 = call i64 @getc(i32* %25)
%34 = trunc i64 %33 to i8
%35 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %32, i64 0
store i8 %34, i8* %35
%36 = call i64 @getc(i32* %25)
%37 = trunc i64 %36 to i8
%38 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %32, i64 1
store i8 %37, i8* %38
%39 = call i64 @getc(i32* %25)
%40 = trunc i64 %39 to i8
%41 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %32, i64 2
store i8 %40, i8* %41
%42 = call i64 @getc(i32* %25)
%43 = trunc i64 %42 to i8
%44 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %32, i64 3
store i8 %43, i8* %44
%45 = call i64 @feof(i32* %25)
%46 = icmp eq i64 %45, 0
br i1 %46, label %50, label %47
47: ; preds = %31
%48 = load i32, i32* @stderr
%49 = call i32 (i32, i8*, ...) @fprintf(i32 %48, i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.11, i64 0, i64 0))
br label %218
50: ; preds = %31
%51 = icmp eq i8 %43, 13
br i1 %51, label %55, label %52
52: ; preds = %50
%53 = load i32, i32* @stderr
%54 = call i32 (i32, i8*, ...) @fprintf(i32 %53, i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.12, i64 0, i64 0))
br label %218
55: ; preds = %50
%56 = getelementptr inbounds [256 x [16 x i8]], [256 x [16 x i8]]* %4, i64 0, i64 %32, i64 0
%57 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %32
%58 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %32
%59 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %32
%60 = call i32 @mnemonic(i8* %56, i8* %57, i8* %58, i32* %59, i8 signext %34, i8 signext %37, i8 signext %40)
%61 = add nuw nsw i64 %32, 1
%62 = icmp eq i64 %61, 256
br i1 %62, label %63, label %31
63: ; preds = %55
%64 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 0, i64 3
store i8 95, i8* %64
br label %65
65: ; preds = %122, %63
%66 = phi i64 [ 0, %63 ], [ %123, %122 ]
%67 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %66
%68 = bitcast i32* %67 to <4 x i32>*
%69 = load <4 x i32>, <4 x i32>* %68
%70 = getelementptr inbounds i32, i32* %67, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
%72 = load <4 x i32>, <4 x i32>* %71
%73 = icmp sgt <4 x i32> %69, <i32 -1, i32 -1, i32 -1, i32 -1>
%74 = icmp sgt <4 x i32> %72, <i32 -1, i32 -1, i32 -1, i32 -1>
%75 = extractelement <4 x i1> %73, i64 0
br i1 %75, label %76, label %80
76: ; preds = %65
%77 = extractelement <4 x i32> %69, i64 0
%78 = zext i32 %77 to i64
%79 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %78, i64 3
store i8 95, i8* %79
br label %80
80: ; preds = %76, %65
%81 = extractelement <4 x i1> %73, i64 1
br i1 %81, label %82, label %86
82: ; preds = %80
%83 = extractelement <4 x i32> %69, i64 1
%84 = zext i32 %83 to i64
%85 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %84, i64 3
store i8 95, i8* %85
br label %86
86: ; preds = %82, %80
%87 = extractelement <4 x i1> %73, i64 2
br i1 %87, label %88, label %92
88: ; preds = %86
%89 = extractelement <4 x i32> %69, i64 2
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %90, i64 3
store i8 95, i8* %91
br label %92
92: ; preds = %88, %86
%93 = extractelement <4 x i1> %73, i64 3
br i1 %93, label %94, label %98
94: ; preds = %92
%95 = extractelement <4 x i32> %69, i64 3
%96 = zext i32 %95 to i64
%97 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %96, i64 3
store i8 95, i8* %97
br label %98
98: ; preds = %94, %92
%99 = extractelement <4 x i1> %74, i64 0
br i1 %99, label %100, label %104
100: ; preds = %98
%101 = extractelement <4 x i32> %72, i64 0
%102 = zext i32 %101 to i64
%103 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %102, i64 3
store i8 95, i8* %103
br label %104
104: ; preds = %100, %98
%105 = extractelement <4 x i1> %74, i64 1
br i1 %105, label %106, label %110
106: ; preds = %104
%107 = extractelement <4 x i32> %72, i64 1
%108 = zext i32 %107 to i64
%109 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %108, i64 3
store i8 95, i8* %109
br label %110
110: ; preds = %106, %104
%111 = extractelement <4 x i1> %74, i64 2
br i1 %111, label %112, label %116
112: ; preds = %110
%113 = extractelement <4 x i32> %72, i64 2
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %114, i64 3
store i8 95, i8* %115
br label %116
116: ; preds = %112, %110
%117 = extractelement <4 x i1> %74, i64 3
br i1 %117, label %118, label %122
118: ; preds = %116
%119 = extractelement <4 x i32> %72, i64 3
%120 = zext i32 %119 to i64
%121 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %120, i64 3
store i8 95, i8* %121
br label %122
122: ; preds = %118, %116
%123 = add nuw i64 %66, 8
%124 = icmp eq i64 %123, 256
br i1 %124, label %125, label %65
125: ; preds = %122
%126 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 255, i64 0
%127 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 255, i64 1
%128 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 255, i64 2
%129 = load i8, i8* %126
%130 = load i8, i8* %127
%131 = load i8, i8* %128
br label %132
132: ; preds = %125, %149
%133 = phi i64 [ 256, %125 ], [ %150, %149 ]
%134 = icmp ugt i64 %133, 1
br i1 %134, label %135, label %162
135: ; preds = %132
%136 = add i64 %133, 4294967294
%137 = and i64 %136, 4294967295
%138 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %137, i64 0
%139 = load i8, i8* %138
%140 = icmp eq i8 %129, %139
br i1 %140, label %141, label %154
141: ; preds = %135
%142 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %137, i64 1
%143 = load i8, i8* %142
%144 = icmp eq i8 %130, %143
br i1 %144, label %145, label %156
145: ; preds = %141
%146 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %137, i64 2
%147 = load i8, i8* %146
%148 = icmp eq i8 %131, %147
br i1 %148, label %149, label %158
149: ; preds = %145
%150 = add nsw i64 %133, -1
%151 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %150, i64 3
%152 = load i8, i8* %151
%153 = icmp eq i8 %152, 95
br i1 %153, label %160, label %132
154: ; preds = %135
%155 = trunc i64 %133 to i32
br label %162
156: ; preds = %141
%157 = trunc i64 %133 to i32
br label %162
158: ; preds = %145
%159 = trunc i64 %133 to i32
br label %162
160: ; preds = %149
%161 = trunc i64 %133 to i32
br label %162
162: ; preds = %132, %160, %158, %156, %154
%163 = phi i32 [ %155, %154 ], [ %157, %156 ], [ %159, %158 ], [ %161, %160 ], [ 1, %132 ]
%164 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([2 x i8], [2 x i8]* @str, i64 0, i64 0))
%165 = load i8*, i8** %23
%166 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @.str.14, i64 0, i64 0), i8* %165)
%167 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @str.25, i64 0, i64 0))
%168 = icmp slt i32 %163, 256
br i1 %168, label %171, label %169
169: ; preds = %162
%170 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.26, i64 0, i64 0))
br label %178
171: ; preds = %162
%172 = sext i8 %129 to i32
%173 = sext i8 %130 to i32
%174 = sext i8 %131 to i32
%175 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str.16, i64 0, i64 0), i32 %172, i32 %173, i32 %174)
%176 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.26, i64 0, i64 0))
%177 = icmp sgt i32 %163, 0
br i1 %177, label %178, label %216
178: ; preds = %169, %171
%179 = zext i32 %163 to i64
br label %180
180: ; preds = %178, %212
%181 = phi i64 [ 0, %178 ], [ %214, %212 ]
%182 = getelementptr inbounds [256 x [4 x i8]], [256 x [4 x i8]]* %3, i64 0, i64 %181, i64 3
%183 = load i8, i8* %182
%184 = icmp eq i8 %183, 95
br i1 %184, label %185, label %189
185: ; preds = %180
%186 = call i32 @putchar(i32 10)
%187 = trunc i64 %181 to i32
%188 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @.str.19, i64 0, i64 0), i32 %187)
br label %191
189: ; preds = %180
%190 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0))
br label %191
191: ; preds = %189, %185
%192 = getelementptr inbounds [256 x [16 x i8]], [256 x [16 x i8]]* %4, i64 0, i64 %181, i64 0
%193 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([3 x i8], [3 x i8]* @.str.21, i64 0, i64 0), i8* %192)
%194 = getelementptr inbounds [256 x i8], [256 x i8]* %5, i64 0, i64 %181
%195 = load i8, i8* %194
%196 = icmp eq i8 %195, 32
br i1 %196, label %206, label %197
197: ; preds = %191
%198 = sext i8 %195 to i32
%199 = call i32 @putchar(i32 %198)
%200 = getelementptr inbounds [256 x i8], [256 x i8]* %6, i64 0, i64 %181
%201 = load i8, i8* %200
%202 = icmp eq i8 %201, 32
br i1 %202, label %212, label %203
203: ; preds = %197
%204 = sext i8 %201 to i32
%205 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.23, i64 0, i64 0), i32 %204)
br label %212
206: ; preds = %191
%207 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %181
%208 = load i32, i32* %207
%209 = icmp sgt i32 %208, -1
br i1 %209, label %210, label %212
210: ; preds = %206
%211 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str.24, i64 0, i64 0), i32 %208)
br label %212
212: ; preds = %206, %210, %197, %203
%213 = call i32 @putchar(i32 10)
%214 = add nuw nsw i64 %181, 1
%215 = icmp eq i64 %214, %179
br i1 %215, label %216, label %180
216: ; preds = %212, %171
%217 = call i32 @fclose(i32* %25)
br label %218
218: ; preds = %216, %52, %47, %27, %14
%219 = phi i32 [ 0, %14 ], [ 5, %47 ], [ 5, %52 ], [ 0, %216 ], [ 2, %27 ]
ret i32 %219
}