LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Tarsnap[P]kivaloo/liball/../lib/proto_dynamodb_kv/proto_dynamodb_kv_server.c
// Function: proto_dynamodb_kv_response_data
int
proto_dynamodb_kv_response_data(struct netbuf_write * Q, uint64_t ID,
    int status, uint32_t len, const uint8_t * buf)
{
	uint8_t * wbuf;
	size_t rlen;

	/* Sanity check. */
	assert((status == 0) || (status == 1) || (status == 2));

	/* Compute the response length. */
	rlen = 4 + ((status == 0) ? len + 4 : 0);

	/* Get a packet data buffer. */
	if ((wbuf = wire_writepacket_getbuf(Q, ID, rlen)) == NULL)
		goto err0;

	/* Write the packet data. */
	be32enc(&wbuf[0], (uint32_t)status);
	if (status == 0) {
		be32enc(&wbuf[4], len);
		memcpy(&wbuf[8], buf, len);
	}

	/* Finish the packet. */
	if (wire_writepacket_done(Q, wbuf, rlen))
		goto err0;

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jae 0xdfac
movq %r8, %r14
movl %ecx, %r12d
movl %edx, %ebp
movq %rdi, %rbx
leal 0x8(%r12), %eax
testl %edx, %edx
movl $0x4, %r15d
cmovel %eax, %r15d
movq %r15, %rdx
callq 0xee2c
testq %rax, %rax
je 0xdf94
movq %rax, %r13
movb %bpl, 0x3(%rax)
movb $0x0, 0x2(%rax)
movw $0x0, (%rax)
testl %ebp, %ebp
jne 0xdf82
movl %r12d, %edx
bswapl %r12d
movl %r12d, 0x4(%r13)
movq %r13, %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x3290
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xeefa
testl %eax, %eax
je 0xdf9b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xdf9d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x80ea(%rip), %rdi      # 0x1609d
leaq 0x8113(%rip), %rsi      # 0x160cd
leaq 0x818c(%rip), %rcx      # 0x1614d
movl $0xe8, %edx
callq 0x3210
nop
// File: /workspace/github_c_makefile_star2_O1/xiongxu[P]bam2bedGraph2/samtools-0.1.19/misc/md5.c
// Function: md5_one
static void md5_one(const char *fn)
{
	unsigned char buf[4096], digest[16];
	MD5_CTX md5;
	int l;
	FILE *fp;

	fp = strcmp(fn, "-")? fopen(fn, "r") : stdin;
	if (fp == 0) {
		fprintf(stderr, "md5sum: %s: No such file or directory\n", fn);
		exit(1);
	}
	MD5Init(&md5);
	while ((l = fread(buf, 1, 4096, fp)) > 0)
		MD5Update(&md5, buf, l);
	MD5Final(digest, &md5);
	if (fp != stdin) fclose(fp);
	for (l = 0; l < 16; ++l)
		printf("%c%c", HEX_STR[digest[l]>>4&0xf], HEX_STR[digest[l]&0xf]);
	printf("  %s\n", fn);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1078, %rsp           # imm = 0x1078
movq %rdi, %rbx
leaq 0x4dd(%rip), %rsi       # 0x2020
callq 0x1070
testl %eax, %eax
je 0x1b60
leaq 0x4cf(%rip), %rsi       # 0x2022
movq %rbx, %rdi
callq 0x10a0
movq %rax, %r14
jmp 0x1b6a
movq 0x2471(%rip), %rax      # 0x3fd8
movq (%rax), %r14
testq %r14, %r14
je 0x1c4e
movaps 0x496(%rip), %xmm0      # 0x2010
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x70(%rsp), %rdi
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r14, %rcx
callq 0x1030
testl %eax, %eax
jle 0x1bd3
leaq 0x18(%rsp), %r15
leaq 0x70(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x11ff
movl $0x1, %esi
movl $0x1000, %edx           # imm = 0x1000
movq %r12, %rdi
movq %r14, %rcx
callq 0x1030
testl %eax, %eax
jg 0x1bad
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x1a5a
movq 0x23f1(%rip), %rax      # 0x3fd8
cmpq (%rax), %r14
je 0x1bf4
movq %r14, %rdi
callq 0x1040
leaq 0x455(%rip), %r15       # 0x2050
leaq 0x449(%rip), %r14       # 0x204b
xorl %r12d, %r12d
movzbl (%rsp,%r12), %eax
movl %eax, %ecx
shrl $0x4, %ecx
movsbl (%rcx,%r15), %esi
andl $0xf, %eax
movsbl (%rax,%r15), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x1050
incq %r12
cmpq $0x10, %r12
jne 0x1c05
leaq 0x42b(%rip), %rdi       # 0x2061
movq %rbx, %rsi
xorl %eax, %eax
addq $0x1078, %rsp           # imm = 0x1078
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1050
movq %rbx, %rdi
callq 0x10d0
// File: /workspace/github_c_makefile_star2_O1/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_14/frequency_histogram.c
// Function: main
int main(void)
{
  int i;
  char chars_freq[ALPHA_NR + NUM_NR];

  // Initialize the chars_freq array with 0
  for (i = 0; i < (ALPHA_NR + NUM_NR); ++i)
  {
    chars_freq[i] = 0;
  }

  // Count characters from the standard input
  char c;
  while ((c = getchar()) != EOF)
  {
    if (c >= 'a' && c <= 'z')
    {
      ++chars_freq[c - 'a'];
    }
    else if (c >= '0' && c <= '9')
    {
      ++chars_freq[c - '0' + ALPHA_NR];
    }
  }

  // Print horizontal histogram
  for (i = 0; i < (ALPHA_NR + NUM_NR); ++i)
  {
    if (i < ALPHA_NR)
    {
      printf("%c: ", 'a' + i);
    }
    else if (i >= ALPHA_NR)
    {
      printf("%c: ", '0' + i - ALPHA_NR);
    }

    int j;
    for (j = 0; j < chars_freq[i]; ++j)
    {
      printf("#");
    }

    putchar('\n');
  }

  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl $0x0, 0x20(%rsp)
callq 0x1050
shll $0x18, %eax
cmpl $0xff000000, %eax       # imm = 0xFF000000
je 0x11a6
sarl $0x18, %eax
leal -0x61(%rax), %ecx
cmpl $0x1a, %ecx
jb 0x119f
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x1178
addl $-0x16, %eax
movl %eax, %ecx
movl %ecx, %eax
incb (%rsp,%rax)
jmp 0x1178
leaq 0xe57(%rip), %rbx       # 0x2004
xorl %r14d, %r14d
leal 0x16(%r14), %eax
leal 0x61(%r14), %esi
cmpq $0x1a, %r14
cmovael %eax, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
movsbl (%rsp,%r14), %ebp
testl %ebp, %ebp
jle 0x11e0
movl $0x23, %edi
callq 0x1030
decl %ebp
jne 0x11d2
movl $0xa, %edi
callq 0x1030
incq %r14
cmpq $0x24, %r14
jne 0x11b0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_addb_imm8_imm8_to_r0
void vm_insn_addb_imm8_imm8_to_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_ADDB_IMM8_IMM8_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_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x40, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rax
movl %eax, 0x8(%rbx)
movq (%rbx), %rdx
movq 0x18(%rbx), %rax
movb 0x1(%rdx,%rcx), %sil
leaq 0x2(%rcx), %rdi
movl %edi, 0x8(%rbx)
movzbl 0x2(%rdx,%rcx), %ecx
movl %ecx, %r8d
negl %r8d
cmpb $-0x1, %sil
cmovel %r8d, %ecx
movslq %edi, %rsi
leaq 0x1(%rsi), %rdi
movl %edi, 0x8(%rbx)
movb 0x1(%rdx,%rsi), %dil
leaq 0x2(%rsi), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x2(%rdx,%rsi), %edx
movl %edx, %esi
negl %esi
cmpb $-0x1, %dil
cmovel %esi, %edx
addl %ecx, %edx
movzwl %dx, %ecx
movl %ecx, %esi
shrl $0xf, %esi
movq (%rax), %rax
movq (%rax), %rax
movl %esi, 0x4(%rax)
movzbl %dl, %edx
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
testw %cx, %cx
cmovnsl %edx, %esi
movw %si, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_imm8_to_r0
void vm_insn_divb_imm8_imm8_to_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_IMM8_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_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x4c, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movslq 0x8(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movl %ecx, 0x8(%rbx)
movb 0x1(%rax,%rsi), %cl
leaq 0x2(%rsi), %rdx
movl %edx, 0x8(%rbx)
movzbl 0x2(%rax,%rsi), %edx
leaq 0x3(%rsi), %rdi
movl %edi, 0x8(%rbx)
movb 0x3(%rax,%rsi), %dil
leaq 0x4(%rsi), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rax,%rsi), %esi
movl %esi, %eax
negl %eax
cmpb $-0x1, %dil
cmovel %eax, %esi
testw %si, %si
je 0x2252
movl %edx, %eax
negl %eax
cmpb $-0x1, %cl
cmovnel %edx, %eax
movswl %si, %ecx
cltd
idivl %ecx
movzbl %al, %ecx
shrl $0xf, %eax
movq 0x18(%rbx), %rdx
movq (%rdx), %rdx
movq (%rdx), %rdx
movl $0x100, %esi            # imm = 0x100
subl %ecx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rdx)
cmovel %ecx, %esi
movw %si, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x116a
jmp 0x224b
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_imm8_to_r1
void vm_insn_divb_imm8_imm8_to_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_IMM8_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_insn_read_byte(vm) == 0xff
                  ? VM_NEGATE_BYTE(vm_insn_read_byte(vm))
                  : vm_insn_read_byte(vm);

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

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x4d, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movslq 0x8(%rbx), %rsi
leaq 0x1(%rsi), %rcx
movl %ecx, 0x8(%rbx)
movb 0x1(%rax,%rsi), %cl
leaq 0x2(%rsi), %rdx
movl %edx, 0x8(%rbx)
movzbl 0x2(%rax,%rsi), %edx
leaq 0x3(%rsi), %rdi
movl %edi, 0x8(%rbx)
movb 0x3(%rax,%rsi), %dil
leaq 0x4(%rsi), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rax,%rsi), %esi
movl %esi, %eax
negl %eax
cmpb $-0x1, %dil
cmovel %eax, %esi
testw %si, %si
je 0x22f6
movl %edx, %eax
negl %eax
cmpb $-0x1, %cl
cmovnel %edx, %eax
movswl %si, %ecx
cltd
idivl %ecx
movzbl %al, %ecx
shrl $0xf, %eax
movq 0x18(%rbx), %rdx
movq (%rdx), %rdx
movq 0x8(%rdx), %rdx
movl $0x100, %esi            # imm = 0x100
subl %ecx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rdx)
cmovel %ecx, %esi
movw %si, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1199
jmp 0x22ef
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_addb_imm8_r0_to_r0
void vm_insn_addb_imm8_r0_to_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_ADDB_IMM8_R0_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->r0->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                  : vm->regs->gp->r0->val;

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x50, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movb 0x1(%rcx,%rax), %sil
leaq 0x2(%rax), %rdi
movl %edi, 0x8(%rbx)
movzbl 0x2(%rcx,%rax), %eax
movl %eax, %ecx
negl %ecx
cmpb $-0x1, %sil
cmovel %ecx, %eax
movq (%rdx), %rcx
movq (%rcx), %rcx
movzwl (%rcx), %edx
movl $0xff, %esi
movl %edx, %edi
andl %esi, %edi
negl %edi
cmpl $0x0, 0x4(%rcx)
cmovel %edx, %edi
addl %eax, %edi
movzwl %di, %eax
movl %eax, %edx
shrl $0xf, %edx
movl %edx, 0x4(%rcx)
andl %esi, %edi
movl $0x100, %edx            # imm = 0x100
subl %edi, %edx
testw %ax, %ax
cmovnsl %edi, %edx
movw %dx, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_addb_imm8_r0_to_r1
void vm_insn_addb_imm8_r0_to_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_ADDB_IMM8_R0_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->r0->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                  : vm->regs->gp->r0->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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x51, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movb 0x1(%rcx,%rax), %sil
leaq 0x2(%rax), %rdi
movl %edi, 0x8(%rbx)
movzbl 0x2(%rcx,%rax), %eax
movl %eax, %ecx
negl %ecx
cmpb $-0x1, %sil
cmovel %ecx, %eax
movq (%rdx), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
movzwl (%rdx), %esi
movl $0xff, %edi
movl %esi, %r8d
andl %edi, %r8d
negl %r8d
cmpl $0x0, 0x4(%rdx)
cmovel %esi, %r8d
addl %eax, %r8d
movzwl %r8w, %eax
movl %eax, %edx
shrl $0xf, %edx
movl %edx, 0x4(%rcx)
andl %edi, %r8d
movl $0x100, %edx            # imm = 0x100
subl %r8d, %edx
testw %ax, %ax
cmovnsl %r8d, %edx
movw %dx, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_subb_imm8_r0_to_r2
void vm_insn_subb_imm8_r0_to_r2(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_SUBB_IMM8_R0_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->r0->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                  : vm->regs->gp->r0->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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x56, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movb 0x1(%rcx,%rax), %sil
leaq 0x2(%rax), %rdi
movl %edi, 0x8(%rbx)
movzbl 0x2(%rcx,%rax), %eax
movl %eax, %ecx
negl %ecx
cmpb $-0x1, %sil
cmovel %ecx, %eax
movq (%rdx), %rcx
movq (%rcx), %rdx
movq 0x10(%rcx), %rcx
movzwl (%rdx), %esi
movl $0xff, %edi
movl %esi, %r8d
andl %edi, %r8d
negl %r8d
cmpl $0x0, 0x4(%rdx)
cmovel %esi, %r8d
subl %r8d, %eax
movzwl %ax, %edx
movl %edx, %esi
shrl $0xf, %esi
movl %esi, 0x4(%rcx)
andl %edi, %eax
movl $0x100, %esi            # imm = 0x100
subl %eax, %esi
testw %dx, %dx
cmovnsl %eax, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r0_to_r0
void vm_insn_divb_imm8_r0_to_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R0_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->r0->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                  : vm->regs->gp->r0->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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x5c, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq (%rcx), %rcx
movzwl (%rcx), %r8d
movzbl %r8b, %edi
negl %edi
cmpl $0x0, 0x4(%rcx)
cmovel %r8d, %edi
testw %di, %di
je 0x2bb5
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1226
jmp 0x2bae
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r0_to_r1
void vm_insn_divb_imm8_r0_to_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R0_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->r0->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                  : vm->regs->gp->r0->val;

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

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x5d, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq (%rcx), %r8
movzwl (%r8), %r9d
movzbl %r9b, %edi
negl %edi
cmpl $0x0, 0x4(%r8)
cmovel %r9d, %edi
testw %di, %di
je 0x2c4c
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movq 0x8(%rcx), %rcx
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1255
jmp 0x2c45
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r0_to_r2
void vm_insn_divb_imm8_r0_to_r2(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R0_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->r0->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                  : vm->regs->gp->r0->val;

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

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x5e, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq (%rcx), %r8
movzwl (%r8), %r9d
movzbl %r9b, %edi
negl %edi
cmpl $0x0, 0x4(%r8)
cmovel %r9d, %edi
testw %di, %di
je 0x2ce3
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movq 0x10(%rcx), %rcx
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1284
jmp 0x2cdc
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r0_to_r3
void vm_insn_divb_imm8_r0_to_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R0_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->r0->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r0->val)
                  : vm->regs->gp->r0->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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x5f, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq (%rcx), %r8
movzwl (%r8), %r9d
movzbl %r9b, %edi
negl %edi
cmpl $0x0, 0x4(%r8)
cmovel %r9d, %edi
testw %di, %di
je 0x2d7a
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movq 0x18(%rcx), %rcx
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x12b3
jmp 0x2d73
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_addb_imm8_r1_to_r0
void vm_insn_addb_imm8_r1_to_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_ADDB_IMM8_R1_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->r1->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r1->val)
                  : vm->regs->gp->r1->val;

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x60, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movb 0x1(%rcx,%rax), %sil
leaq 0x2(%rax), %rdi
movl %edi, 0x8(%rbx)
movzbl 0x2(%rcx,%rax), %eax
movl %eax, %ecx
negl %ecx
cmpb $-0x1, %sil
cmovel %ecx, %eax
movq (%rdx), %rcx
movq (%rcx), %rdx
movq 0x8(%rcx), %rcx
movzwl (%rcx), %esi
movl $0xff, %edi
movl %esi, %r8d
andl %edi, %r8d
negl %r8d
cmpl $0x0, 0x4(%rcx)
cmovel %esi, %r8d
addl %eax, %r8d
movzwl %r8w, %eax
movl %eax, %ecx
shrl $0xf, %ecx
movl %ecx, 0x4(%rdx)
andl %edi, %r8d
movl $0x100, %ecx            # imm = 0x100
subl %r8d, %ecx
testw %ax, %ax
cmovnsl %r8d, %ecx
movw %cx, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_subb_imm8_r1_to_r1
void vm_insn_subb_imm8_r1_to_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_SUBB_IMM8_R1_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->r1->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r1->val)
                  : vm->regs->gp->r1->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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x65, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movb 0x1(%rcx,%rax), %sil
leaq 0x2(%rax), %rdi
movl %edi, 0x8(%rbx)
movzbl 0x2(%rcx,%rax), %eax
movl %eax, %ecx
negl %ecx
cmpb $-0x1, %sil
cmovel %ecx, %eax
movq (%rdx), %rcx
movq 0x8(%rcx), %rcx
movzwl (%rcx), %edx
movl $0xff, %esi
movl %edx, %edi
andl %esi, %edi
negl %edi
cmpl $0x0, 0x4(%rcx)
cmovel %edx, %edi
subl %edi, %eax
movzwl %ax, %edx
movl %edx, %edi
shrl $0xf, %edi
movl %edi, 0x4(%rcx)
andl %esi, %eax
movl $0x100, %esi            # imm = 0x100
subl %eax, %esi
testw %dx, %dx
cmovnsl %eax, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r1_to_r1
void vm_insn_divb_imm8_r1_to_r1(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R1_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->r1->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r1->val)
                  : vm->regs->gp->r1->val;

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

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x6d, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq 0x8(%rcx), %rcx
movzwl (%rcx), %r8d
movzbl %r8b, %edi
negl %edi
cmpl $0x0, 0x4(%rcx)
cmovel %r8d, %edi
testw %di, %di
je 0x3592
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x1311
jmp 0x358b
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_r1_to_r3
void vm_insn_divb_imm8_r1_to_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_R1_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->r1->is_negative
                  ? VM_NEGATE_BYTE(vm->regs->gp->r1->val)
                  : vm->regs->gp->r1->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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x6f, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq 0x8(%rcx), %r8
movzwl (%r8), %r9d
movzbl %r9b, %edi
negl %edi
cmpl $0x0, 0x4(%r8)
cmovel %r9d, %edi
testw %di, %di
je 0x36c2
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movq 0x18(%rcx), %rcx
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x136f
jmp 0x36bb
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_subb_imm8_r2_to_r0
void vm_insn_subb_imm8_r2_to_r0(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_SUBB_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;

  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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x74, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movslq 0x8(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x8(%rbx)
movq (%rbx), %rcx
movq 0x18(%rbx), %rdx
movb 0x1(%rcx,%rax), %sil
leaq 0x2(%rax), %rdi
movl %edi, 0x8(%rbx)
movzbl 0x2(%rcx,%rax), %eax
movl %eax, %ecx
negl %ecx
cmpb $-0x1, %sil
cmovel %ecx, %eax
movq (%rdx), %rcx
movq (%rcx), %rdx
movq 0x10(%rcx), %rcx
movzwl (%rcx), %esi
movl $0xff, %edi
movl %esi, %r8d
andl %edi, %r8d
negl %r8d
cmpl $0x0, 0x4(%rcx)
cmovel %esi, %r8d
subl %r8d, %eax
movzwl %ax, %ecx
movl %ecx, %esi
shrl $0xf, %esi
movl %esi, 0x4(%rdx)
andl %edi, %eax
movl $0x100, %esi            # imm = 0x100
subl %eax, %esi
testw %cx, %cx
cmovnsl %eax, %esi
movw %si, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x7c, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq 0x10(%rcx), %r8
movzwl (%r8), %r9d
movzbl %r9b, %edi
negl %edi
cmpl $0x0, 0x4(%r8)
cmovel %r9d, %edi
testw %di, %di
je 0x3e47
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movq (%rcx), %rcx
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x139e
jmp 0x3e40
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x7f, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movslq 0x8(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movl %esi, 0x8(%rbx)
movb 0x1(%rax,%rdx), %sil
addq $0x2, %rdx
movl %edx, 0x8(%rbx)
movq (%rcx), %rcx
movq 0x10(%rcx), %r8
movzwl (%r8), %r9d
movzbl %r9b, %edi
negl %edi
cmpl $0x0, 0x4(%r8)
cmovel %r9d, %edi
testw %di, %di
je 0x400a
movzbl (%rax,%rdx), %edx
movl %edx, %eax
negl %eax
cmpb $-0x1, %sil
cmovnel %edx, %eax
movswl %di, %esi
cltd
idivl %esi
movzbl %al, %edx
shrl $0xf, %eax
movq 0x18(%rcx), %rcx
movl $0x100, %esi            # imm = 0x100
subl %edx, %esi
andl $0x1, %eax
movl %eax, 0x4(%rcx)
cmovel %edx, %esi
movw %si, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x142b
jmp 0x4003
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movl $0x20, %esi
callq 0x45a7
movq %rax, 0x20(%r14)
callq 0x4518
movq %rax, %rbx
movq (%r14), %rax
movslq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movl %edx, 0x8(%r14)
movb 0x1(%rax,%rcx), %dl
xorl %esi, %esi
cmpb $-0x1, %dl
sete %sil
movl %esi, 0x4(%rbx)
leaq 0x2(%rcx), %rsi
movl %esi, 0x8(%r14)
movzbl 0x2(%rax,%rcx), %eax
movzwl %ax, %eax
movl %eax, %esi
xorl $0xff, %esi
addl $0xffffff01, %esi       # imm = 0xFFFFFF01
cmpb $-0x1, %dl
movw %ax, (%rbx)
cmovnel %eax, %esi
leaq 0x1d43(%rip), %rdi      # 0x6017
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4556
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x21, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq (%rax), %rax
movzwl (%rax), %ecx
movl %ecx, %esi
negl %esi
cmpl $0x0, 0x4(%rax)
cmovel %ecx, %esi
leaq 0x1cf6(%rip), %rdi      # 0x6017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x22, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movzwl (%rax), %ecx
movl %ecx, %esi
negl %esi
cmpl $0x0, 0x4(%rax)
cmovel %ecx, %esi
leaq 0x1cae(%rip), %rdi      # 0x6017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x23, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movzwl (%rax), %ecx
movl %ecx, %esi
negl %esi
cmpl $0x0, 0x4(%rax)
cmovel %ecx, %esi
leaq 0x1c66(%rip), %rdi      # 0x6017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movl $0x24, %esi
callq 0x45a7
movq %rax, 0x20(%rbx)
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movzwl (%rax), %ecx
movl %ecx, %esi
negl %esi
cmpl $0x0, 0x4(%rax)
cmovel %ecx, %esi
leaq 0x1c1e(%rip), %rdi      # 0x6017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
nop
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x8, %esi
callq 0x10a0
testq %rax, %rax
je 0x4437
movq %rax, %rbx
callq 0x4456
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1bf5(%rip), %rdi      # 0x6033
leaq 0x1bfb(%rip), %rsi      # 0x6040
leaq 0x1bff(%rip), %rcx      # 0x604b
movl $0x8, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x20, %esi
callq 0x10a0
testq %rax, %rax
je 0x44a0
movq %rax, %rbx
callq 0x4518
movq %rax, (%rbx)
callq 0x4518
movq %rax, 0x8(%rbx)
callq 0x4518
movq %rax, 0x10(%rbx)
callq 0x4518
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1bc2(%rip), %rdi      # 0x6069
leaq 0x1b92(%rip), %rsi      # 0x6040
leaq 0x1bbf(%rip), %rcx      # 0x6074
movl $0x15, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/regs.c
// Function: vm_gp_regs_destroy
void vm_gp_regs_destroy(vm_gp_regs_t *gp) {
  free(gp->r3);
  free(gp->r2);
  free(gp->r1);
  free(gp->r0);
  free(gp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x1030
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x8, %esi
callq 0x10a0
testq %rax, %rax
je 0x4537
movw $0x0, (%rax)
popq %rbp
retq
leaq 0x1b5a(%rip), %rdi      # 0x6098
leaq 0x1b5f(%rip), %rsi      # 0x60a4
leaq 0x1b64(%rip), %rcx      # 0x60b0
movl $0x8, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
testq %rax, %rax
je 0x4588
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rax)
popq %rbp
retq
leaq 0x1b09(%rip), %rdi      # 0x6098
leaq 0x1f7e(%rip), %rsi      # 0x6514
leaq 0x1f80(%rip), %rcx      # 0x651d
movl $0xa, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x45e1
movl %esi, %r14d
movq %rdi, %rbx
movq %rdi, %rax
movq %rax, %r15
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x45bf
callq 0x4560
movl %r14d, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r15)
jmp 0x45e3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x10, %esi
callq 0x10a0
testq %rax, %rax
je 0x4637
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rbp
retq
leaq 0x1a5a(%rip), %rdi      # 0x6098
leaq 0x1ecf(%rip), %rsi      # 0x6514
leaq 0x1ef3(%rip), %rcx      # 0x653f
movl $0x2f, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x467e
movq %rsi, %r14
movq %rdi, %rbx
callq 0x4617
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %r14, (%rax)
movq %rax, 0x8(%rbx)
jmp 0x4680
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
movq (%rax), %rbx
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq %rax, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10a0
testq %rax, %rax
je 0x4731
movq %rax, %rbx
movq %r15, %rdi
callq 0x1100
movq %rax, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
callq 0x4408
movq %rax, 0x18(%rbx)
callq 0x4560
movq %rax, 0x20(%rbx)
callq 0x4617
movq %rax, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e29(%rip), %rdi      # 0x6561
leaq 0x1dd5(%rip), %rsi      # 0x6514
leaq 0x1e26(%rip), %rcx      # 0x656c
movl $0x52, %edx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/src/vm.c
// Function: vm_destroy
void vm_destroy(vm_t *vm) {
  vm_stack_destroy(vm->stack);
  vm_state_destroy(vm->state);
  vm_regs_destroy(vm->regs);

  vm->ip = -1;

  free(vm->buf);
  free(vm);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1030
movq 0x20(%rbx), %rdi
callq 0x45f1
movq 0x18(%rbx), %rdi
callq 0x44bf
movl $0xffffffff, 0x8(%rbx)  # imm = 0xFFFFFFFF
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O1/plvhx[P]dummy-vm/dispatcher.c
// Function: main
int main(int argc, char **argv) {
  int opt;

  if (argc == 1) {
    fprintf(stderr, "Usage: %s -f <filename>.cplx\n", argv[0]);
    return 1;
  }

  while ((opt = getopt(argc, argv, "f:")) != -1) {
    switch (opt) {
    case 'f':
      vm_runner_run_file(optarg);
      break;
    default:
      fprintf(stderr, "Usage: %s -f <filename>.cplx\n", argv[0]);
      return 1;
    }
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
je 0x5074
movl %edi, %r14d
movl %r14d, %edi
movq %rbx, %rsi
leaq 0x164c(%rip), %rdx      # 0x65a8
callq 0x10e0
cmpl $0x66, %eax
jne 0x505b
movq 0x4067(%rip), %rax      # 0x8fd8
movq (%rax), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
testl %eax, %eax
js 0x5017
movl %eax, %r12d
movl $0x90, %edx
leaq -0xb8(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x1070
movl %r12d, %edi
movq %r15, %rsi
callq 0x1110
testl %eax, %eax
js 0x5028
movq -0x88(%rbp), %r13
movl $0x1, %esi
movq %r13, %rdi
callq 0x10a0
testq %rax, %rax
je 0x5039
movq %rax, %r15
movl %r12d, %edi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1090
testq %rax, %rax
js 0x504a
movq %r15, %rdi
callq 0x1040
movq %r15, %rdi
movq %rax, %rsi
callq 0x46c9
movq %rax, %r13
movq %rax, %rdi
callq 0x4750
movq %r13, %rdi
callq 0x4eea
movq %r15, %rdi
callq 0x1030
movl %r12d, %edi
callq 0x1080
jmp 0x4f4f
leaq 0x158d(%rip), %rdi      # 0x65ab
callq 0x10d0
jmp 0x4f4f
leaq 0x158a(%rip), %rdi      # 0x65b9
callq 0x10d0
jmp 0x4f4f
leaq 0x1588(%rip), %rdi      # 0x65c8
callq 0x10d0
jmp 0x4f4f
leaq 0x1587(%rip), %rdi      # 0x65d8
callq 0x10d0
jmp 0x4f4f
cmpl $-0x1, %eax
jne 0x5074
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
callq 0x145a
movl $0x1, %eax
jmp 0x5062