LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/dynamodb-kv/dispatch.c
// Function: request_dequeue
static void
request_dequeue(struct dispatch_state * D, struct request * R)
{

	/* Sanity-check linked list. */
	assert(D == R->D);

	/* Free the contents of the kivaloo-dynamodb-kv request. */
	proto_dynamodb_kv_request_free(&R->R);

	/* Free the DynamoDB request body we constructed. */
	free(R->body);

	/* Remove from the linked list. */
	if (D->ip_head == R) {
		assert(R->prev == NULL);
		D->ip_head = R->next;
	} else {
		assert(R->prev != NULL);
		R->prev->next = R->next;
	}
	if (D->ip_tail == R) {
		assert(R->next == NULL);
		D->ip_tail = R->prev;
	} else {
		assert(R->next != NULL);
		R->next->prev = R->prev;
	}

	/* Free the request structure. */
	free(R);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq %rdi, (%rsi)
jne 0x4d98
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsi), %rdi
callq 0xcd09
movq 0x50(%rbx), %rdi
callq 0x3470
movq 0x8(%rbx), %rax
cmpq %rbx, 0x18(%r14)
je 0x4d56
testq %rax, %rax
je 0x4db1
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x4d69
testq %rax, %rax
jne 0x4de3
movq 0x10(%rbx), %rcx
movq %rcx, 0x18(%r14)
xorl %eax, %eax
cmpq %rbx, 0x20(%r14)
je 0x4d7d
testq %rcx, %rcx
je 0x4dca
addq $0x8, %rcx
movq %rcx, %r14
jmp 0x4d86
testq %rcx, %rcx
jne 0x4dfc
addq $0x20, %r14
movq %rax, (%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3470
leaq 0xe7d9(%rip), %rdi      # 0x13578
leaq 0xe6b9(%rip), %rsi      # 0x1345f
leaq 0xe7d5(%rip), %rcx      # 0x13582
pushq $0x3a
jmp 0x4e13
leaq 0xe81a(%rip), %rdi      # 0x135d2
leaq 0xe6a0(%rip), %rsi      # 0x1345f
leaq 0xe7bc(%rip), %rcx      # 0x13582
pushq $0x47
jmp 0x4e13
leaq 0xe821(%rip), %rdi      # 0x135f2
leaq 0xe687(%rip), %rsi      # 0x1345f
leaq 0xe7a3(%rip), %rcx      # 0x13582
pushq $0x4e
jmp 0x4e13
leaq 0xe7d8(%rip), %rdi      # 0x135c2
leaq 0xe66e(%rip), %rsi      # 0x1345f
leaq 0xe78a(%rip), %rcx      # 0x13582
pushq $0x44
jmp 0x4e13
leaq 0xe7df(%rip), %rdi      # 0x135e2
leaq 0xe655(%rip), %rsi      # 0x1345f
leaq 0xe771(%rip), %rcx      # 0x13582
pushq $0x4b
popq %rdx
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]kivaloo/dynamodb-kv/dispatch.c
// Function: callback_response
static int
callback_response(void * cookie, struct http_response * res, const char * err)
{
	struct request * R = cookie;
	struct dispatch_state * D = R->D;
	uint8_t * vbuf;
	uint32_t vlen;
	int status;

	/* Did we succeed? */
	switch (res->status) {
	case 200:
		status = 0;
		break;
	case 400:
		if (strcmp(err, "ConditionalCheckFailedException") == 0)
			status = 2;
		else
			status = 1;
		break;
	default:
		status = 1;
		break;
	}

	/* Send appropriate response back to the client. */
	switch (R->R.type) {
	case PROTO_DDBKV_PUT:
	case PROTO_DDBKV_ICAS:
	case PROTO_DDBKV_CREATE:
	case PROTO_DDBKV_DELETE:	/* Has same response as PUT. */
		if (proto_dynamodb_kv_response_put(D->writeq, R->R.ID,
		    status))
			goto err1;
		break;
	case PROTO_DDBKV_GET:
	case PROTO_DDBKV_GETC:		/* Has same response as GET. */
		/* Extract the value. */
		if (dynamodb_kv_extractv(res->body, res->bodylen,
		    &vbuf, &vlen))
			goto err1;

		/* A success without data is a status of 2. */
		if ((status == 0) && (vbuf == NULL))
			status = 2;

		/* Send a response back. */
		if (proto_dynamodb_kv_response_get(D->writeq, R->R.ID,
		    status, vlen, vbuf))
			goto err2;

		/* Free the value. */
		free(vbuf);
		break;
	}

	/* Free the response body buffer. */
	free(res->body);

	/* Remove this request from the in-progress list. */
	request_dequeue(D, R);

	/* Success! */
	return (0);

err2:
	free(vbuf);
err1:
	free(res->body);
	request_dequeue(D, R);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r14
movl (%rsi), %eax
xorl %ebp, %ebp
cmpl $0xc8, %eax
je 0x4e63
cmpl $0x190, %eax            # imm = 0x190
jne 0x4e6b
leaq 0xe7f0(%rip), %rsi      # 0x13639
movq %rdx, %rdi
callq 0x3530
xorl %r13d, %r13d
cmpl $0x1, %eax
movl $0x0, %r12d
adcl $0x1, %r12d
jmp 0x4e72
movb $0x1, %r13b
xorl %r12d, %r12d
jmp 0x4e72
pushq $0x1
popq %r12
xorl %r13d, %r13d
movl $0xfffeff00, %eax       # imm = 0xFFFEFF00
addl 0x20(%rbx), %eax
cmpl $0x20, %eax
ja 0x4f0b
movabsq $0x100000007, %rcx      # imm = 0x100000007
btq %rax, %rcx
jae 0x4ea9
movq 0x30(%r14), %rdi
movq 0x18(%rbx), %rsi
movl %r12d, %edx
callq 0xcd41
testl %eax, %eax
jne 0x4f08
jmp 0x4f0b
movl $0x30000, %ecx          # imm = 0x30000
btq %rax, %rcx
jae 0x4f0b
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdi
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
callq 0xb3e3
testl %eax, %eax
jne 0x4f08
movq 0x10(%rsp), %r8
testq %r8, %r8
pushq $0x2
popq %rdx
cmovnel %r12d, %edx
testb %r13b, %r13b
cmovel %r12d, %edx
movq 0x30(%r14), %rdi
movq 0x18(%rbx), %rsi
movl 0xc(%rsp), %ecx
callq 0xcda6
movl %eax, %r12d
movq 0x10(%rsp), %rdi
callq 0x3470
testl %r12d, %r12d
je 0x4f0b
pushq $-0x1
popq %rbp
movq 0x20(%r15), %rdi
callq 0x3470
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4d1c
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xce31
movq %r8, %r14
movl %ecx, %r12d
movl %edx, %ebp
movq %rdi, %rbx
leal 0x8(%r12), %eax
testl %edx, %edx
pushq $0x4
popq %r15
cmovel %eax, %r15d
movq %r15, %rdx
callq 0xdb00
testq %rax, %rax
je 0xce1b
movq %rax, %r13
andw $0x0, (%rax)
movb %bpl, 0x3(%rax)
movb $0x0, 0x2(%rax)
testl %ebp, %ebp
jne 0xce09
movl %r12d, %edx
bswapl %r12d
movl %r12d, 0x4(%r13)
movq %r13, %rdi
addq $0x8, %rdi
movq %r14, %rsi
callq 0x32a0
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xdbca
testl %eax, %eax
je 0xce20
pushq $-0x1
popq %rax
jmp 0xce22
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x808d(%rip), %rdi      # 0x14ec5
leaq 0x80b6(%rip), %rsi      # 0x14ef5
leaq 0x812f(%rip), %rcx      # 0x14f75
movl $0xe8, %edx
callq 0x3220
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
cmpq $0x24, %rax
je 0x1198
movb $0x0, (%rsp,%rax)
incq %rax
jmp 0x116c
movsbl %al, %eax
leal -0x61(%rax), %ecx
cmpl $0x1a, %ecx
jb 0x1193
leal -0x30(%rax), %ecx
cmpl $0x9, %ecx
ja 0x1198
addl $-0x16, %eax
movl %eax, %ecx
movl %ecx, %eax
incb (%rsp,%rax)
callq 0x1050
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xff000000, %ecx       # imm = 0xFF000000
jne 0x117b
xorl %r15d, %r15d
leaq 0xe50(%rip), %rbx       # 0x2004
pushq $0xa
popq %rbp
pushq $0x23
popq %r14
xorl %r12d, %r12d
cmpq $0x24, %r12
je 0x120a
leal 0x16(%r12), %eax
leal 0x61(%r12), %esi
cmpq $0x1a, %r12
cmovael %eax, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1040
movzbl (%rsp,%r12), %eax
testb %al, %al
cmovlel %r15d, %eax
movzbl %al, %r13d
subl $0x1, %r13d
jb 0x11fe
movl %r14d, %edi
callq 0x1030
jmp 0x11ee
movl %ebp, %edi
callq 0x1030
incq %r12
jmp 0x11be
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x40
popq %rsi
callq 0x43ba
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), %edi
movl %edi, %r8d
negl %r8d
cmpb $-0x1, %sil
cmovel %r8d, %edi
leaq 0x3(%rcx), %rsi
movl %esi, 0x8(%rbx)
movb 0x3(%rdx,%rcx), %sil
leaq 0x4(%rcx), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rdx,%rcx), %ecx
movl %ecx, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %ecx
addl %edi, %ecx
movzwl %cx, %edx
movl %edx, %esi
shrl $0xf, %esi
movq (%rax), %rax
movq (%rax), %rax
movl %esi, 0x4(%rax)
movzbl %cl, %ecx
movl $0x100, %esi            # imm = 0x100
subl %ecx, %esi
testw %dx, %dx
cmovnsl %ecx, %esi
movw %si, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_mulb_imm8_imm8_to_r3
void vm_insn_mulb_imm8_imm8_to_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_MULB_IMM8_IMM8_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_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->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
pushq $0x4b
popq %rsi
callq 0x43ba
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), %edi
movl %edi, %r8d
negl %r8d
cmpb $-0x1, %sil
cmovel %r8d, %edi
leaq 0x3(%rcx), %rsi
movl %esi, 0x8(%rbx)
movb 0x3(%rdx,%rcx), %sil
leaq 0x4(%rcx), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rdx,%rcx), %ecx
movl %ecx, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %ecx
imull %edi, %ecx
movzwl %cx, %edx
movl %edx, %esi
shrl $0xf, %esi
movq (%rax), %rax
movq 0x18(%rax), %rax
movl %esi, 0x4(%rax)
movzbl %cl, %ecx
movl $0x100, %esi            # imm = 0x100
subl %ecx, %esi
testw %dx, %dx
cmovnsl %ecx, %esi
movw %si, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4c
popq %rsi
callq 0x43ba
movq %rax, 0x20(%rbx)
movq (%rbx), %rdx
movslq 0x8(%rbx), %rsi
leaq 0x1(%rsi), %rax
movl %eax, 0x8(%rbx)
movb 0x1(%rdx,%rsi), %cl
leaq 0x2(%rsi), %rax
movl %eax, 0x8(%rbx)
movzbl 0x2(%rdx,%rsi), %eax
leaq 0x3(%rsi), %rdi
movl %edi, 0x8(%rbx)
movb 0x3(%rdx,%rsi), %dil
leaq 0x4(%rsi), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rdx,%rsi), %esi
movl %esi, %edx
negl %edx
cmpb $-0x1, %dil
cmovel %edx, %esi
testw %si, %si
je 0x1ecb
movzwl %ax, %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %cl
cmovel %edx, %eax
cwtd
idivw %si
movzwl %ax, %ecx
movl %ecx, %edx
shrl $0xf, %edx
movq 0x18(%rbx), %rsi
movq (%rsi), %rsi
movq (%rsi), %rsi
movl %edx, 0x4(%rsi)
movzbl %al, %eax
movl $0x100, %edx            # imm = 0x100
subl %eax, %edx
testw %cx, %cx
cmovnsl %eax, %edx
movw %dx, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x6126(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x3128(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4d
popq %rsi
callq 0x43ba
movq %rax, 0x20(%rbx)
movq (%rbx), %rdx
movslq 0x8(%rbx), %rsi
leaq 0x1(%rsi), %rax
movl %eax, 0x8(%rbx)
movb 0x1(%rdx,%rsi), %cl
leaq 0x2(%rsi), %rax
movl %eax, 0x8(%rbx)
movzbl 0x2(%rdx,%rsi), %eax
leaq 0x3(%rsi), %rdi
movl %edi, 0x8(%rbx)
movb 0x3(%rdx,%rsi), %dil
leaq 0x4(%rsi), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rdx,%rsi), %esi
movl %esi, %edx
negl %edx
cmpb $-0x1, %dil
cmovel %edx, %esi
testw %si, %si
je 0x1f8f
movzwl %ax, %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %cl
cmovel %edx, %eax
cwtd
idivw %si
movzwl %ax, %ecx
movl %ecx, %edx
shrl $0xf, %edx
movq 0x18(%rbx), %rsi
movq (%rsi), %rsi
movq 0x8(%rsi), %rsi
movl %edx, 0x4(%rsi)
movzbl %al, %eax
movl $0x100, %edx            # imm = 0x100
subl %eax, %edx
testw %cx, %cx
cmovnsl %eax, %edx
movw %dx, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x6062(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x3064(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_imm8_to_r2
void vm_insn_divb_imm8_imm8_to_r2(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_IMM8_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_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->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
pushq $0x4e
popq %rsi
callq 0x43ba
movq %rax, 0x20(%rbx)
movq (%rbx), %rdx
movslq 0x8(%rbx), %rsi
leaq 0x1(%rsi), %rax
movl %eax, 0x8(%rbx)
movb 0x1(%rdx,%rsi), %cl
leaq 0x2(%rsi), %rax
movl %eax, 0x8(%rbx)
movzbl 0x2(%rdx,%rsi), %eax
leaq 0x3(%rsi), %rdi
movl %edi, 0x8(%rbx)
movb 0x3(%rdx,%rsi), %dil
leaq 0x4(%rsi), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rdx,%rsi), %esi
movl %esi, %edx
negl %edx
cmpb $-0x1, %dil
cmovel %edx, %esi
testw %si, %si
je 0x2053
movzwl %ax, %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %cl
cmovel %edx, %eax
cwtd
idivw %si
movzwl %ax, %ecx
movl %ecx, %edx
shrl $0xf, %edx
movq 0x18(%rbx), %rsi
movq (%rsi), %rsi
movq 0x10(%rsi), %rsi
movl %edx, 0x4(%rsi)
movzbl %al, %eax
movl $0x100, %edx            # imm = 0x100
subl %eax, %edx
testw %cx, %cx
cmovnsl %eax, %edx
movw %dx, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5f9e(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2fa0(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/plvhx[P]dummy-vm/src/insn.c
// Function: vm_insn_divb_imm8_imm8_to_r3
void vm_insn_divb_imm8_imm8_to_r3(vm_t *vm) {
  vm->state = vm_state_insert(vm->state, VM_INSN_DIVB_IMM8_IMM8_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_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->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
pushq $0x4f
popq %rsi
callq 0x43ba
movq %rax, 0x20(%rbx)
movq (%rbx), %rdx
movslq 0x8(%rbx), %rsi
leaq 0x1(%rsi), %rax
movl %eax, 0x8(%rbx)
movb 0x1(%rdx,%rsi), %cl
leaq 0x2(%rsi), %rax
movl %eax, 0x8(%rbx)
movzbl 0x2(%rdx,%rsi), %eax
leaq 0x3(%rsi), %rdi
movl %edi, 0x8(%rbx)
movb 0x3(%rdx,%rsi), %dil
leaq 0x4(%rsi), %r8
movl %r8d, 0x8(%rbx)
movzbl 0x4(%rdx,%rsi), %esi
movl %esi, %edx
negl %edx
cmpb $-0x1, %dil
cmovel %edx, %esi
testw %si, %si
je 0x2117
movzwl %ax, %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %cl
cmovel %edx, %eax
cwtd
idivw %si
movzwl %ax, %ecx
movl %ecx, %edx
shrl $0xf, %edx
movq 0x18(%rbx), %rsi
movq (%rsi), %rsi
movq 0x18(%rsi), %rsi
movl %edx, 0x4(%rsi)
movzbl %al, %eax
movl $0x100, %edx            # imm = 0x100
subl %eax, %edx
testw %cx, %cx
cmovnsl %eax, %edx
movw %dx, (%rsi)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x5eda(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2edc(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x5c
popq %rsi
callq 0x43ba
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 0x2893
movzbl (%rax,%rdx), %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %eax
cwtd
idivw %di
movzwl %ax, %edx
movl %edx, %esi
shrl $0xf, %esi
movl %esi, 0x4(%rcx)
movzbl %al, %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
movq 0x575e(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x2760(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x5d
popq %rsi
callq 0x43ba
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 0x2947
movzbl (%rax,%rdx), %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %eax
cwtd
idivw %di
movzwl %ax, %edx
movl %edx, %esi
shrl $0xf, %esi
movq 0x8(%rcx), %rcx
movl %esi, 0x4(%rcx)
movzbl %al, %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
movq 0x56aa(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x26ac(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x5e
popq %rsi
callq 0x43ba
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 0x29fb
movzbl (%rax,%rdx), %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %eax
cwtd
idivw %di
movzwl %ax, %edx
movl %edx, %esi
shrl $0xf, %esi
movq 0x10(%rcx), %rcx
movl %esi, 0x4(%rcx)
movzbl %al, %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
movq 0x55f6(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x25f8(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x6d
popq %rsi
callq 0x43ba
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 0x32e9
movzbl (%rax,%rdx), %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %eax
cwtd
idivw %di
movzwl %ax, %edx
movl %edx, %esi
shrl $0xf, %esi
movl %esi, 0x4(%rcx)
movzbl %al, %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
movq 0x4d08(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x1d0a(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x6f
popq %rsi
callq 0x43ba
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 0x3453
movzbl (%rax,%rdx), %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %eax
cwtd
idivw %di
movzwl %ax, %edx
movl %edx, %esi
shrl $0xf, %esi
movq 0x18(%rcx), %rcx
movl %esi, 0x4(%rcx)
movzbl %al, %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
movq 0x4b9e(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x1ba0(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x7c
popq %rsi
callq 0x43ba
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 0x3bdd
movzbl (%rax,%rdx), %eax
movl %eax, %edx
negl %edx
cmpb $-0x1, %sil
cmovel %edx, %eax
cwtd
idivw %di
movzwl %ax, %edx
movl %edx, %esi
shrl $0xf, %esi
movq (%rcx), %rcx
movl %esi, 0x4(%rcx)
movzbl %al, %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
movq 0x4414(%rip), %rax      # 0x7ff8
movq (%rax), %rcx
leaq 0x1416(%rip), %rdi      # 0x5004
pushq $0x12
popq %rsi
pushq $0x1
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10f0
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rsi
callq 0x43ba
movq %rax, 0x20(%r14)
callq 0x4344
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 0xf3d(%rip), %rdi       # 0x5017
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4377
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x21
popq %rsi
callq 0x43ba
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 0xef2(%rip), %rdi       # 0x5017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x22
popq %rsi
callq 0x43ba
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 0xeac(%rip), %rdi       # 0x5017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x23
popq %rsi
callq 0x43ba
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 0xe66(%rip), %rdi       # 0x5017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x24
popq %rsi
callq 0x43ba
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 0xe20(%rip), %rdi       # 0x5017
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x10a0
testq %rax, %rax
je 0x426b
movq %rax, %rbx
callq 0x4288
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xdc1(%rip), %rdi       # 0x5033
leaq 0xdc7(%rip), %rsi       # 0x5040
leaq 0xdcb(%rip), %rcx       # 0x504b
pushq $0x8
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
callq 0x10a0
testq %rax, %rax
je 0x42ce
movq %rax, %rbx
callq 0x4344
movq %rax, (%rbx)
callq 0x4344
movq %rax, 0x8(%rbx)
callq 0x4344
movq %rax, 0x10(%rbx)
callq 0x4344
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd94(%rip), %rdi       # 0x5069
leaq 0xd64(%rip), %rsi       # 0x5040
leaq 0xd91(%rip), %rcx       # 0x5074
pushq $0x15
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x8
popq %rsi
callq 0x10a0
testq %rax, %rax
je 0x435a
popq %rbp
retq
leaq 0xd37(%rip), %rdi       # 0x5098
leaq 0xd3c(%rip), %rsi       # 0x50a4
leaq 0xd41(%rip), %rcx       # 0x50b0
pushq $0x8
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10a0
testq %rax, %rax
je 0x439d
orl $-0x1, (%rax)
popq %rbp
retq
leaq 0xcf4(%rip), %rdi       # 0x5098
leaq 0x1169(%rip), %rsi      # 0x5514
leaq 0x116b(%rip), %rcx      # 0x551d
pushq $0xa
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0x43f2
movl %esi, %r14d
movq %rbx, %rax
movq %rax, %r15
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x43d2
callq 0x4384
movl %r14d, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x10
popq %rsi
callq 0x10a0
testq %rax, %rax
je 0x443c
popq %rbp
retq
leaq 0xc55(%rip), %rdi       # 0x5098
leaq 0x10ca(%rip), %rsi      # 0x5514
leaq 0x10ee(%rip), %rcx      # 0x553f
pushq $0x2f
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0x447f
movq %rsi, %r14
callq 0x4426
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movq %r14, (%rax)
movq %rax, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %rdi
pushq $0x30
popq %rsi
callq 0x10a0
testq %rax, %rax
je 0x4527
movq %rax, %rbx
movq %r15, %rdi
callq 0x1100
movq %rax, (%rbx)
orl $-0x1, 0x8(%rbx)
movq %r14, 0x10(%rbx)
callq 0x4240
movq %rax, 0x18(%rbx)
callq 0x4384
movq %rax, 0x20(%rbx)
callq 0x4426
movq %rax, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1033(%rip), %rdi      # 0x5561
leaq 0xfdf(%rip), %rsi       # 0x5514
leaq 0x1030(%rip), %rcx      # 0x556c
pushq $0x52
popq %rdx
callq 0x1060
// File: /workspace/github_c_makefile_star2_O2/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 0x4400
movq 0x18(%rbx), %rdi
callq 0x42eb
orl $-0x1, 0x8(%rbx)
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/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 0x4d9a
movl %edi, %r14d
movl %r14d, %edi
movq %rbx, %rsi
leaq 0x924(%rip), %rdx       # 0x55a8
callq 0x10e0
cmpl $0x66, %eax
jne 0x4d81
movq 0x333f(%rip), %rax      # 0x7fd8
movq (%rax), %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x10c0
testl %eax, %eax
js 0x4d3d
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 0x4d4e
movq -0x88(%rbp), %r13
movq %r13, %rdi
pushq $0x1
popq %rsi
callq 0x10a0
testq %rax, %rax
je 0x4d5f
movq %rax, %r15
movl %r12d, %edi
movq %rax, %rsi
movq %r13, %rdx
callq 0x1090
testq %rax, %rax
js 0x4d70
movq %r15, %rdi
callq 0x1040
movq %r15, %rdi
movq %rax, %rsi
callq 0x44c8
movq %rax, %r13
movq %rax, %rdi
callq 0x4544
movq %r13, %rdi
callq 0x4c16
movq %r15, %rdi
callq 0x1030
movl %r12d, %edi
callq 0x1080
jmp 0x4c77
leaq 0x867(%rip), %rdi       # 0x55ab
callq 0x10d0
jmp 0x4c77
leaq 0x864(%rip), %rdi       # 0x55b9
callq 0x10d0
jmp 0x4c77
leaq 0x862(%rip), %rdi       # 0x55c8
callq 0x10d0
jmp 0x4c77
leaq 0x861(%rip), %rdi       # 0x55d8
callq 0x10d0
jmp 0x4c77
cmpl $-0x1, %eax
jne 0x4d9a
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x3257(%rip), %rax      # 0x7ff8
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x7dc(%rip), %rsi       # 0x558a
xorl %eax, %eax
callq 0x10b0
pushq $0x1
popq %rax
jmp 0x4d88
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/src/redis-benchmark.c
// Function: showThroughput
int showThroughput(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    REDIS_NOTUSED(eventLoop);
    REDIS_NOTUSED(id);
    REDIS_NOTUSED(clientData);

    if (config.csv) return 250;
    float dt = (float)(mstime()-config.start)/1000.0;
    float rps = (float)config.requests_finished/dt;
    printf("%s: %.2f\r", config.title, rps);
    fflush(stdout);
    return 250; /* every 250ms */
}

// Assembly:
cmpl $0x0, 0x29490(%rip)     # 0x34444
jne 0xb008
pushq %rax
callq 0xb00e
subq 0x29455(%rip), %rax     # 0x34418
cvtsi2ss %rax, %xmm0
divss 0x1a198(%rip), %xmm0    # 0x25168
cvtsi2ssl 0x29420(%rip), %xmm1 # 0x343f8
divss %xmm0, %xmm1
movq 0x2944d(%rip), %rsi     # 0x34430
cvtss2sd %xmm1, %xmm0
leaq 0x1a1da(%rip), %rdi     # 0x251c8
movb $0x1, %al
callq 0x91b0
movq 0x28fb4(%rip), %rax     # 0x33fb0
movq (%rax), %rdi
callq 0x9390
addq $0x8, %rsp
movl $0xfa, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/src/redis-benchmark.c
// Function: createMissingClients
static void createMissingClients(client c) {
    int n = 0;
    char *buf = c->obuf;
    size_t buflen = sdslen(c->obuf);

    /* If we are cloning from a client with a SELECT prefix, skip it since the
     * client will be created with the prefixed SELECT if needed. */
    if (c->selectlen) {
        buf += c->selectlen;
        buflen -= c->selectlen;
    }

    while(config.liveclients < config.numclients) {
        createClient(NULL,0,c);

        /* Listen backlog is quite limited on most systems */
        if (++n > 64) {
            usleep(50000);
            n = 0;
        }
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movl 0x289cd(%rip), %eax     # 0x343ec
cmpl 0x289c3(%rip), %eax     # 0x343e8
jge 0xba4c
xorl %edi, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0xb761
leal 0x1(%r14), %eax
cmpl $0x40, %r14d
movl %eax, %r14d
jl 0xba19
movl $0xc350, %edi           # imm = 0xC350
callq 0x95e0
jmp 0xba16
addq $0x8, %rsp
popq %rbx
popq %r14
retq