LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_subb_imm8_r2_to_r2
void vm_insn_subb_imm8_r2_to_r2(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_SUBB_IMM8_R2_TO_R2);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r2->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r2->val)
                  : vm->regs->gp->r2->val;

  short res = op1 - op2;

  vm->regs->gp->r2->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r2->val =
      !vm->regs->gp->r2->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x76, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x661f
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x662e
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x6673
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x6688
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
subl %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x66e3
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x66fa
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_mulb_imm8_r2_to_r1
void vm_insn_mulb_imm8_r2_to_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_MULB_IMM8_R2_TO_R1);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r2->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r2->val)
                  : vm->regs->gp->r2->val;

  short res = op1 * op2;

  vm->regs->gp->r1->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r1->val =
      !vm->regs->gp->r1->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x79, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x6a3f
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x6a4e
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x6a93
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x6aa8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
imull %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x6b04
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6b1b
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_mulb_imm8_r2_to_r2
void vm_insn_mulb_imm8_r2_to_r2(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_MULB_IMM8_R2_TO_R2);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r2->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r2->val)
                  : vm->regs->gp->r2->val;

  short res = op1 * op2;

  vm->regs->gp->r2->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r2->val =
      !vm->regs->gp->r2->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x7a, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x6b9f
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x6bae
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x6bf3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x6c08
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
imull %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x6c64
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6c7b
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_mulb_imm8_r2_to_r3
void vm_insn_mulb_imm8_r2_to_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_MULB_IMM8_R2_TO_R3);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r2->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r2->val)
                  : vm->regs->gp->r2->val;

  short res = op1 * op2;

  vm->regs->gp->r3->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r3->val =
      !vm->regs->gp->r3->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x7b, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x6cff
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x6d0e
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x6d53
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x6d68
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
imull %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x6dc4
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6ddb
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r2_to_r0
void vm_insn_divb_imm8_r2_to_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R2_TO_R0);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r2->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r2->val)
                  : vm->regs->gp->r2->val;

  if (!op2) {
    fprintf(stderr, "Division by zero.\n");
    return;
  }

  short res = op1 / op2;

  vm->regs->gp->r0->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r0->val =
      !vm->regs->gp->r0->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x7c, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x6e5f
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x6e6e
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x6eb3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x6ec8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
cmpw $0x0, -0xc(%rbp)
jne 0x6ef3
movq 0x611b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x311d(%rip), %rsi      # 0xa004
movb $0x0, %al
callq 0x10b0
jmp 0x6f74
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
cltd
idivl %ecx
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x6f46
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6f5d
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r2_to_r3
void vm_insn_divb_imm8_r2_to_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R2_TO_R3);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r2->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r2->val)
                  : vm->regs->gp->r2->val;

  if (!op2) {
    fprintf(stderr, "Division by zero.\n");
    return;
  }

  short res = op1 / op2;

  vm->regs->gp->r3->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r3->val =
      !vm->regs->gp->r3->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x7f, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x72df
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x72ee
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x7333
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x7348
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
cmpw $0x0, -0xc(%rbp)
jne 0x7373
movq 0x5c9b(%rip), %rax      # 0xcff8
movq (%rax), %rdi
leaq 0x2c9d(%rip), %rsi      # 0xa004
movb $0x0, %al
callq 0x10b0
jmp 0x73f7
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
cltd
idivl %ecx
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x73c8
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x73df
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_addb_imm8_r3_to_r1
void vm_insn_addb_imm8_r3_to_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_ADDB_IMM8_R3_TO_R1);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r3->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r3->val)
                  : vm->regs->gp->r3->val;

  short res = op1 + op2;

  vm->regs->gp->r1->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r1->val =
      !vm->regs->gp->r1->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x81, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x75bf
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x75ce
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x7613
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x7628
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7683
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x769a
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_addb_imm8_r3_to_r2
void vm_insn_addb_imm8_r3_to_r2(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_ADDB_IMM8_R3_TO_R2);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r3->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r3->val)
                  : vm->regs->gp->r3->val;

  short res = op1 + op2;

  vm->regs->gp->r2->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r2->val =
      !vm->regs->gp->r2->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x82, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x771f
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x772e
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x7773
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x7788
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x77e3
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x77fa
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_addb_imm8_r3_to_r3
void vm_insn_addb_imm8_r3_to_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_ADDB_IMM8_R3_TO_R3);

  short op1 = vm_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  short op2 = vm->regs->gp->r3->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r3->val)
                  : vm->regs->gp->r3->val;

  short res = op1 + op2;

  vm->regs->gp->r3->is_negative = ((short)res < 0) ? 1 : 0;
  vm->regs->gp->r3->val =
      !vm->regs->gp->r3->is_negative
          ? VM_ALIGN_TO_BYTE((unsigned short)res)
          : 0xff - (VM_ALIGN_TO_BYTE((unsigned short)res) - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x83, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
cmpl $0xff, %eax
jne 0x787f
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
jmp 0x788e
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
je 0x78d3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x18(%rbp)
jmp 0x78e8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movw %ax, -0xc(%rbp)
movswl -0xa(%rbp), %eax
movswl -0xc(%rbp), %ecx
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movswl -0xe(%rbp), %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0x0, %edx
cmovll %eax, %ecx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7943
movzwl -0xe(%rbp), %eax
andl $0xff, %eax
movl %eax, -0x1c(%rbp)
jmp 0x795a
movzwl -0xe(%rbp), %ecx
andl $0xff, %ecx
subl $0x1, %ecx
movl $0xff, %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movw %cx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_print_imm8
void vm_insn_print_imm8(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_PRINT_IMM8);

  vm_value_t *val = vm_value_create();
  val->is_negative = vm_insn_read_byte(vm) == 0xff ? 1 : 0;
  val->val = VM_ALIGN_TO_BYTE(vm_insn_read_byte(vm));

  printf("%d\n", !val->is_negative ? val->val : VM_NEGATE_BYTE(val->val));
  vm_value_destroy(val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x20, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x7f90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %edx
xorl %ecx, %ecx
movl $0x1, %eax
cmpl $0xff, %edx
cmovel %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
callq 0x1290
movzwl %ax, %eax
andl $0xff, %eax
movw %ax, %cx
movq -0x10(%rbp), %rax
movw %cx, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7a06
movq -0x10(%rbp), %rax
movzwl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x7a22
movq -0x10(%rbp), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
leaq 0x25eb(%rip), %rdi      # 0xa017
movb $0x0, %al
callq 0x1050
movq -0x10(%rbp), %rdi
callq 0x7ff0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_print_r0
void vm_insn_print_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_PRINT_R0);

  printf("%d\n", !vm->regs->gp->r0->is_negative
                     ? vm->regs->gp->r0->val
                     : (vm->regs->gp->r0->val <= 0xff)
                           ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                           : VM_NEGATE_WORD(vm->regs->gp->r0->val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x21, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7aa3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movzwl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x7b0f
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movzwl (%rax), %eax
cmpl $0xff, %eax
jg 0x7ae3
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x10(%rbp)
jmp 0x7b09
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movzwl (%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movl $0xffff, %eax           # imm = 0xFFFF
subl %ecx, %eax
subl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x24fe(%rip), %rdi      # 0xa017
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_print_r1
void vm_insn_print_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_PRINT_R1);

  printf("%d\n", !vm->regs->gp->r1->is_negative
                     ? vm->regs->gp->r1->val
                     : (vm->regs->gp->r1->val <= 0xff)
                           ? VM_NEGATE_BYTE(vm->regs->gp->r1->val)
                           : VM_NEGATE_WORD(vm->regs->gp->r1->val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x22, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7b85
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x7bf4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movzwl (%rax), %eax
cmpl $0xff, %eax
jg 0x7bc7
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x10(%rbp)
jmp 0x7bee
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movzwl (%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movl $0xffff, %eax           # imm = 0xFFFF
subl %ecx, %eax
subl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x2419(%rip), %rdi      # 0xa017
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_print_r2
void vm_insn_print_r2(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_PRINT_R2);

  printf("%d\n", !vm->regs->gp->r2->is_negative
                     ? vm->regs->gp->r2->val
                     : (vm->regs->gp->r2->val <= 0xff)
                           ? VM_NEGATE_BYTE(vm->regs->gp->r2->val)
                           : VM_NEGATE_WORD(vm->regs->gp->r2->val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x23, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7c65
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x7cd4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %eax
cmpl $0xff, %eax
jg 0x7ca7
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x10(%rbp)
jmp 0x7cce
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movl $0xffff, %eax           # imm = 0xFFFF
subl %ecx, %eax
subl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x2339(%rip), %rdi      # 0xa017
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_print_r3
void vm_insn_print_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_PRINT_R3);

  printf("%d\n", !vm->regs->gp->r3->is_negative
                     ? vm->regs->gp->r3->val
                     : (vm->regs->gp->r3->val <= 0xff)
                           ? VM_NEGATE_BYTE(vm->regs->gp->r3->val)
                           : VM_NEGATE_WORD(vm->regs->gp->r3->val));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x24, %esi
callq 0x8080
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x4(%rax)
jne 0x7d45
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0x7db4
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %eax
cmpl $0xff, %eax
jg 0x7d87
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %ecx
andl $0xff, %ecx
movl $0xff, %eax
subl %ecx, %eax
subl $0xff, %eax
movl %eax, -0x10(%rbp)
jmp 0x7dae
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movl $0xffff, %eax           # imm = 0xFFFF
subl %ecx, %eax
subl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %esi
leaq 0x2259(%rip), %rdi      # 0xa017
movb $0x0, %al
callq 0x1050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/regs.c
// Function: vm_regs_init
vm_regs_t *vm_regs_init(void) {
  vm_regs_t *regs = calloc(1, sizeof(vm_regs_t));
  assert(regs != NULL);

  regs->gp = vm_gp_regs_init();
  return regs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x8, %esi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7e44
jmp 0x7e63
leaq 0x21e8(%rip), %rdi      # 0xa033
leaq 0x21ee(%rip), %rsi      # 0xa040
movl $0x8, %edx
leaq 0x21ed(%rip), %rcx      # 0xa04b
callq 0x1060
callq 0x7e80
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/regs.c
// Function: vm_gp_regs_init
vm_gp_regs_t *vm_gp_regs_init(void) {
  vm_gp_regs_t *gp = calloc(1, sizeof(vm_gp_regs_t));
  assert(gp != NULL);

  gp->r0 = vm_value_create();
  gp->r1 = vm_value_create();
  gp->r2 = vm_value_create();
  gp->r3 = vm_value_create();
  return gp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7ea4
jmp 0x7ec3
leaq 0x21be(%rip), %rdi      # 0xa069
leaq 0x218e(%rip), %rsi      # 0xa040
movl $0x15, %edx
leaq 0x21b6(%rip), %rcx      # 0xa074
callq 0x1060
callq 0x7f90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
callq 0x7f90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x7f90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x7f90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/value.c
// Function: vm_value_create
vm_value_t *vm_value_create(void) {
  vm_value_t *ret = calloc(1, sizeof(vm_value_t));
  assert(ret != NULL);

  ret->val = 0;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x8, %esi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x7fb4
jmp 0x7fd3
leaq 0x20dd(%rip), %rdi      # 0xa098
leaq 0x20e2(%rip), %rsi      # 0xa0a4
movl $0x8, %edx
leaq 0x20e2(%rip), %rcx      # 0xa0b0
callq 0x1060
movq -0x8(%rbp), %rax
movw $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_state_create
vm_state_t *vm_state_create(void) {
  vm_state_t *ret = calloc(1, sizeof(vm_state_t));
  assert(ret != NULL);

  ret->opcode = -1;
  ret->next = NULL;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8034
jmp 0x8053
leaq 0x205d(%rip), %rdi      # 0xa098
leaq 0x24d2(%rip), %rsi      # 0xa514
movl $0xa, %edx
leaq 0x24cf(%rip), %rcx      # 0xa51d
callq 0x1060
movq -0x8(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_state_insert
vm_state_t *vm_state_insert(vm_state_t *state, int opcode) {
  if (state == NULL) {
    return NULL;
  }

  vm_state_t *tmp = (vm_state_t *)state;
  vm_state_t *new;

  while (tmp->next != NULL) {
    tmp = tmp->next;
  }

  new = vm_state_create();
  new->opcode = opcode;
  new->next = tmp->next;
  tmp->next = new;
  return state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x80a0
movq $0x0, -0x8(%rbp)
jmp 0x80f7
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x80c1
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x80a8
callq 0x8010
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_state_destroy
void vm_state_destroy(vm_state_t *state) {
  if (state == NULL) {
    return;
  }

  vm_state_destroy(state->next);
  free(state);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x8125
jmp 0x813b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8110
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_stack_create
vm_stack_t *vm_stack_create(void) {
  vm_stack_t *ret = calloc(1, sizeof(vm_stack_t));
  assert(ret != NULL);

  ret->value = NULL;
  ret->next = NULL;
  return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x8174
jmp 0x8193
leaq 0x1f1d(%rip), %rdi      # 0xa098
leaq 0x2392(%rip), %rsi      # 0xa514
movl $0x2f, %edx
leaq 0x23b1(%rip), %rcx      # 0xa53f
callq 0x1060
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_stack_push
vm_stack_t *vm_stack_push(vm_stack_t *stack, vm_value_t *value) {
  if (stack == NULL) {
    return NULL;
  }

  vm_stack_t *new = vm_stack_create();
  new->next = stack->next;
  new->value = value;
  stack->next = new;
  return stack;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x81e1
movq $0x0, -0x8(%rbp)
jmp 0x8219
callq 0x8150
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_stack_pop
vm_value_t *vm_stack_pop(vm_stack_t *stack) {
  vm_stack_t *tmp = stack->next;
  vm_value_t *rval = tmp->value;

  stack->next = stack->next->next == NULL ? NULL : stack->next->next;
  free(tmp);

  return rval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x828a
xorl %eax, %eax
movq %rax, -0x20(%rbp)
jmp 0x829a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_init
vm_t *vm_init(char *buf, size_t len) {
  vm_t *vm = calloc(1, sizeof(vm_t));
  assert(vm != NULL);

  vm->buf = strdup(buf);
  vm->ip = -1;
  vm->is_error = 0;
  vm->buflen = len;
  vm->regs = vm_regs_init();
  vm->state = vm_state_create();
  vm->stack = vm_stack_create();
  return vm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x10a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x830c
jmp 0x832b
leaq 0x224e(%rip), %rdi      # 0xa561
leaq 0x21fa(%rip), %rsi      # 0xa514
movl $0x52, %edx
leaq 0x2246(%rip), %rcx      # 0xa56c
callq 0x1060
movq -0x8(%rbp), %rdi
callq 0x10f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x7e20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
callq 0x8010
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
callq 0x8150
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_movb_imm8_to_regs
static void vm_movb_imm8_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MOVB_IMM8_TO_R0:
    vm_insn_movb_imm8_to_r0(vm);
    break;
  case VM_INSN_MOVB_IMM8_TO_R1:
    vm_insn_movb_imm8_to_r1(vm);
    break;
  case VM_INSN_MOVB_IMM8_TO_R2:
    vm_insn_movb_imm8_to_r2(vm);
    break;
  case VM_INSN_MOVB_IMM8_TO_R3:
    vm_insn_movb_imm8_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $0xffffff70, %eax       # imm = 0xFFFFFF70
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x85d9
movq -0x10(%rbp), %rax
leaq 0x1dfe(%rip), %rcx      # 0xa3a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x1210
jmp 0x85d9
movq -0x8(%rbp), %rdi
callq 0x12c0
jmp 0x85d9
movq -0x8(%rbp), %rdi
callq 0x1340
jmp 0x85d9
movq -0x8(%rbp), %rdi
callq 0x13c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_movb_regs_to_r0
static void vm_movb_regs_to_r0(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MOVB_R0_TO_R0:
    vm_insn_movb_r0_to_r0(vm);
    break;
  case VM_INSN_MOVB_R1_TO_R0:
    vm_insn_movb_r1_to_r0(vm);
    break;
  case VM_INSN_MOVB_R2_TO_R0:
    vm_insn_movb_r2_to_r0(vm);
    break;
  case VM_INSN_MOVB_R3_TO_R0:
    vm_insn_movb_r3_to_r0(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $0xffffff60, %eax       # imm = 0xFFFFFF60
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8649
movq -0x10(%rbp), %rax
leaq 0x1d9e(%rip), %rcx      # 0xa3b4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x1440
jmp 0x8649
movq -0x8(%rbp), %rdi
callq 0x1470
jmp 0x8649
movq -0x8(%rbp), %rdi
callq 0x14f0
jmp 0x8649
movq -0x8(%rbp), %rdi
callq 0x1570
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_movb_regs_to_r1
static void vm_movb_regs_to_r1(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MOVB_R0_TO_R1:
    vm_insn_movb_r0_to_r1(vm);
    break;
  case VM_INSN_MOVB_R1_TO_R1:
    vm_insn_movb_r1_to_r1(vm);
    break;
  case VM_INSN_MOVB_R2_TO_R1:
    vm_insn_movb_r2_to_r1(vm);
    break;
  case VM_INSN_MOVB_R3_TO_R1:
    vm_insn_movb_r3_to_r1(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $0xffffff50, %eax       # imm = 0xFFFFFF50
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x86b9
movq -0x10(%rbp), %rax
leaq 0x1d3e(%rip), %rcx      # 0xa3c4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x15f0
jmp 0x86b9
movq -0x8(%rbp), %rdi
callq 0x1670
jmp 0x86b9
movq -0x8(%rbp), %rdi
callq 0x16a0
jmp 0x86b9
movq -0x8(%rbp), %rdi
callq 0x1720
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_movb_regs_to_r2
static void vm_movb_regs_to_r2(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MOVB_R0_TO_R2:
    vm_insn_movb_r0_to_r2(vm);
    break;
  case VM_INSN_MOVB_R1_TO_R2:
    vm_insn_movb_r1_to_r2(vm);
    break;
  case VM_INSN_MOVB_R2_TO_R2:
    vm_insn_movb_r2_to_r2(vm);
    break;
  case VM_INSN_MOVB_R3_TO_R2:
    vm_insn_movb_r3_to_r2(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $0xffffff40, %eax       # imm = 0xFFFFFF40
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8729
movq -0x10(%rbp), %rax
leaq 0x1cde(%rip), %rcx      # 0xa3d4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x17a0
jmp 0x8729
movq -0x8(%rbp), %rdi
callq 0x1820
jmp 0x8729
movq -0x8(%rbp), %rdi
callq 0x18a0
jmp 0x8729
movq -0x8(%rbp), %rdi
callq 0x18d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_movb_regs_to_r3
static void vm_movb_regs_to_r3(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_MOVB_R0_TO_R3:
    vm_insn_movb_r0_to_r3(vm);
    break;
  case VM_INSN_MOVB_R1_TO_R3:
    vm_insn_movb_r1_to_r3(vm);
    break;
  case VM_INSN_MOVB_R2_TO_R3:
    vm_insn_movb_r2_to_r3(vm);
    break;
  case VM_INSN_MOVB_R3_TO_R3:
    vm_insn_movb_r3_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $0xffffff30, %eax       # imm = 0xFFFFFF30
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8799
movq -0x10(%rbp), %rax
leaq 0x1c7e(%rip), %rcx      # 0xa3e4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x1950
jmp 0x8799
movq -0x8(%rbp), %rdi
callq 0x19d0
jmp 0x8799
movq -0x8(%rbp), %rdi
callq 0x1a50
jmp 0x8799
movq -0x8(%rbp), %rdi
callq 0x1ad0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_addb_imm8_imm8_to_regs
static void vm_addb_imm8_imm8_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_ADDB_IMM8_IMM8_TO_R0:
    vm_insn_addb_imm8_imm8_to_r0(vm);
    break;
  case VM_INSN_ADDB_IMM8_IMM8_TO_R1:
    vm_insn_addb_imm8_imm8_to_r1(vm);
    break;
  case VM_INSN_ADDB_IMM8_IMM8_TO_R2:
    vm_insn_addb_imm8_imm8_to_r2(vm);
    break;
  case VM_INSN_ADDB_IMM8_IMM8_TO_R3:
    vm_insn_addb_imm8_imm8_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x40, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8807
movq -0x10(%rbp), %rax
leaq 0x1c20(%rip), %rcx      # 0xa3f4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x1b00
jmp 0x8807
movq -0x8(%rbp), %rdi
callq 0x1c50
jmp 0x8807
movq -0x8(%rbp), %rdi
callq 0x1da0
jmp 0x8807
movq -0x8(%rbp), %rdi
callq 0x1ef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/plvhx[P]dummy-vm/src/vm.c
// Function: vm_subb_imm8_imm8_to_regs
static void vm_subb_imm8_imm8_to_regs(vm_t *vm) {
  switch (vm->buf[vm->ip]) {
  case VM_INSN_SUBB_IMM8_IMM8_TO_R0:
    vm_insn_subb_imm8_imm8_to_r0(vm);
    break;
  case VM_INSN_SUBB_IMM8_IMM8_TO_R1:
    vm_insn_subb_imm8_imm8_to_r1(vm);
    break;
  case VM_INSN_SUBB_IMM8_IMM8_TO_R2:
    vm_insn_subb_imm8_imm8_to_r2(vm);
    break;
  case VM_INSN_SUBB_IMM8_IMM8_TO_R3:
    vm_insn_subb_imm8_imm8_to_r3(vm);
    break;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq (%rcx), %rax
movslq 0x8(%rcx), %rcx
movzbl (%rax,%rcx), %eax
addl $-0x44, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x3, %eax
ja 0x8877
movq -0x10(%rbp), %rax
leaq 0x1bc0(%rip), %rcx      # 0xa404
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
callq 0x2040
jmp 0x8877
movq -0x8(%rbp), %rdi
callq 0x2190
jmp 0x8877
movq -0x8(%rbp), %rdi
callq 0x22e0
jmp 0x8877
movq -0x8(%rbp), %rdi
callq 0x2430
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)