int vm_engine(int *ip, void **dataseg) {
  void *func_table[] = {&&set,  &&add,  &&sub,    &&mul,    &&div,      &&mod,
                        &&show, &&jump, &&nextif, &&skipif, &&printstr, &&exit};
  int regs[32] = {
      0,
  };
  goto *func_table[ip[0]];
set:
  if (ip[3] == 0) {
    verboseprintf("[op 0] setting reg %d to val %d\n", ip[1], ip[2]);
    regs[ip[1]] = ip[2];
  } else if (ip[3] == 1) {
    verboseprintf("[op 0] setting reg %d to reg%d(%d)\n", ip[1], ip[2],
                  regs[ip[2]]);
    regs[ip[1]] = regs[ip[2]];
  }
  ip += 4;
  verboseprintf("[op 0] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
add:
  verboseprintf("[op 1] setting reg%d = reg%d + reg%d (%d)\n", ip[1], ip[2],
                ip[3], regs[ip[2]] + regs[ip[3]]);
  regs[ip[1]] = regs[ip[2]] + regs[ip[3]];
  ip += 4;
  verboseprintf("[op 1] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
sub:
  verboseprintf("[op 2] setting reg%d = reg%d - reg%d (%d)\n", ip[1], ip[2],
                ip[3], regs[ip[2]] - regs[ip[3]]);
  regs[ip[1]] = regs[ip[2]] - regs[ip[3]];
  ip += 4;
  verboseprintf("[op 2] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
mul:
  verboseprintf("[op 3] setting reg%d = reg%d * reg%d (%d)\n", ip[1], ip[2],
                ip[3], regs[ip[2]] * regs[ip[3]]);
  regs[ip[1]] = regs[ip[2]] * regs[ip[3]];
  ip += 4;
  verboseprintf("[op 3] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
div:
  verboseprintf("[op 4] setting reg%d = reg%d / reg%d (%d)\n", ip[1], ip[2],
                ip[3], regs[ip[2]] / regs[ip[3]]);
  regs[ip[1]] = regs[ip[2]] / regs[ip[3]];
  ip += 4;
  verboseprintf("[op 4] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
mod:
  verboseprintf("[op 5] setting reg%d = reg%d + reg%d (%d)\n", ip[1], ip[2],
                ip[3], regs[ip[2]] + regs[ip[3]]);
  regs[ip[1]] = regs[ip[2]] % regs[ip[3]];
  ip += 4;
  verboseprintf("[op 5] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
show:
  printf("[op 6] reg %d ==> %d\n", ip[1], regs[ip[1]]);
  ip += 4;
  verboseprintf("[op 6] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
jump:
  verboseprintf("[op 7] jumping %s %d opcodes\n",
                ip[1] > 0 ? "forward" : "back", abs(ip[1]));
  ip += (ip[1] * 4);
  verboseprintf("[op 7] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
nextif:
  verboseprintf("[op 8] executing next instruction (op %d) if reg%d == %d\n",
                ip[4], ip[1], ip[2]);
  if (regs[ip[1]] == ip[2])
    ip += 4;
  else
    ip += 8;
  verboseprintf("[op 8] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
skipif:
  verboseprintf("[op 9] skipping next instruction (op %d) if reg%d == %d\n",
                ip[4], ip[1], ip[2]);
  if (regs[ip[1]] == ip[2])
    ip += 8;
  else
    ip += 4;
  verboseprintf("[op 9] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
printstr:
  verboseprintf("[op 10] printing string, data index %d\n", ip[1]);
  printf("%s\n", dataseg[ip[1]]);
  ip += 4;
  verboseprintf("[op 10] next op is %d\n", ip[0]);
  goto *func_table[ip[0]];
exit:
  verboseprintf("[op 11] exiting with value %d\n", ip[1]);
  return ip[1];
}


x86 assembly (clang, -O0):
<vm_engine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x70(%rbp),%rdi
lea    0x2c52(%rip),%rsi
mov    $0x60,%edx
call   1060 <memcpy@plt>
lea    -0xf0(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1050 <memset@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
cmpl   $0x0,0xc(%rax)
jne    11e8 <vm_engine+0x98>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
lea    0xe3a(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
jmp    1244 <vm_engine+0xf4>
mov    -0x8(%rbp),%rax
cmpl   $0x1,0xc(%rax)
jne    123f <vm_engine+0xef>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%ecx
lea    0xe07(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
jmp    1244 <vm_engine+0xf4>
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xde8(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%r8d
ff
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
add    -0xf0(%rbp,%rax,4),%r8d
ff
lea    0xda3(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
add    -0xf0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xd81(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%r8d
ff
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
sub    -0xf0(%rbp,%rax,4),%r8d
ff
lea    0xd3c(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
sub    -0xf0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xd1a(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%r8d
ff
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
imul   -0xf0(%rbp,%rax,4),%r8d
lea    0xcd4(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%ecx
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
imul   -0xf0(%rbp,%rax,4),%ecx
ff
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xcb1(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0xfc(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%eax
mov    -0x8(%rbp),%rdx
movslq 0xc(%rdx),%rdi
cltd
idivl  -0xf0(%rbp,%rdi,4)
mov    -0xfc(%rbp),%edx
mov    %eax,%r8d
lea    0xc5e(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%eax
mov    -0x8(%rbp),%rcx
movslq 0xc(%rcx),%rcx
cltd
idivl  -0xf0(%rbp,%rcx,4)
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    %ecx,-0xf0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xc39(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%r8d
ff
mov    -0x8(%rbp),%rax
movslq 0xc(%rax),%rax
add    -0xf0(%rbp,%rax,4),%r8d
ff
lea    0xbf4(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x8(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%eax
mov    -0x8(%rbp),%rcx
movslq 0xc(%rcx),%rcx
cltd
idivl  -0xf0(%rbp,%rcx,4)
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    %edx,-0xf0(%rbp,%rax,4)
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xbd1(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%edx
lea    0xbab(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xba1(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
lea    0xbb0(%rip),%rax
lea    0xba1(%rip),%rcx
cmp    $0x0,%edx
cmovg  %rcx,%rax
mov    %rax,-0x108(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
call   1030 <abs@plt>
mov    -0x108(%rbp),%rsi
mov    %eax,%edx
lea    0xb59(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%ecx
shl    $0x2,%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xb54(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
lea    0xb2f(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%eax
mov    -0x8(%rbp),%rcx
cmp    0x8(%rcx),%eax
jne    1712 <vm_engine+0x5c2>
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
jmp    171e <vm_engine+0x5ce>
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xb1c(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%esi
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edx
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
lea    0xaf7(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq 0x4(%rax),%rax
mov    -0xf0(%rbp,%rax,4),%eax
mov    -0x8(%rbp),%rcx
cmp    0x8(%rcx),%eax
jne    179a <vm_engine+0x64a>
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
jmp    17a6 <vm_engine+0x656>
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xae3(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
lea    0xacc(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,8),%rsi
lea    0xad6(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%esi
lea    0xaba(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
movslq (%rax),%rax
mov    -0x70(%rbp,%rax,8),%rax
mov    %rax,-0xf8(%rbp)
jmp    1862 <vm_engine+0x712>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%esi
lea    0xaa4(%rip),%rdi
mov    $0x0,%al
call   1070 <verboseprintf@plt>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
add    $0x110,%rsp
pop    %rbp
ret
mov    -0xf8(%rbp),%rax
jmp    *%rax

x86 assembly (clang, -O2):
<vm_engine>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x80,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,(%rsp)
movslq (%rdi),%rax
lea    0x2c46(%rip),%r15
jmp    *(%r15,%rax,8)
mov    0xc(%rbx),%eax
cmp    $0x1,%eax
je     11a8 <vm_engine+0x78>
test   %eax,%eax
jne    11d7 <vm_engine+0xa7>
lea    0x4(%rbx),%r12
lea    0x8(%rbx),%r13
mov    0x4(%rbx),%esi
mov    0x8(%rbx),%edx
lea    0xe61(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
jmp    11cc <vm_engine+0x9c>
lea    0x4(%rbx),%r12
mov    0x4(%rbx),%esi
movslq 0x8(%rbx),%rdx
mov    (%rsp,%rdx,4),%ecx
lea    0xe64(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x8(%rbx),%rax
lea    (%rsp,%rax,4),%r13
mov    0x0(%r13),%eax
movslq (%r12),%rcx
mov    %eax,(%rsp,%rcx,4)
add    $0x10,%rbx
lea    0xe63(%rip),%rdi
mov    (%rbx),%esi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq (%rbx),%rax
jmp    *(%r15,%rax,8)
mov    0x4(%rbx),%esi
movslq 0x8(%rbx),%rdx
movslq 0xc(%rbx),%rcx
mov    (%rsp,%rcx,4),%r8d
add    (%rsp,%rdx,4),%r8d
lea    0xe4f(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x8(%rbx),%rax
movslq 0xc(%rbx),%rcx
mov    (%rsp,%rcx,4),%ecx
add    (%rsp,%rax,4),%ecx
movslq 0x4(%rbx),%rax
mov    %ecx,(%rsp,%rax,4)
add    $0x10,%rbx
lea    0xe53(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
mov    0x4(%rbx),%esi
movslq 0x8(%rbx),%rdx
movslq 0xc(%rbx),%rcx
mov    (%rsp,%rdx,4),%r8d
sub    (%rsp,%rcx,4),%r8d
lea    0xe4d(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x8(%rbx),%rax
mov    (%rsp,%rax,4),%eax
movslq 0xc(%rbx),%rcx
sub    (%rsp,%rcx,4),%eax
movslq 0x4(%rbx),%rcx
mov    %eax,(%rsp,%rcx,4)
add    $0x10,%rbx
lea    0xe51(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
mov    0x4(%rbx),%esi
movslq 0x8(%rbx),%rdx
movslq 0xc(%rbx),%rcx
mov    (%rsp,%rcx,4),%r8d
imul   (%rsp,%rdx,4),%r8d
lea    0xe47(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x8(%rbx),%rax
movslq 0xc(%rbx),%rcx
mov    (%rsp,%rcx,4),%ecx
imul   (%rsp,%rax,4),%ecx
movslq 0x4(%rbx),%rax
mov    %ecx,(%rsp,%rax,4)
add    $0x10,%rbx
lea    0xe4a(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
mov    0x4(%rbx),%esi
movslq 0x8(%rbx),%r8
movslq 0xc(%rbx),%rcx
mov    (%rsp,%r8,4),%eax
cltd
idivl  (%rsp,%rcx,4)
lea    0xe41(%rip),%rdi
mov    %r8d,%edx
mov    %eax,%r8d
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x8(%rbx),%rax
mov    (%rsp,%rax,4),%eax
movslq 0xc(%rbx),%rcx
cltd
idivl  (%rsp,%rcx,4)
movslq 0x4(%rbx),%rcx
mov    %eax,(%rsp,%rcx,4)
add    $0x10,%rbx
lea    0xe3e(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
mov    0x4(%rbx),%esi
movslq 0x8(%rbx),%rdx
movslq 0xc(%rbx),%rcx
mov    (%rsp,%rcx,4),%r8d
add    (%rsp,%rdx,4),%r8d
lea    0xe35(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x8(%rbx),%rax
mov    (%rsp,%rax,4),%eax
movslq 0xc(%rbx),%rcx
cltd
idivl  (%rsp,%rcx,4)
movslq 0x4(%rbx),%rax
mov    %edx,(%rsp,%rax,4)
add    $0x10,%rbx
lea    0xe38(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
movslq 0x4(%rbx),%rsi
mov    (%rsp,%rsi,4),%edx
lea    0xe3b(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
add    $0x10,%rbx
lea    0xe3f(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
mov    0x4(%rbx),%eax
test   %eax,%eax
lea    0xe62(%rip),%rcx
lea    0xe63(%rip),%rsi
cmovg  %rcx,%rsi
mov    %eax,%edx
neg    %edx
cmovs  %eax,%edx
lea    0xe2b(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x4(%rbx),%rax
shl    $0x4,%rax
add    %rax,%rbx
lea    0xe3d(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
lea    0x10(%rbx),%r12
mov    0x10(%rbx),%esi
mov    0x4(%rbx),%edx
mov    0x8(%rbx),%ecx
lea    0xe3a(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x4(%rbx),%rax
mov    (%rsp,%rax,4),%eax
cmp    0x8(%rbx),%eax
lea    0x20(%rbx),%rbx
cmove  %r12,%rbx
lea    0xe54(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
lea    0x10(%rbx),%r12
mov    0x10(%rbx),%esi
mov    0x4(%rbx),%edx
mov    0x8(%rbx),%ecx
lea    0xe51(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x4(%rbx),%rax
mov    (%rsp,%rax,4),%eax
cmp    0x8(%rbx),%eax
lea    0x20(%rbx),%rax
cmove  %rax,%r12
lea    0xe6a(%rip),%rdi
mov    %r12,%rbx
jmp    11e2 <vm_engine+0xb2>
mov    0x4(%rbx),%esi
lea    0xe6e(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
movslq 0x4(%rbx),%rax
mov    (%r14,%rax,8),%rdi
call   1030 <puts@plt>
add    $0x10,%rbx
lea    0xe77(%rip),%rdi
jmp    11e2 <vm_engine+0xb2>
mov    0x4(%rbx),%esi
lea    0xe7f(%rip),%rdi
xor    %eax,%eax
call   1050 <verboseprintf@plt>
mov    0x4(%rbx),%eax
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@__const.vm_engine.func_table = [12 x i8*] [i8* blockaddress(@vm_engine, %15), i8* blockaddress(@vm_engine, %80), i8* blockaddress(@vm_engine, %134), i8* blockaddress(@vm_engine, %188), i8* blockaddress(@vm_engine, %242), i8* blockaddress(@vm_engine, %296), i8* blockaddress(@vm_engine, %350), i8* blockaddress(@vm_engine, %373), i8* blockaddress(@vm_engine, %402), i8* blockaddress(@vm_engine, %440), i8* blockaddress(@vm_engine, %478), i8* blockaddress(@vm_engine, %503)]
@.str = [33 x i8] c"[op 0] setting reg %d to val %d\0A\00"
@.str.1 = [36 x i8] c"[op 0] setting reg %d to reg%d(%d)\0A\00"
@.str.2 = [22 x i8] c"[op 0] next op is %d\0A\00"
@.str.3 = [43 x i8] c"[op 1] setting reg%d = reg%d + reg%d (%d)\0A\00"
@.str.4 = [22 x i8] c"[op 1] next op is %d\0A\00"
@.str.5 = [43 x i8] c"[op 2] setting reg%d = reg%d - reg%d (%d)\0A\00"
@.str.6 = [22 x i8] c"[op 2] next op is %d\0A\00"
@.str.7 = [43 x i8] c"[op 3] setting reg%d = reg%d * reg%d (%d)\0A\00"
@.str.8 = [22 x i8] c"[op 3] next op is %d\0A\00"
@.str.9 = [43 x i8] c"[op 4] setting reg%d = reg%d / reg%d (%d)\0A\00"
@.str.10 = [22 x i8] c"[op 4] next op is %d\0A\00"
@.str.11 = [43 x i8] c"[op 5] setting reg%d = reg%d + reg%d (%d)\0A\00"
@.str.12 = [22 x i8] c"[op 5] next op is %d\0A\00"
@.str.13 = [22 x i8] c"[op 6] reg %d ==> %d\0A\00"
@.str.14 = [22 x i8] c"[op 6] next op is %d\0A\00"
@.str.15 = [30 x i8] c"[op 7] jumping %s %d opcodes\0A\00"
@.str.16 = [8 x i8] c"forward\00"
@.str.17 = [5 x i8] c"back\00"
@.str.18 = [22 x i8] c"[op 7] next op is %d\0A\00"
@.str.19 = [58 x i8] c"[op 8] executing next instruction (op %d) if reg%d == %d\0A\00"
@.str.20 = [22 x i8] c"[op 8] next op is %d\0A\00"
@.str.21 = [57 x i8] c"[op 9] skipping next instruction (op %d) if reg%d == %d\0A\00"
@.str.22 = [22 x i8] c"[op 9] next op is %d\0A\00"
@.str.23 = [40 x i8] c"[op 10] printing string, data index %d\0A\00"
@.str.24 = [4 x i8] c"%s\0A\00"
@.str.25 = [23 x i8] c"[op 10] next op is %d\0A\00"
@.str.26 = [31 x i8] c"[op 11] exiting with value %d\0A\00"
define i32 @vm_engine(i32* %0, i8** %1) {
%3 = alloca i32*
%4 = alloca i8**
%5 = alloca [12 x i8*]
%6 = alloca [32 x i32]
store i32* %0, i32** %3
store i8** %1, i8*** %4
%7 = bitcast [12 x i8*]* %5 to i8*
%8 = bitcast [32 x i32]* %6 to i8*
%9 = load i32*, i32** %3
%10 = getelementptr inbounds i32, i32* %9, i64 0
%11 = load i32, i32* %10
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %12
%14 = load i8*, i8** %13
br label %511
15: ; preds = %511
%16 = load i32*, i32** %3
%17 = getelementptr inbounds i32, i32* %16, i64 3
%18 = load i32, i32* %17
%19 = icmp eq i32 %18, 0
br i1 %19, label %20, label %36
20: ; preds = %15
%21 = load i32*, i32** %3
%22 = getelementptr inbounds i32, i32* %21, i64 1
%23 = load i32, i32* %22
%24 = load i32*, i32** %3
%25 = getelementptr inbounds i32, i32* %24, i64 2
%26 = load i32, i32* %25
%27 = call i32 (i8*, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0), i32 %23, i32 %26)
%28 = load i32*, i32** %3
%29 = getelementptr inbounds i32, i32* %28, i64 2
%30 = load i32, i32* %29
%31 = load i32*, i32** %3
%32 = getelementptr inbounds i32, i32* %31, i64 1
%33 = load i32, i32* %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %34
store i32 %30, i32* %35
br label %67
36: ; preds = %15
%37 = load i32*, i32** %3
%38 = getelementptr inbounds i32, i32* %37, i64 3
%39 = load i32, i32* %38
%40 = icmp eq i32 %39, 1
br i1 %40, label %41, label %66
41: ; preds = %36
%42 = load i32*, i32** %3
%43 = getelementptr inbounds i32, i32* %42, i64 1
%44 = load i32, i32* %43
%45 = load i32*, i32** %3
%46 = getelementptr inbounds i32, i32* %45, i64 2
%47 = load i32, i32* %46
%48 = load i32*, i32** %3
%49 = getelementptr inbounds i32, i32* %48, i64 2
%50 = load i32, i32* %49
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %51
%53 = load i32, i32* %52
%54 = call i32 (i8*, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), i32 %44, i32 %47, i32 %53)
%55 = load i32*, i32** %3
%56 = getelementptr inbounds i32, i32* %55, i64 2
%57 = load i32, i32* %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %58
%60 = load i32, i32* %59
%61 = load i32*, i32** %3
%62 = getelementptr inbounds i32, i32* %61, i64 1
%63 = load i32, i32* %62
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %64
store i32 %60, i32* %65
br label %66
66: ; preds = %41, %36
br label %67
67: ; preds = %66, %20
%68 = load i32*, i32** %3
%69 = getelementptr inbounds i32, i32* %68, i64 4
store i32* %69, i32** %3
%70 = load i32*, i32** %3
%71 = getelementptr inbounds i32, i32* %70, i64 0
%72 = load i32, i32* %71
%73 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), i32 %72)
%74 = load i32*, i32** %3
%75 = getelementptr inbounds i32, i32* %74, i64 0
%76 = load i32, i32* %75
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %77
%79 = load i8*, i8** %78
br label %511
80: ; preds = %511
%81 = load i32*, i32** %3
%82 = getelementptr inbounds i32, i32* %81, i64 1
%83 = load i32, i32* %82
%84 = load i32*, i32** %3
%85 = getelementptr inbounds i32, i32* %84, i64 2
%86 = load i32, i32* %85
%87 = load i32*, i32** %3
%88 = getelementptr inbounds i32, i32* %87, i64 3
%89 = load i32, i32* %88
%90 = load i32*, i32** %3
%91 = getelementptr inbounds i32, i32* %90, i64 2
%92 = load i32, i32* %91
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %93
%95 = load i32, i32* %94
%96 = load i32*, i32** %3
%97 = getelementptr inbounds i32, i32* %96, i64 3
%98 = load i32, i32* %97
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %99
%101 = load i32, i32* %100
%102 = add nsw i32 %95, %101
%103 = call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), i32 %83, i32 %86, i32 %89, i32 %102)
%104 = load i32*, i32** %3
%105 = getelementptr inbounds i32, i32* %104, i64 2
%106 = load i32, i32* %105
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %107
%109 = load i32, i32* %108
%110 = load i32*, i32** %3
%111 = getelementptr inbounds i32, i32* %110, i64 3
%112 = load i32, i32* %111
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %113
%115 = load i32, i32* %114
%116 = add nsw i32 %109, %115
%117 = load i32*, i32** %3
%118 = getelementptr inbounds i32, i32* %117, i64 1
%119 = load i32, i32* %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %120
store i32 %116, i32* %121
%122 = load i32*, i32** %3
%123 = getelementptr inbounds i32, i32* %122, i64 4
store i32* %123, i32** %3
%124 = load i32*, i32** %3
%125 = getelementptr inbounds i32, i32* %124, i64 0
%126 = load i32, i32* %125
%127 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), i32 %126)
%128 = load i32*, i32** %3
%129 = getelementptr inbounds i32, i32* %128, i64 0
%130 = load i32, i32* %129
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %131
%133 = load i8*, i8** %132
br label %511
134: ; preds = %511
%135 = load i32*, i32** %3
%136 = getelementptr inbounds i32, i32* %135, i64 1
%137 = load i32, i32* %136
%138 = load i32*, i32** %3
%139 = getelementptr inbounds i32, i32* %138, i64 2
%140 = load i32, i32* %139
%141 = load i32*, i32** %3
%142 = getelementptr inbounds i32, i32* %141, i64 3
%143 = load i32, i32* %142
%144 = load i32*, i32** %3
%145 = getelementptr inbounds i32, i32* %144, i64 2
%146 = load i32, i32* %145
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %147
%149 = load i32, i32* %148
%150 = load i32*, i32** %3
%151 = getelementptr inbounds i32, i32* %150, i64 3
%152 = load i32, i32* %151
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %153
%155 = load i32, i32* %154
%156 = sub nsw i32 %149, %155
%157 = call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0), i32 %137, i32 %140, i32 %143, i32 %156)
%158 = load i32*, i32** %3
%159 = getelementptr inbounds i32, i32* %158, i64 2
%160 = load i32, i32* %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %161
%163 = load i32, i32* %162
%164 = load i32*, i32** %3
%165 = getelementptr inbounds i32, i32* %164, i64 3
%166 = load i32, i32* %165
%167 = sext i32 %166 to i64
%168 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %167
%169 = load i32, i32* %168
%170 = sub nsw i32 %163, %169
%171 = load i32*, i32** %3
%172 = getelementptr inbounds i32, i32* %171, i64 1
%173 = load i32, i32* %172
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %174
store i32 %170, i32* %175
%176 = load i32*, i32** %3
%177 = getelementptr inbounds i32, i32* %176, i64 4
store i32* %177, i32** %3
%178 = load i32*, i32** %3
%179 = getelementptr inbounds i32, i32* %178, i64 0
%180 = load i32, i32* %179
%181 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.6, i64 0, i64 0), i32 %180)
%182 = load i32*, i32** %3
%183 = getelementptr inbounds i32, i32* %182, i64 0
%184 = load i32, i32* %183
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %185
%187 = load i8*, i8** %186
br label %511
188: ; preds = %511
%189 = load i32*, i32** %3
%190 = getelementptr inbounds i32, i32* %189, i64 1
%191 = load i32, i32* %190
%192 = load i32*, i32** %3
%193 = getelementptr inbounds i32, i32* %192, i64 2
%194 = load i32, i32* %193
%195 = load i32*, i32** %3
%196 = getelementptr inbounds i32, i32* %195, i64 3
%197 = load i32, i32* %196
%198 = load i32*, i32** %3
%199 = getelementptr inbounds i32, i32* %198, i64 2
%200 = load i32, i32* %199
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %201
%203 = load i32, i32* %202
%204 = load i32*, i32** %3
%205 = getelementptr inbounds i32, i32* %204, i64 3
%206 = load i32, i32* %205
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %207
%209 = load i32, i32* %208
%210 = mul nsw i32 %203, %209
%211 = call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.7, i64 0, i64 0), i32 %191, i32 %194, i32 %197, i32 %210)
%212 = load i32*, i32** %3
%213 = getelementptr inbounds i32, i32* %212, i64 2
%214 = load i32, i32* %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %215
%217 = load i32, i32* %216
%218 = load i32*, i32** %3
%219 = getelementptr inbounds i32, i32* %218, i64 3
%220 = load i32, i32* %219
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %221
%223 = load i32, i32* %222
%224 = mul nsw i32 %217, %223
%225 = load i32*, i32** %3
%226 = getelementptr inbounds i32, i32* %225, i64 1
%227 = load i32, i32* %226
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %228
store i32 %224, i32* %229
%230 = load i32*, i32** %3
%231 = getelementptr inbounds i32, i32* %230, i64 4
store i32* %231, i32** %3
%232 = load i32*, i32** %3
%233 = getelementptr inbounds i32, i32* %232, i64 0
%234 = load i32, i32* %233
%235 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.8, i64 0, i64 0), i32 %234)
%236 = load i32*, i32** %3
%237 = getelementptr inbounds i32, i32* %236, i64 0
%238 = load i32, i32* %237
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %239
%241 = load i8*, i8** %240
br label %511
242: ; preds = %511
%243 = load i32*, i32** %3
%244 = getelementptr inbounds i32, i32* %243, i64 1
%245 = load i32, i32* %244
%246 = load i32*, i32** %3
%247 = getelementptr inbounds i32, i32* %246, i64 2
%248 = load i32, i32* %247
%249 = load i32*, i32** %3
%250 = getelementptr inbounds i32, i32* %249, i64 3
%251 = load i32, i32* %250
%252 = load i32*, i32** %3
%253 = getelementptr inbounds i32, i32* %252, i64 2
%254 = load i32, i32* %253
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %255
%257 = load i32, i32* %256
%258 = load i32*, i32** %3
%259 = getelementptr inbounds i32, i32* %258, i64 3
%260 = load i32, i32* %259
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %261
%263 = load i32, i32* %262
%264 = sdiv i32 %257, %263
%265 = call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.9, i64 0, i64 0), i32 %245, i32 %248, i32 %251, i32 %264)
%266 = load i32*, i32** %3
%267 = getelementptr inbounds i32, i32* %266, i64 2
%268 = load i32, i32* %267
%269 = sext i32 %268 to i64
%270 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %269
%271 = load i32, i32* %270
%272 = load i32*, i32** %3
%273 = getelementptr inbounds i32, i32* %272, i64 3
%274 = load i32, i32* %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %275
%277 = load i32, i32* %276
%278 = sdiv i32 %271, %277
%279 = load i32*, i32** %3
%280 = getelementptr inbounds i32, i32* %279, i64 1
%281 = load i32, i32* %280
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %282
store i32 %278, i32* %283
%284 = load i32*, i32** %3
%285 = getelementptr inbounds i32, i32* %284, i64 4
store i32* %285, i32** %3
%286 = load i32*, i32** %3
%287 = getelementptr inbounds i32, i32* %286, i64 0
%288 = load i32, i32* %287
%289 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0), i32 %288)
%290 = load i32*, i32** %3
%291 = getelementptr inbounds i32, i32* %290, i64 0
%292 = load i32, i32* %291
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %293
%295 = load i8*, i8** %294
br label %511
296: ; preds = %511
%297 = load i32*, i32** %3
%298 = getelementptr inbounds i32, i32* %297, i64 1
%299 = load i32, i32* %298
%300 = load i32*, i32** %3
%301 = getelementptr inbounds i32, i32* %300, i64 2
%302 = load i32, i32* %301
%303 = load i32*, i32** %3
%304 = getelementptr inbounds i32, i32* %303, i64 3
%305 = load i32, i32* %304
%306 = load i32*, i32** %3
%307 = getelementptr inbounds i32, i32* %306, i64 2
%308 = load i32, i32* %307
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %309
%311 = load i32, i32* %310
%312 = load i32*, i32** %3
%313 = getelementptr inbounds i32, i32* %312, i64 3
%314 = load i32, i32* %313
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %315
%317 = load i32, i32* %316
%318 = add nsw i32 %311, %317
%319 = call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.11, i64 0, i64 0), i32 %299, i32 %302, i32 %305, i32 %318)
%320 = load i32*, i32** %3
%321 = getelementptr inbounds i32, i32* %320, i64 2
%322 = load i32, i32* %321
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %323
%325 = load i32, i32* %324
%326 = load i32*, i32** %3
%327 = getelementptr inbounds i32, i32* %326, i64 3
%328 = load i32, i32* %327
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %329
%331 = load i32, i32* %330
%332 = srem i32 %325, %331
%333 = load i32*, i32** %3
%334 = getelementptr inbounds i32, i32* %333, i64 1
%335 = load i32, i32* %334
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %336
store i32 %332, i32* %337
%338 = load i32*, i32** %3
%339 = getelementptr inbounds i32, i32* %338, i64 4
store i32* %339, i32** %3
%340 = load i32*, i32** %3
%341 = getelementptr inbounds i32, i32* %340, i64 0
%342 = load i32, i32* %341
%343 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0), i32 %342)
%344 = load i32*, i32** %3
%345 = getelementptr inbounds i32, i32* %344, i64 0
%346 = load i32, i32* %345
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %347
%349 = load i8*, i8** %348
br label %511
350: ; preds = %511
%351 = load i32*, i32** %3
%352 = getelementptr inbounds i32, i32* %351, i64 1
%353 = load i32, i32* %352
%354 = load i32*, i32** %3
%355 = getelementptr inbounds i32, i32* %354, i64 1
%356 = load i32, i32* %355
%357 = sext i32 %356 to i64
%358 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %357
%359 = load i32, i32* %358
%360 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i64 0, i64 0), i32 %353, i32 %359)
%361 = load i32*, i32** %3
%362 = getelementptr inbounds i32, i32* %361, i64 4
store i32* %362, i32** %3
%363 = load i32*, i32** %3
%364 = getelementptr inbounds i32, i32* %363, i64 0
%365 = load i32, i32* %364
%366 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), i32 %365)
%367 = load i32*, i32** %3
%368 = getelementptr inbounds i32, i32* %367, i64 0
%369 = load i32, i32* %368
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %370
%372 = load i8*, i8** %371
br label %511
373: ; preds = %511
%374 = load i32*, i32** %3
%375 = getelementptr inbounds i32, i32* %374, i64 1
%376 = load i32, i32* %375
%377 = icmp sgt i32 %376, 0
%378 = zext i1 %377 to i64
%379 = select i1 %377, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0)
%380 = load i32*, i32** %3
%381 = getelementptr inbounds i32, i32* %380, i64 1
%382 = load i32, i32* %381
%383 = call i32 @abs(i32 %382)
%384 = call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.15, i64 0, i64 0), i8* %379, i32 %383)
%385 = load i32*, i32** %3
%386 = getelementptr inbounds i32, i32* %385, i64 1
%387 = load i32, i32* %386
%388 = mul nsw i32 %387, 4
%389 = load i32*, i32** %3
%390 = sext i32 %388 to i64
%391 = getelementptr inbounds i32, i32* %389, i64 %390
store i32* %391, i32** %3
%392 = load i32*, i32** %3
%393 = getelementptr inbounds i32, i32* %392, i64 0
%394 = load i32, i32* %393
%395 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.18, i64 0, i64 0), i32 %394)
%396 = load i32*, i32** %3
%397 = getelementptr inbounds i32, i32* %396, i64 0
%398 = load i32, i32* %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %399
%401 = load i8*, i8** %400
br label %511
402: ; preds = %511
%403 = load i32*, i32** %3
%404 = getelementptr inbounds i32, i32* %403, i64 4
%405 = load i32, i32* %404
%406 = load i32*, i32** %3
%407 = getelementptr inbounds i32, i32* %406, i64 1
%408 = load i32, i32* %407
%409 = load i32*, i32** %3
%410 = getelementptr inbounds i32, i32* %409, i64 2
%411 = load i32, i32* %410
%412 = call i32 (i8*, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.19, i64 0, i64 0), i32 %405, i32 %408, i32 %411)
%413 = load i32*, i32** %3
%414 = getelementptr inbounds i32, i32* %413, i64 1
%415 = load i32, i32* %414
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %416
%418 = load i32, i32* %417
%419 = load i32*, i32** %3
%420 = getelementptr inbounds i32, i32* %419, i64 2
%421 = load i32, i32* %420
%422 = icmp eq i32 %418, %421
br i1 %422, label %423, label %426
423: ; preds = %402
%424 = load i32*, i32** %3
%425 = getelementptr inbounds i32, i32* %424, i64 4
store i32* %425, i32** %3
br label %429
426: ; preds = %402
%427 = load i32*, i32** %3
%428 = getelementptr inbounds i32, i32* %427, i64 8
store i32* %428, i32** %3
br label %429
429: ; preds = %426, %423
%430 = load i32*, i32** %3
%431 = getelementptr inbounds i32, i32* %430, i64 0
%432 = load i32, i32* %431
%433 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.20, i64 0, i64 0), i32 %432)
%434 = load i32*, i32** %3
%435 = getelementptr inbounds i32, i32* %434, i64 0
%436 = load i32, i32* %435
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %437
%439 = load i8*, i8** %438
br label %511
440: ; preds = %511
%441 = load i32*, i32** %3
%442 = getelementptr inbounds i32, i32* %441, i64 4
%443 = load i32, i32* %442
%444 = load i32*, i32** %3
%445 = getelementptr inbounds i32, i32* %444, i64 1
%446 = load i32, i32* %445
%447 = load i32*, i32** %3
%448 = getelementptr inbounds i32, i32* %447, i64 2
%449 = load i32, i32* %448
%450 = call i32 (i8*, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.21, i64 0, i64 0), i32 %443, i32 %446, i32 %449)
%451 = load i32*, i32** %3
%452 = getelementptr inbounds i32, i32* %451, i64 1
%453 = load i32, i32* %452
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %454
%456 = load i32, i32* %455
%457 = load i32*, i32** %3
%458 = getelementptr inbounds i32, i32* %457, i64 2
%459 = load i32, i32* %458
%460 = icmp eq i32 %456, %459
br i1 %460, label %461, label %464
461: ; preds = %440
%462 = load i32*, i32** %3
%463 = getelementptr inbounds i32, i32* %462, i64 8
store i32* %463, i32** %3
br label %467
464: ; preds = %440
%465 = load i32*, i32** %3
%466 = getelementptr inbounds i32, i32* %465, i64 4
store i32* %466, i32** %3
br label %467
467: ; preds = %464, %461
%468 = load i32*, i32** %3
%469 = getelementptr inbounds i32, i32* %468, i64 0
%470 = load i32, i32* %469
%471 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.22, i64 0, i64 0), i32 %470)
%472 = load i32*, i32** %3
%473 = getelementptr inbounds i32, i32* %472, i64 0
%474 = load i32, i32* %473
%475 = sext i32 %474 to i64
%476 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %475
%477 = load i8*, i8** %476
br label %511
478: ; preds = %511
%479 = load i32*, i32** %3
%480 = getelementptr inbounds i32, i32* %479, i64 1
%481 = load i32, i32* %480
%482 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.23, i64 0, i64 0), i32 %481)
%483 = load i8**, i8*** %4
%484 = load i32*, i32** %3
%485 = getelementptr inbounds i32, i32* %484, i64 1
%486 = load i32, i32* %485
%487 = sext i32 %486 to i64
%488 = getelementptr inbounds i8*, i8** %483, i64 %487
%489 = load i8*, i8** %488
%490 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.24, i64 0, i64 0), i8* %489)
%491 = load i32*, i32** %3
%492 = getelementptr inbounds i32, i32* %491, i64 4
store i32* %492, i32** %3
%493 = load i32*, i32** %3
%494 = getelementptr inbounds i32, i32* %493, i64 0
%495 = load i32, i32* %494
%496 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i64 0, i64 0), i32 %495)
%497 = load i32*, i32** %3
%498 = getelementptr inbounds i32, i32* %497, i64 0
%499 = load i32, i32* %498
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds [12 x i8*], [12 x i8*]* %5, i64 0, i64 %500
%502 = load i8*, i8** %501
br label %511
503: ; preds = %511
%504 = load i32*, i32** %3
%505 = getelementptr inbounds i32, i32* %504, i64 1
%506 = load i32, i32* %505
%507 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.26, i64 0, i64 0), i32 %506)
%508 = load i32*, i32** %3
%509 = getelementptr inbounds i32, i32* %508, i64 1
%510 = load i32, i32* %509
ret i32 %510
511: ; preds = %478, %467, %429, %373, %350, %296, %242, %188, %134, %80, %67, %2
%512 = phi i8* [ %14, %2 ], [ %79, %67 ], [ %133, %80 ], [ %187, %134 ], [ %241, %188 ], [ %295, %242 ], [ %349, %296 ], [ %372, %350 ], [ %401, %373 ], [ %439, %429 ], [ %477, %467 ], [ %502, %478 ]
indirectbr i8* %512, [label %15, label %80, label %134, label %188, label %242, label %296, label %350, label %373, label %402, label %440, label %478, label %503]
}

LLVM IR (-O2):
@__const.vm_engine.func_table = [12 x i8*] [i8* blockaddress(@vm_engine, %5), i8* blockaddress(@vm_engine, %40), i8* blockaddress(@vm_engine, %68), i8* blockaddress(@vm_engine, %96), i8* blockaddress(@vm_engine, %124), i8* blockaddress(@vm_engine, %152), i8* blockaddress(@vm_engine, %180), i8* blockaddress(@vm_engine, %188), i8* blockaddress(@vm_engine, %199), i8* blockaddress(@vm_engine, %215), i8* blockaddress(@vm_engine, %231), i8* blockaddress(@vm_engine, %241)]
@.str = [33 x i8] c"[op 0] setting reg %d to val %d\0A\00"
@.str.1 = [36 x i8] c"[op 0] setting reg %d to reg%d(%d)\0A\00"
@.str.2 = [22 x i8] c"[op 0] next op is %d\0A\00"
@.str.3 = [43 x i8] c"[op 1] setting reg%d = reg%d + reg%d (%d)\0A\00"
@.str.4 = [22 x i8] c"[op 1] next op is %d\0A\00"
@.str.5 = [43 x i8] c"[op 2] setting reg%d = reg%d - reg%d (%d)\0A\00"
@.str.6 = [22 x i8] c"[op 2] next op is %d\0A\00"
@.str.7 = [43 x i8] c"[op 3] setting reg%d = reg%d * reg%d (%d)\0A\00"
@.str.8 = [22 x i8] c"[op 3] next op is %d\0A\00"
@.str.9 = [43 x i8] c"[op 4] setting reg%d = reg%d / reg%d (%d)\0A\00"
@.str.10 = [22 x i8] c"[op 4] next op is %d\0A\00"
@.str.11 = [43 x i8] c"[op 5] setting reg%d = reg%d + reg%d (%d)\0A\00"
@.str.12 = [22 x i8] c"[op 5] next op is %d\0A\00"
@.str.13 = [22 x i8] c"[op 6] reg %d ==> %d\0A\00"
@.str.14 = [22 x i8] c"[op 6] next op is %d\0A\00"
@.str.15 = [30 x i8] c"[op 7] jumping %s %d opcodes\0A\00"
@.str.16 = [8 x i8] c"forward\00"
@.str.17 = [5 x i8] c"back\00"
@.str.18 = [22 x i8] c"[op 7] next op is %d\0A\00"
@.str.19 = [58 x i8] c"[op 8] executing next instruction (op %d) if reg%d == %d\0A\00"
@.str.20 = [22 x i8] c"[op 8] next op is %d\0A\00"
@.str.21 = [57 x i8] c"[op 9] skipping next instruction (op %d) if reg%d == %d\0A\00"
@.str.22 = [22 x i8] c"[op 9] next op is %d\0A\00"
@.str.23 = [40 x i8] c"[op 10] printing string, data index %d\0A\00"
@.str.25 = [23 x i8] c"[op 10] next op is %d\0A\00"
@.str.26 = [31 x i8] c"[op 11] exiting with value %d\0A\00"
define i32 @vm_engine(i32* %0, i8** nocapture %1) {
%3 = alloca [32 x i32]
%4 = bitcast [32 x i32]* %3 to i8*
br label %246
5: ; preds = %246
%6 = getelementptr inbounds i32, i32* %247, i64 3
%7 = load i32, i32* %6
switch i32 %7, label %33 [
i32 0, label %8
i32 1, label %14
]
8: ; preds = %5
%9 = getelementptr inbounds i32, i32* %247, i64 1
%10 = load i32, i32* %9
%11 = getelementptr inbounds i32, i32* %247, i64 2
%12 = load i32, i32* %11
%13 = tail call i32 (i8*, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, ...)*)(i8* getelementptr inbounds ([33 x i8], [33 x i8]* @.str, i64 0, i64 0), i32 %10, i32 %12)
br label %26
14: ; preds = %5
%15 = getelementptr inbounds i32, i32* %247, i64 1
%16 = load i32, i32* %15
%17 = getelementptr inbounds i32, i32* %247, i64 2
%18 = load i32, i32* %17
%19 = sext i32 %18 to i64
%20 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %19
%21 = load i32, i32* %20
%22 = tail call i32 (i8*, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0), i32 %16, i32 %18, i32 %21)
%23 = load i32, i32* %17
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %24
br label %26
26: ; preds = %8, %14
%27 = phi i32* [ %25, %14 ], [ %11, %8 ]
%28 = phi i32* [ %15, %14 ], [ %9, %8 ]
%29 = load i32, i32* %27
%30 = load i32, i32* %28
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %31
store i32 %29, i32* %32
br label %33
33: ; preds = %26, %5
%34 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
35: ; preds = %33, %40, %68, %96, %124, %152, %180, %188, %199, %215, %231
%36 = phi i32* [ %34, %33 ], [ %67, %40 ], [ %95, %68 ], [ %123, %96 ], [ %151, %124 ], [ %179, %152 ], [ %187, %180 ], [ %198, %188 ], [ %214, %199 ], [ %230, %215 ], [ %240, %231 ]
%37 = phi i8* [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.2, i64 0, i64 0), %33 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.4, i64 0, i64 0), %40 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.6, i64 0, i64 0), %68 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.8, i64 0, i64 0), %96 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.10, i64 0, i64 0), %124 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.12, i64 0, i64 0), %152 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.14, i64 0, i64 0), %180 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.18, i64 0, i64 0), %188 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.20, i64 0, i64 0), %199 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.22, i64 0, i64 0), %215 ], [ getelementptr inbounds ([23 x i8], [23 x i8]* @.str.25, i64 0, i64 0), %231 ]
%38 = load i32, i32* %36
%39 = tail call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* %37, i32 %38)
br label %246
40: ; preds = %246
%41 = getelementptr inbounds i32, i32* %247, i64 1
%42 = load i32, i32* %41
%43 = getelementptr inbounds i32, i32* %247, i64 2
%44 = load i32, i32* %43
%45 = getelementptr inbounds i32, i32* %247, i64 3
%46 = load i32, i32* %45
%47 = sext i32 %44 to i64
%48 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %47
%49 = load i32, i32* %48
%50 = sext i32 %46 to i64
%51 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %50
%52 = load i32, i32* %51
%53 = add nsw i32 %52, %49
%54 = tail call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.3, i64 0, i64 0), i32 %42, i32 %44, i32 %46, i32 %53)
%55 = load i32, i32* %43
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %56
%58 = load i32, i32* %57
%59 = load i32, i32* %45
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %60
%62 = load i32, i32* %61
%63 = add nsw i32 %62, %58
%64 = load i32, i32* %41
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %65
store i32 %63, i32* %66
%67 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
68: ; preds = %246
%69 = getelementptr inbounds i32, i32* %247, i64 1
%70 = load i32, i32* %69
%71 = getelementptr inbounds i32, i32* %247, i64 2
%72 = load i32, i32* %71
%73 = getelementptr inbounds i32, i32* %247, i64 3
%74 = load i32, i32* %73
%75 = sext i32 %72 to i64
%76 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %75
%77 = load i32, i32* %76
%78 = sext i32 %74 to i64
%79 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = sub nsw i32 %77, %80
%82 = tail call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.5, i64 0, i64 0), i32 %70, i32 %72, i32 %74, i32 %81)
%83 = load i32, i32* %71
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %84
%86 = load i32, i32* %85
%87 = load i32, i32* %73
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %88
%90 = load i32, i32* %89
%91 = sub nsw i32 %86, %90
%92 = load i32, i32* %69
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %93
store i32 %91, i32* %94
%95 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
96: ; preds = %246
%97 = getelementptr inbounds i32, i32* %247, i64 1
%98 = load i32, i32* %97
%99 = getelementptr inbounds i32, i32* %247, i64 2
%100 = load i32, i32* %99
%101 = getelementptr inbounds i32, i32* %247, i64 3
%102 = load i32, i32* %101
%103 = sext i32 %100 to i64
%104 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %103
%105 = load i32, i32* %104
%106 = sext i32 %102 to i64
%107 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %106
%108 = load i32, i32* %107
%109 = mul nsw i32 %108, %105
%110 = tail call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.7, i64 0, i64 0), i32 %98, i32 %100, i32 %102, i32 %109)
%111 = load i32, i32* %99
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %112
%114 = load i32, i32* %113
%115 = load i32, i32* %101
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %116
%118 = load i32, i32* %117
%119 = mul nsw i32 %118, %114
%120 = load i32, i32* %97
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %121
store i32 %119, i32* %122
%123 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
124: ; preds = %246
%125 = getelementptr inbounds i32, i32* %247, i64 1
%126 = load i32, i32* %125
%127 = getelementptr inbounds i32, i32* %247, i64 2
%128 = load i32, i32* %127
%129 = getelementptr inbounds i32, i32* %247, i64 3
%130 = load i32, i32* %129
%131 = sext i32 %128 to i64
%132 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %131
%133 = load i32, i32* %132
%134 = sext i32 %130 to i64
%135 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %134
%136 = load i32, i32* %135
%137 = sdiv i32 %133, %136
%138 = tail call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.9, i64 0, i64 0), i32 %126, i32 %128, i32 %130, i32 %137)
%139 = load i32, i32* %127
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %140
%142 = load i32, i32* %141
%143 = load i32, i32* %129
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %144
%146 = load i32, i32* %145
%147 = sdiv i32 %142, %146
%148 = load i32, i32* %125
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %149
store i32 %147, i32* %150
%151 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
152: ; preds = %246
%153 = getelementptr inbounds i32, i32* %247, i64 1
%154 = load i32, i32* %153
%155 = getelementptr inbounds i32, i32* %247, i64 2
%156 = load i32, i32* %155
%157 = getelementptr inbounds i32, i32* %247, i64 3
%158 = load i32, i32* %157
%159 = sext i32 %156 to i64
%160 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %159
%161 = load i32, i32* %160
%162 = sext i32 %158 to i64
%163 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %162
%164 = load i32, i32* %163
%165 = add nsw i32 %164, %161
%166 = tail call i32 (i8*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.11, i64 0, i64 0), i32 %154, i32 %156, i32 %158, i32 %165)
%167 = load i32, i32* %155
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %168
%170 = load i32, i32* %169
%171 = load i32, i32* %157
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %172
%174 = load i32, i32* %173
%175 = srem i32 %170, %174
%176 = load i32, i32* %153
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %177
store i32 %175, i32* %178
%179 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
180: ; preds = %246
%181 = getelementptr inbounds i32, i32* %247, i64 1
%182 = load i32, i32* %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %183
%185 = load i32, i32* %184
%186 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @.str.13, i64 0, i64 0), i32 %182, i32 %185)
%187 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
188: ; preds = %246
%189 = getelementptr inbounds i32, i32* %247, i64 1
%190 = load i32, i32* %189
%191 = icmp sgt i32 %190, 0
%192 = select i1 %191, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0)
%193 = tail call i32 @llvm.abs.i32(i32 %190, i1 true)
%194 = tail call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i8*, i32, ...)*)(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.15, i64 0, i64 0), i8* %192, i32 %193)
%195 = load i32, i32* %189
%196 = shl nsw i32 %195, 2
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %247, i64 %197
br label %35
199: ; preds = %246
%200 = getelementptr inbounds i32, i32* %247, i64 4
%201 = load i32, i32* %200
%202 = getelementptr inbounds i32, i32* %247, i64 1
%203 = load i32, i32* %202
%204 = getelementptr inbounds i32, i32* %247, i64 2
%205 = load i32, i32* %204
%206 = tail call i32 (i8*, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([58 x i8], [58 x i8]* @.str.19, i64 0, i64 0), i32 %201, i32 %203, i32 %205)
%207 = load i32, i32* %202
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %208
%210 = load i32, i32* %209
%211 = load i32, i32* %204
%212 = icmp eq i32 %210, %211
%213 = getelementptr inbounds i32, i32* %247, i64 8
%214 = select i1 %212, i32* %200, i32* %213
br label %35
215: ; preds = %246
%216 = getelementptr inbounds i32, i32* %247, i64 4
%217 = load i32, i32* %216
%218 = getelementptr inbounds i32, i32* %247, i64 1
%219 = load i32, i32* %218
%220 = getelementptr inbounds i32, i32* %247, i64 2
%221 = load i32, i32* %220
%222 = tail call i32 (i8*, i32, i32, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, i32, i32, ...)*)(i8* getelementptr inbounds ([57 x i8], [57 x i8]* @.str.21, i64 0, i64 0), i32 %217, i32 %219, i32 %221)
%223 = load i32, i32* %218
%224 = sext i32 %223 to i64
%225 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %224
%226 = load i32, i32* %225
%227 = load i32, i32* %220
%228 = icmp eq i32 %226, %227
%229 = getelementptr inbounds i32, i32* %247, i64 8
%230 = select i1 %228, i32* %229, i32* %216
br label %35
231: ; preds = %246
%232 = getelementptr inbounds i32, i32* %247, i64 1
%233 = load i32, i32* %232
%234 = tail call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.23, i64 0, i64 0), i32 %233)
%235 = load i32, i32* %232
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds i8*, i8** %1, i64 %236
%238 = load i8*, i8** %237
%239 = tail call i32 @puts(i8* dereferenceable(1) %238)
%240 = getelementptr inbounds i32, i32* %247, i64 4
br label %35
241: ; preds = %246
%242 = getelementptr inbounds i32, i32* %247, i64 1
%243 = load i32, i32* %242
%244 = tail call i32 (i8*, i32, ...) bitcast (i32 (...)* @verboseprintf to i32 (i8*, i32, ...)*)(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.26, i64 0, i64 0), i32 %243)
%245 = load i32, i32* %242
ret i32 %245
246: ; preds = %35, %2
%247 = phi i32* [ %36, %35 ], [ %0, %2 ]
%248 = load i32, i32* %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds [12 x i8*], [12 x i8*]* @__const.vm_engine.func_table, i64 0, i64 %249
%251 = load i8*, i8** %250
indirectbr i8* %251, [label %5, label %40, label %68, label %96, label %124, label %152, label %180, label %188, label %199, label %215, label %231, label %241]
}