LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_handler_list_update
subtilis_handler_list_t *
subtilis_handler_list_update(subtilis_handler_list_t *list, size_t level,
			     size_t label, subtilis_error_t *err)
{
	subtilis_handler_list_t *p;

	if (!list || level > list->level) {
		p = malloc(sizeof(*p));
		if (!p) {
			subtilis_error_set_oom(err);
			return NULL;
		}
		p->level = level;
		p->label = label;
		p->next = list;
		return p;
	}

	if (level < list->level) {
		subtilis_error_set_assertion_failed(err);
		return list;
	}

	list->label = label;

	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x37ffc
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x38062
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x38035
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x72df7(%rip), %rdx     # 0xaae18
movl $0x129, %ecx            # imm = 0x129
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x380a7
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x380a7
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x38093
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x72d99(%rip), %rdx     # 0xaae18
movl $0x133, %ecx            # imm = 0x133
callq 0x158e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x380a7
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_merge_errors
void subtilis_ir_merge_errors(subtilis_ir_section_t *s, subtilis_error_t *err)
{
	size_t i;

	s->handler_offset = s->len;
	for (i = 0; i < s->error_len; i++) {
		prv_ensure_buffer(s, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		s->ops[s->len++] = s->error_ops[i];
		s->error_ops[i] = NULL;
	}
	s->error_len = 0;
	s->max_error_len = 0;
	free(s->error_ops);
	s->error_ops = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x80(%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x38165
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x381a0
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x38114
jmp 0x38196
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x18(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x380eb
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq $0x0, 0x70(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_ensure_buffer
static void prv_ensure_buffer(subtilis_ir_section_t *s, subtilis_error_t *err)
{
	subtilis_ir_op_t **new_ops;
	size_t new_max;

	if (s->len < s->max_len)
		return;

	new_max = s->max_len + SUBTILIS_CONFIG_PROGRAM_GRAN;
	new_ops = realloc(s->ops, new_max * sizeof(subtilis_ir_op_t *));
	if (!new_ops) {
		subtilis_error_set_oom(err);
		return;
	}
	s->max_len = new_max;
	s->ops = new_ops;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x381c4
jmp 0x3822a
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x38212
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x72c12(%rip), %rdx     # 0xaae18
movl $0x159, %ecx            # imm = 0x159
callq 0x158e0
jmp 0x3822a
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_instr
size_t subtilis_ir_section_add_instr(subtilis_ir_section_t *s,
				     subtilis_op_instr_type_t type,
				     subtilis_ir_operand_t op1,
				     subtilis_ir_operand_t op2,
				     subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	const subtilis_ir_class_info_t *details;
	size_t *counter;

	details = &class_details[op_desc[type].cls];
	if (details->op_count == 0) {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}
	if (details->classes[0] == SUBTILIS_IR_OPERAND_REGISTER) {
		counter = &s->reg_counter;
	} else if (details->classes[0] == SUBTILIS_IR_OPERAND_FREGISTER) {
		counter = &s->freg_counter;
	} else {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}

	op0.reg = *counter;
	subtilis_ir_section_add_instr_reg(s, type, op0, op1, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;
	(*counter)++;
	return op0.reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
leaq 0x92a39(%rip), %rax     # 0xcac90
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x72986(%rip), %rax     # 0xaabf0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x382a6
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x72b89(%rip), %rdx     # 0xaae18
movl $0x1c4, %ecx            # imm = 0x1C4
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3834c
movq -0x40(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x382be
movq -0x20(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x48(%rbp)
jmp 0x382fc
movq -0x40(%rbp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x382d6
movq -0x20(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
jmp 0x382fa
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x72b32(%rip), %rdx     # 0xaae18
movl $0x1cc, %ecx            # imm = 0x1CC
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3834c
jmp 0x382fc
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %r9
movq -0x38(%rbp), %rdx
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x38360
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x38336
movq $0x0, -0x8(%rbp)
jmp 0x3834c
movq -0x48(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_instr_reg
void subtilis_ir_section_add_instr_reg(subtilis_ir_section_t *s,
				       subtilis_op_instr_type_t type,
				       subtilis_ir_operand_t op0,
				       subtilis_ir_operand_t op1,
				       subtilis_ir_operand_t op2,
				       subtilis_error_t *err)
{
	subtilis_ir_op_t *op;
	subtilis_ir_inst_t *instr;

	if (s->in_error_handler)
		prv_ensure_error_buffer(s, err);
	else
		prv_ensure_buffer(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op = malloc(sizeof(*op));
	if (!op) {
		subtilis_error_set_oom(err);
		return;
	}

	op->type = SUBTILIS_OP_INSTR;
	instr = &op->op.instr;
	instr->type = type;
	instr->operands[0] = op0;
	instr->operands[1] = op1;
	instr->operands[2] = op2;

	if (s->in_error_handler)
		s->error_ops[s->error_len++] = op;
	else
		s->ops[s->len++] = op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x38398
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x38630
jmp 0x383a5
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x381a0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x383b3
jmp 0x3847c
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x383e7
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0x72a40(%rip), %rdx     # 0xaae18
movl $0x225, %ecx            # imm = 0x225
callq 0x158e0
jmp 0x3847c
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x38459
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x20(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x3847c
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x20(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_ensure_error_buffer
static void prv_ensure_error_buffer(subtilis_ir_section_t *s,
				    subtilis_error_t *err)
{
	subtilis_ir_op_t **new_ops;
	size_t new_max;

	if (s->error_len < s->max_error_len)
		return;

	new_max = s->max_error_len + SUBTILIS_CONFIG_PROGRAM_GRAN;
	new_ops = realloc(s->error_ops, new_max * sizeof(subtilis_ir_op_t *));
	if (!new_ops) {
		subtilis_error_set_oom(err);
		return;
	}
	s->max_error_len = new_max;
	s->error_ops = new_ops;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x58(%rcx), %rax
jae 0x38654
jmp 0x386ba
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
addq $0x1000, %rax           # imm = 0x1000
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
movq -0x20(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x386a2
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x72782(%rip), %rdx     # 0xaae18
movl $0x16c, %ecx            # imm = 0x16C
callq 0x158e0
jmp 0x386ba
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x70(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_instr4
void subtilis_ir_section_add_instr4(subtilis_ir_section_t *s,
				    subtilis_op_instr_type_t type,
				    subtilis_ir_operand_t op0,
				    subtilis_ir_operand_t op1,
				    subtilis_ir_operand_t op2,
				    subtilis_ir_operand_t op3,
				    subtilis_error_t *err)

/* clang-format on */

{
	subtilis_ir_op_t *op;
	subtilis_ir_inst_t *instr;

	if (s->in_error_handler)
		prv_ensure_error_buffer(s, err);
	else
		prv_ensure_buffer(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op = malloc(sizeof(*op));
	if (!op) {
		subtilis_error_set_oom(err);
		return;
	}

	op->type = SUBTILIS_OP_INSTR;
	instr = &op->op.instr;
	instr->type = type;
	instr->operands[0] = op0;
	instr->operands[1] = op1;
	instr->operands[2] = op2;
	instr->operands[3] = op3;

	if (s->in_error_handler)
		s->error_ops[s->error_len++] = op;
	else
		s->ops[s->len++] = op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
movq -0x28(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x386fc
movq -0x28(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0x38630
jmp 0x38709
movq -0x28(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0x381a0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x38717
jmp 0x387ec
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3874b
movq 0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x726dc(%rip), %rdx     # 0xaae18
movl $0x24e, %ecx            # imm = 0x24E
callq 0x158e0
jmp 0x387ec
movq -0x38(%rbp), %rax
movl $0x0, (%rax)
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x387c9
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x28(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x387ec
movq -0x38(%rbp), %rdx
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x28(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_nop
size_t subtilis_ir_section_add_nop(subtilis_ir_section_t *s,
				   subtilis_error_t *err)
{
	size_t ret;
	subtilis_ir_op_t *op;

	if (s->in_error_handler)
		prv_ensure_error_buffer(s, err);
	else
		prv_ensure_buffer(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;

	op = malloc(sizeof(*op));
	if (!op) {
		subtilis_error_set_oom(err);
		return 0;
	}

	op->type = SUBTILIS_OP_INSTR;
	op->op.instr.type = SUBTILIS_OP_INSTR_NOP;

	ret = s->len;

	if (s->in_error_handler)
		s->error_ops[s->error_len++] = op;
	else
		s->ops[s->len++] = op;

	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x38829
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38630
jmp 0x38836
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x381a0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3884c
movq $0x0, -0x8(%rbp)
jmp 0x38900
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x38885
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x725a7(%rip), %rdx     # 0xaae18
movl $0x26f, %ecx            # imm = 0x26F
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x38900
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
movl $0x54, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x388d5
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x388f8
movq -0x28(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_promote_nop
size_t subtilis_ir_section_promote_nop(subtilis_ir_section_t *s, size_t nop,
				       subtilis_op_instr_type_t type,
				       size_t op1, subtilis_error_t *err)
{
	subtilis_ir_inst_t *instr;
	subtilis_ir_op_t *op;

	if (s->in_error_handler || ((type != SUBTILIS_OP_INSTR_MOV_I32_FP) &&
				    (type != SUBTILIS_OP_INSTR_MOV_FP_I32) &&
				    (type != SUBTILIS_OP_INSTR_SIGNX_8_TO_32) &&
				    (type != SUBTILIS_OP_INSTR_MOV_I8_FP))) {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}

	if (nop >= s->len) {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}

	op = s->ops[nop];
	if ((op->type != SUBTILIS_OP_INSTR) ||
	    (op->op.instr.type != SUBTILIS_OP_INSTR_NOP)) {
		subtilis_error_set_assertion_failed(err);
		return 0;
	}

	instr = &op->op.instr;
	instr->type = type;
	instr->operands[0].reg = (type == SUBTILIS_OP_INSTR_MOV_I32_FP ||
				  type == SUBTILIS_OP_INSTR_MOV_I8_FP)
				     ? s->freg_counter++
				     : s->reg_counter++;
	instr->operands[1].reg = op1;

	return instr->operands[0].reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x60(%rax)
jne 0x38953
cmpl $0x51, -0x1c(%rbp)
je 0x3897a
cmpl $0x52, -0x1c(%rbp)
je 0x3897a
cmpl $0x97, -0x1c(%rbp)
je 0x3897a
cmpl $0x98, -0x1c(%rbp)
je 0x3897a
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x724b5(%rip), %rdx     # 0xaae18
movl $0x28b, %ecx            # imm = 0x28B
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x38a72
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x389af
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x72480(%rip), %rdx     # 0xaae18
movl $0x290, %ecx            # imm = 0x290
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x38a72
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x389d6
movq -0x40(%rbp), %rax
cmpl $0x54, 0x8(%rax)
je 0x389fa
movq -0x30(%rbp), %rdi
movl $0xf, %esi
leaq 0x72432(%rip), %rdx     # 0xaae18
movl $0x297, %ecx            # imm = 0x297
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x38a72
movq -0x40(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x51, -0x1c(%rbp)
je 0x38a1e
cmpl $0x98, -0x1c(%rbp)
jne 0x38a37
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rcx)
movq %rax, -0x48(%rbp)
jmp 0x38a4e
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rcx)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_prog_new
subtilis_ir_prog_t *subtilis_ir_prog_new(const subtilis_settings_t *settings,
					 subtilis_error_t *err)
{
	subtilis_ir_prog_t *p;

	p = calloc(1, sizeof(*p));
	if (!p) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	p->string_pool = subtilis_string_pool_new(err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	p->constant_pool = subtilis_constant_pool_new(err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	p->settings = settings;

	return p;

cleanup:

	subtilis_ir_prog_delete(p);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x38, %esi
callq 0x12130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x38ace
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x7235e(%rip), %rdx     # 0xaae18
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x38b33
movq -0x18(%rbp), %rdi
callq 0x3d520
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x38aed
jmp 0x38b22
movq -0x18(%rbp), %rdi
callq 0x3d080
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x38b0c
jmp 0x38b22
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x38b33
movq -0x20(%rbp), %rdi
callq 0x38b40
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_prog_delete
void subtilis_ir_prog_delete(subtilis_ir_prog_t *p)
{
	size_t i;

	if (!p)
		return;

	for (i = 0; i < p->num_sections; i++)
		prv_ir_section_delete(p->sections[i]);
	free(p->sections);

	subtilis_string_pool_delete(p->string_pool);
	subtilis_constant_pool_delete(p->constant_pool);
	free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x38b55
jmp 0x38bbc
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x38b8d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x392a0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x38b5d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3d790
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3d110
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_prog_section_new
subtilis_ir_section_t *subtilis_ir_prog_section_new(
	subtilis_ir_prog_t *p, const char *name, size_t locals,
	subtilis_type_section_t *tp, subtilis_builtin_type_t ftype,
	const char *file, size_t line, int32_t eflag_offset,
	int32_t error_offset, size_t *call_index, subtilis_error_t *err)

/* clang-format on */

{
	subtilis_ir_section_type_t section_type;

	section_type = ftype == SUBTILIS_BUILTINS_MAX
			   ? SUBTILIS_IR_SECTION_IR
			   : SUBTILIS_IR_SECTION_BACKEND_BUILTIN;

	return prv_ir_prog_section_new(p, name, section_type, locals, tp, ftype,
				       file, line, eflag_offset, error_offset,
				       call_index, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movl %r8d, -0x3c(%rbp)
movq %r9, -0x48(%rbp)
movl -0x3c(%rbp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x9, %edx
cmovel %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x4c(%rbp), %edx
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %r8
movl -0x3c(%rbp), %r9d
movq -0x48(%rbp), %r15
movq 0x10(%rbp), %r14
movl 0x18(%rbp), %ebx
movl 0x20(%rbp), %r11d
movq 0x28(%rbp), %r10
movq 0x30(%rbp), %rax
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x38c80
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_prog_asm_section_new
void subtilis_ir_prog_asm_section_new(
	subtilis_ir_prog_t *p, const char *name, subtilis_type_section_t *tp,
	const char *file, size_t line, int32_t eflag_offset,
	int32_t error_offset, subtilis_backend_asm_free_t asm_free,
	void *asm_code, size_t *call_index, subtilis_error_t *err)

/* clang-format on */

{
	subtilis_ir_section_t *s;

	s = prv_ir_prog_section_new(
	    p, name, SUBTILIS_IR_SECTION_ASM, 0, tp, SUBTILIS_BUILTINS_MAX,
	    file, line, eflag_offset, error_offset, call_index, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		asm_free(asm_code);
		return;
	}

	s->asm_free_fn = asm_free;
	s->asm_code = asm_code;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movl %r9d, -0x44(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r15
movq -0x40(%rbp), %r14
movl -0x44(%rbp), %ebx
movl 0x10(%rbp), %r11d
movq 0x28(%rbp), %r10
movq 0x30(%rbp), %rax
movl $0x2, %edx
xorl %ecx, %ecx
movl $0x9, %r9d
movq %r15, (%rsp)
movq %r14, 0x8(%rsp)
movl %ebx, 0x10(%rsp)
movl %r11d, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x38c80
movq %rax, -0x50(%rbp)
movq 0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x390a2
movq 0x18(%rbp), %rax
movq 0x20(%rbp), %rdi
callq *%rax
jmp 0x390c0
movq 0x18(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0xd8(%rax)
movq 0x20(%rbp), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0xd0(%rax)
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_prog_find_section
subtilis_ir_section_t *subtilis_ir_prog_find_section(subtilis_ir_prog_t *p,
						     const char *name)
{
	size_t index;

	if (!subtilis_string_pool_find(p->string_pool, name, &index))
		return NULL;

	if (index >= p->num_sections)
		return NULL;

	return p->sections[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x3d5a0
testb $0x1, %al
jne 0x39103
movq $0x0, -0x8(%rbp)
jmp 0x3912e
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x3911b
movq $0x0, -0x8(%rbp)
jmp 0x3912e
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_prog_dump
void subtilis_ir_prog_dump(subtilis_ir_prog_t *p)
{
	size_t i;
	subtilis_ir_section_t *s;

	for (i = 0; i < p->num_sections; i++) {
		s = p->sections[i];
		if (s->section_type != SUBTILIS_IR_SECTION_IR)
			continue;
		if (s->type->type.params.fn.ret_val->type == SUBTILIS_TYPE_VOID)
			printf("PROC%s\n----------------\n\n",
			       p->string_pool->strings[i]);
		else
			printf("FN%s\n----------------\n\n",
			       p->string_pool->strings[i]);
		subtilis_ir_section_dump(p->sections[i]);
		printf("\n");
	}

	printf("String Pool\n----------------\n\n");
	subtilis_string_pool_dump(p->string_pool);
	printf("\n");

	printf("Constant Pool\n----------------\n\n");
	subtilis_constant_pool_dump(p->constant_pool);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3920c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39184
jmp 0x391fb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
jne 0x391b8
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x71c75(%rip), %rdi     # 0xaae24
movb $0x0, %al
callq 0x120f0
jmp 0x391d9
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x71c6c(%rip), %rdi     # 0xaae3e
movb $0x0, %al
callq 0x120f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x39260
leaq 0x71c7f(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x39154
leaq 0x71c43(%rip), %rdi     # 0xaae56
movb $0x0, %al
callq 0x120f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x3d820
leaq 0x71c45(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
leaq 0x71c39(%rip), %rdi     # 0xaae75
movb $0x0, %al
callq 0x120f0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x3d1a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_ir_section_delete
static void prv_ir_section_delete(subtilis_ir_section_t *s)
{
	size_t i;
	subtilis_ir_op_t *op;

	if (!s)
		return;

	subtilis_type_section_delete(s->type);
	for (i = 0; i < s->len; i++) {
		op = s->ops[i];
		if (prv_is_call(op)) {
			free(op->op.call.args);
		} else if (op->type == SUBTILIS_OP_SYS_CALL) {
			free(op->op.sys_call.in_regs);
			free(op->op.sys_call.out_regs);
		}

		free(op);
	}
	free(s->ops);

	for (i = 0; i < s->error_len; i++) {
		op = s->error_ops[i];
		if (prv_is_call(op)) {
			free(op->op.call.args);
		} else if (op->type == SUBTILIS_OP_SYS_CALL) {
			free(op->op.sys_call.in_regs);
			free(op->op.sys_call.out_regs);
		}
		free(op);
	}
	free(s->error_ops);
	subtilis_handler_list_free(s->handler_list);

	if (s->asm_free_fn)
		s->asm_free_fn(s->asm_code);

	free(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x392b8
jmp 0x39423
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3e040
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x39349
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3aae0
testb $0x1, %al
jne 0x392fe
jmp 0x3930d
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x12290
jmp 0x39332
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x39330
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x12290
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x12290
jmp 0x39332
movq -0x18(%rbp), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x392cd
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x12290
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
jae 0x393da
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3aae0
testb $0x1, %al
jne 0x3938f
jmp 0x3939e
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x12290
jmp 0x393c3
movq -0x18(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x393c1
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x12290
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x12290
jmp 0x393c3
movq -0x18(%rbp), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3935e
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x37f30
movq -0x8(%rbp), %rax
cmpq $0x0, 0xd8(%rax)
je 0x3941a
movq -0x8(%rbp), %rax
movq 0xd8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xd0(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_dump_section_ops
static void prv_dump_section_ops(subtilis_ir_op_t **ops, size_t len)
{
	size_t i;

	for (i = 0; i < len; i++) {
		if (!ops[i])
			continue;
		if (ops[i]->type == SUBTILIS_OP_INSTR)
			prv_dump_instr(&ops[i]->op.instr);
		else if (ops[i]->type == SUBTILIS_OP_LABEL)
			printf("label_%zu", ops[i]->op.label);
		else if (prv_is_call(ops[i]))
			prv_dump_call(ops[i]->type, &ops[i]->op.call);
		else if (ops[i]->type == SUBTILIS_OP_SYS_CALL)
			prv_dump_sys_call(&ops[i]->op.sys_call);
		else
			continue;
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x39931
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x3984a
jmp 0x39920
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, (%rax)
jne 0x39875
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x8, %rdi
callq 0x39430
jmp 0x39912
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, (%rax)
jne 0x398a6
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
leaq 0x7166c(%rip), %rdi     # 0xaaf09
movb $0x0, %al
callq 0x120f0
jmp 0x39910
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3aae0
testb $0x1, %al
jne 0x398bd
jmp 0x398e2
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x8, %rsi
callq 0x3ab50
jmp 0x3990e
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x8, (%rax)
jne 0x3990a
movq -0x8(%rbp), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x8, %rdi
callq 0x3acd0
jmp 0x3990c
jmp 0x39920
jmp 0x3990e
jmp 0x39910
jmp 0x39912
leaq 0x7155a(%rip), %rdi     # 0xaae73
movb $0x0, %al
callq 0x120f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x39828
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_label
void subtilis_ir_section_add_label(subtilis_ir_section_t *s, size_t l,
				   subtilis_error_t *err)
{
	subtilis_ir_op_t *op;

	if (s->in_error_handler)
		prv_ensure_error_buffer(s, err);
	else
		prv_ensure_buffer(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op = malloc(sizeof(*op));
	if (!op) {
		subtilis_error_set_oom(err);
		return;
	}
	op->type = SUBTILIS_OP_LABEL;
	op->op.label = l;
	if (s->in_error_handler)
		s->error_ops[s->error_len++] = op;
	else
		s->ops[s->len++] = op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x3998d
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38630
jmp 0x3999a
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x381a0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x399a8
jmp 0x39a41
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x399d9
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x7144b(%rip), %rdx     # 0xaae18
movl $0x478, %ecx            # imm = 0x478
callq 0x158e0
jmp 0x39a41
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39a1e
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x39a41
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_get_partial_addr
size_t subtilis_ir_section_add_get_partial_addr(subtilis_ir_section_t *s,
						size_t *call_site,
						subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	size_t call_reg;
	size_t cs;

	op1.label = SIZE_MAX;
	call_reg = subtilis_ir_section_add_instr2(
	    s, SUBTILIS_OP_INSTR_GET_PROC_ADDR, op1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return SIZE_MAX;

	if (s->in_error_handler)
		cs = s->error_len;
	else
		cs = s->len;
	*call_site = cs - 1;

	return call_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rdx
movl $0x9b, %esi
callq 0x38490
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39a99
movq $-0x1, -0x8(%rbp)
jmp 0x39ad4
movq -0x10(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39ab1
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x39abd
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
subq $0x1, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_sys_call
void subtilis_ir_section_add_sys_call(subtilis_ir_section_t *s, size_t call_id,
				      size_t *in_regs,
				      subtilis_ir_sys_out_reg_t *out_regs,
				      uint32_t in_mask, uint32_t out_mask,
				      size_t flags_reg, bool flags_local,
				      subtilis_error_t *err)
{
	subtilis_ir_op_t *op;

	if (s->in_error_handler)
		prv_ensure_error_buffer(s, err);
	else
		prv_ensure_buffer(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op = malloc(sizeof(*op));
	if (!op) {
		subtilis_error_set_oom(err);
		return;
	}
	op->type = SUBTILIS_OP_SYS_CALL;
	op->op.sys_call.call_id = call_id;
	op->op.sys_call.in_regs = in_regs;
	op->op.sys_call.out_regs = out_regs;
	op->op.sys_call.in_mask = in_mask;
	op->op.sys_call.out_mask = out_mask;
	op->op.sys_call.flags_reg = flags_reg;
	op->op.sys_call.flags_local = flags_local;
	if (s->in_error_handler)
		s->error_ops[s->error_len++] = op;
	else
		s->ops[s->len++] = op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x20(%rbp), %rax
movb 0x18(%rbp), %al
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39b29
movq -0x8(%rbp), %rdi
movq 0x20(%rbp), %rsi
callq 0x38630
jmp 0x39b36
movq -0x8(%rbp), %rdi
movq 0x20(%rbp), %rsi
callq 0x381a0
movq 0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39b44
jmp 0x39c25
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x39b78
movq 0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x712af(%rip), %rdx     # 0xaae18
movl $0x4c8, %ecx            # imm = 0x4C8
callq 0x158e0
jmp 0x39c25
movq -0x38(%rbp), %rax
movl $0x8, (%rax)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x30(%rax)
movl -0x24(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movl -0x28(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x14(%rax)
movq 0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movb -0x29(%rbp), %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39c02
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x39c25
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_add_call
static void prv_add_call(subtilis_ir_section_t *s, subtilis_op_type_t type,
			 size_t arg_count, subtilis_ir_arg_t *args,
			 size_t proc_id, subtilis_error_t *err)
{
	subtilis_ir_op_t *op;

	if (s->in_error_handler)
		prv_ensure_error_buffer(s, err);
	else
		prv_ensure_buffer(s, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	op = malloc(sizeof(*op));
	if (!op) {
		subtilis_error_set_oom(err);
		return;
	}
	op->type = type;
	op->op.call.proc_id = proc_id;
	op->op.call.arg_count = arg_count;
	op->op.call.args = args;
	if (s->in_error_handler)
		s->error_ops[s->error_len++] = op;
	else
		s->ops[s->len++] = op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39ca8
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x38630
jmp 0x39cb5
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x381a0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39cc3
jmp 0x39d73
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x39cf4
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0x71130(%rip), %rdx     # 0xaae18
movl $0x492, %ecx            # imm = 0x492
callq 0x158e0
jmp 0x39d73
movl -0xc(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39d50
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x50(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x50(%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x39d73
movq -0x38(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x30(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x30(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_i32_call
size_t subtilis_ir_section_add_i32_call(subtilis_ir_section_t *s,
					size_t arg_count,
					subtilis_ir_arg_t *args,
					subtilis_error_t *err)
{
	prv_add_call(s, SUBTILIS_OP_CALLI32, arg_count, args, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;
	return prv_get_i32_call_reg(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r9
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x39c70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39dca
movq $0x0, -0x8(%rbp)
jmp 0x39dd7
movq -0x10(%rbp), %rdi
callq 0x39df0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_get_i32_call_reg
static size_t prv_get_i32_call_reg(subtilis_ir_section_t *s)
{
	subtilis_ir_op_t *op;

	if (s->in_error_handler)
		op = s->error_ops[s->error_len - 1];
	else
		op = s->ops[s->len - 1];
	op->op.call.reg = s->reg_counter++;
	return op->op.call.reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39e20
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x39e3c
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_real_call
size_t subtilis_ir_section_add_real_call(subtilis_ir_section_t *s,
					 size_t arg_count,
					 subtilis_ir_arg_t *args,
					 subtilis_error_t *err)
{
	prv_add_call(s, SUBTILIS_OP_CALLREAL, arg_count, args, 0, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;
	return prv_get_real_call_reg(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r9
movl $0x4, %esi
xorl %eax, %eax
movl %eax, %r8d
callq 0x39c70
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39eba
movq $0x0, -0x8(%rbp)
jmp 0x39ec7
movq -0x10(%rbp), %rdi
callq 0x39ee0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_get_real_call_reg
static size_t prv_get_real_call_reg(subtilis_ir_section_t *s)
{
	subtilis_ir_op_t *op;

	if (s->in_error_handler)
		op = s->error_ops[s->error_len - 1];
	else
		op = s->ops[s->len - 1];
	op->op.call.reg = s->freg_counter++;
	return op->op.call.reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x60(%rax)
je 0x39f10
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x50(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x39f2c
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_i32_call_ptr
size_t subtilis_ir_section_add_i32_call_ptr(subtilis_ir_section_t *s,
					    size_t arg_count,
					    subtilis_ir_arg_t *args, size_t ptr,
					    subtilis_error_t *err)
{
	prv_add_call(s, SUBTILIS_OP_CALLI32_PTR, arg_count, args, ptr, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;
	return prv_get_i32_call_reg(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x6, %esi
callq 0x39c70
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x39fed
movq $0x0, -0x8(%rbp)
jmp 0x39ffa
movq -0x10(%rbp), %rdi
callq 0x39df0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_section_add_real_call_ptr
size_t subtilis_ir_section_add_real_call_ptr(subtilis_ir_section_t *s,
					     size_t arg_count,
					     subtilis_ir_arg_t *args,
					     size_t ptr, subtilis_error_t *err)
{
	prv_add_call(s, SUBTILIS_OP_CALLREAL_PTR, arg_count, args, ptr, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;
	return prv_get_real_call_reg(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl $0x7, %esi
callq 0x39c70
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3a05d
movq $0x0, -0x8(%rbp)
jmp 0x3a06a
movq -0x10(%rbp), %rdi
callq 0x39ee0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)