LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_real
subtilis_exp_t *subtilis_exp_new_real(double real, subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->type.type = SUBTILIS_TYPE_CONST_REAL;
	e->exp.ir_op.real = real;

	return e;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movsd %xmm0, (%rsp)
pushq $0x1
popq %rdi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
movq %rax, %rbx
testq %rax, %rax
je 0x2a3e4
movsd (%rsp), %xmm0
movsd %xmm0, 0x148(%rbx)
jmp 0x2a3fb
leaq 0x436e7(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x201, %ecx            # imm = 0x201
callq 0x1429e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_str
subtilis_exp_t *subtilis_exp_new_str(subtilis_buffer_t *str,
				     subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->type.type = SUBTILIS_TYPE_CONST_STRING;
	subtilis_buffer_init(&e->exp.str, str->granularity);
	if (subtilis_buffer_get_size(str) > 0)
		subtilis_buffer_append(&e->exp.str, str->buffer->data,
				       subtilis_buffer_get_size(str), err);

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
movq %rax, %rbx
testq %rax, %rax
je 0x2a475
movq %rax, %r12
movl $0x3, (%rbx)
addq $0x148, %r12            # imm = 0x148
movq (%r15), %rsi
movq %r12, %rdi
callq 0x146a8
movq %r15, %rdi
callq 0x14804
testq %rax, %rax
je 0x2a48c
movq 0x8(%r15), %r13
addq $0x18, %r13
movq %r15, %rdi
callq 0x14804
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x14795
jmp 0x2a48c
leaq 0x43656(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x210, %ecx            # imm = 0x210
callq 0x1429e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_fn
subtilis_exp_t *subtilis_exp_new_fn(size_t call_index, const subtilis_type_t *t,
				    subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->exp.ir_op.reg = call_index;
	subtilis_type_init_copy(&e->type, t, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $0x1
popq %rdi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2a4e4
movq %rax, %rbx
movq %r12, 0x148(%rax)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2db73
cmpl $0x0, (%r14)
je 0x2a4fd
movq %rbx, %rdi
callq 0x29d88
jmp 0x2a4fb
leaq 0x435e7(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x222, %ecx            # imm = 0x222
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_partial_fn
subtilis_exp_t *subtilis_exp_new_partial_fn(size_t call_index, const char *name,
					    size_t call_site,
					    subtilis_error_t *err)
{
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	e->exp.ir_op.reg = call_index;
	e->type.type = SUBTILIS_TYPE_FN;
	e->type.params.fn.num_params = 0;
	e->type.params.fn.ret_val = malloc(sizeof(*e->type.params.fn.ret_val));
	if (!e->type.params.fn.ret_val) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	e->type.params.fn.ret_val->type = SUBTILIS_TYPE_VOID;
	e->partial_name = malloc(strlen(name) + 1);
	if (!e->partial_name) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	strcpy(e->partial_name, name);
	e->call_site = call_site;

	return e;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0x1
popq %rdi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2a58d
movq %rax, %rbx
movq %r13, 0x148(%rax)
movl $0x9, (%rax)
movl $0x148, %edi            # imm = 0x148
callq 0x121d0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2a5a6
movl $0x8, (%rax)
movq %r12, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
movq %rax, 0x160(%rbx)
testq %rax, %rax
je 0x2a5ad
movq %rax, %rdi
movq %r12, %rsi
callq 0x12070
movq %r15, 0x168(%rbx)
jmp 0x2a5ce
leaq 0x4353e(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x236, %ecx            # imm = 0x236
callq 0x1429e
jmp 0x2a5cc
movl $0x23e, %ecx            # imm = 0x23E
jmp 0x2a5b2
movl $0x244, %ecx            # imm = 0x244
leaq 0x43519(%rip), %rdx     # 0x6dad2
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x1429e
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/ir.c
// Function: subtilis_handler_list_free
void subtilis_handler_list_free(subtilis_handler_list_t *list)
{
	subtilis_handler_list_t *p;

	while (list) {
		p = list->next;
		free(list);
		list = p;
	}
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2a68c
movq 0x10(%rdi), %rbx
callq 0x122c0
movq %rbx, %rdi
jmp 0x2a679
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/ir.c
// Function: subtilis_handler_list_truncate
subtilis_handler_list_t *
subtilis_handler_list_truncate(subtilis_handler_list_t *list, size_t level)
{
	subtilis_handler_list_t *p;

	while (list && level < list->level) {
		p = list->next;
		free(list);
		list = p;
	}

	return list;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x2a6ad
cmpq %rbx, (%rdi)
jbe 0x2a6ad
movq 0x10(%rdi), %r14
callq 0x122c0
movq %r14, %rdi
jmp 0x2a695
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %rdi, %rdi
je 0x2a6d6
cmpq %r12, (%rbx)
jae 0x2a6f3
pushq $0x18
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2a70e
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %rbx
jmp 0x2a72d
jbe 0x2a729
leaq 0x436a4(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %r14, %rdi
movl $0x133, %ecx            # imm = 0x133
callq 0x1429e
jmp 0x2a72d
leaq 0x4368b(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x129, %ecx            # imm = 0x129
callq 0x1429e
xorl %ebx, %ebx
jmp 0x2a72d
movq %r15, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq %rax, 0x80(%rdi)
leaq 0x50(%rdi), %r15
xorl %r12d, %r12d
cmpq (%r15), %r12
jae 0x2a79c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a7bd
cmpl $0x0, (%r14)
jne 0x2a7b1
movq 0x70(%rbx), %rax
movq (%rax,%r12,8), %rax
movq 0x30(%rbx), %rcx
movq 0x48(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x30(%rbx)
movq %rax, (%rdx,%rcx,8)
movq 0x70(%rbx), %rax
andq $0x0, (%rax,%r12,8)
incq %r12
jmp 0x2a75c
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x70(%rbx), %rdi
callq 0x122c0
andq $0x0, 0x70(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x38(%rdi), %r15
cmpq %r15, 0x30(%rdi)
jb 0x2a7f7
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x8000(,%r15,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x2a7fd
addq $0x1000, %r15           # imm = 0x1000
movq %r15, 0x38(%rbx)
movq %rax, 0x48(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4359c(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x159, %ecx            # imm = 0x159
popq %rbx
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r8
movq %rdx, %rcx
movl %esi, %eax
shlq $0x4, %rax
leaq 0x723d9(%rip), %rdx     # 0x9cc10
movl 0x8(%rax,%rdx), %eax
imulq $0x18, %rax, %rdx
leaq 0x4330a(%rip), %rax     # 0x6db50
cmpq $0x0, (%rdx,%rax)
je 0x2a863
movq %rdi, %r14
addq %rdx, %rax
movl 0x8(%rax), %eax
testl %eax, %eax
je 0x2a877
cmpl $0x1, %eax
jne 0x2a898
pushq $0x20
jmp 0x2a879
leaq 0x43536(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x1c4, %ecx            # imm = 0x1C4
jmp 0x2a8aa
pushq $0x18
popq %r12
movq (%r14,%r12), %r15
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %r9
callq 0x2a8c1
cmpl $0x0, (%rbx)
jne 0x2a8af
incq (%r14,%r12)
jmp 0x2a8b2
leaq 0x43501(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x1cc, %ecx            # imm = 0x1CC
callq 0x1429e
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r12
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x60(%rdi)
jne 0x2a8f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a9b9
jmp 0x2a8fb
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2a7bd
cmpl $0x0, (%r12)
jne 0x2a972
pushq $0x38
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2a939
andl $0x0, (%rax)
movl %ebp, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2a95e
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2a96e
leaq 0x43460(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r12, %rdi
movl $0x225, %ecx            # imm = 0x225
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq 0x30(%rbx), %rcx
movq 0x48(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x30(%rbx)
movq %rax, (%rdx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq 0x58(%rdi), %r15
cmpq %r15, 0x50(%rdi)
jb 0x2a9f3
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
leaq 0x8000(,%r15,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x2a9f9
addq $0x1000, %r15           # imm = 0x1000
movq %r15, 0x58(%rbx)
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x433a0(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x16c, %ecx            # imm = 0x16C
popq %rbx
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %rbx
movq 0x40(%rsp), %r14
cmpb $0x1, 0x60(%rdi)
jne 0x2aa4a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a9b9
jmp 0x2aa55
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a7bd
cmpl $0x0, (%r14)
jne 0x2aad3
pushq $0x38
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2aa9a
andl $0x0, (%rax)
movl %ebp, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq (%rsp), %rcx
movq %rcx, 0x28(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2aabf
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2aacf
leaq 0x432ff(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x24e, %ecx            # imm = 0x24E
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq 0x30(%rbx), %rcx
movq 0x48(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x30(%rbx)
movq %rax, (%rdx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x60(%rdi)
jne 0x2aaff
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a9b9
jmp 0x2ab0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a7bd
cmpl $0x0, (%r14)
je 0x2ab1a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x38
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2ab54
movq %rax, %rcx
andl $0x0, (%rax)
movl $0x54, 0x8(%rax)
movq 0x30(%rbx), %rax
cmpb $0x1, 0x60(%rbx)
jne 0x2ab6d
movq 0x50(%rbx), %rdx
movq 0x70(%rbx), %rsi
leaq 0x1(%rdx), %rdi
movq %rdi, 0x50(%rbx)
movq %rcx, (%rsi,%rdx,8)
jmp 0x2ab12
leaq 0x43245(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x26f, %ecx            # imm = 0x26F
callq 0x1429e
jmp 0x2ab10
movq 0x48(%rbx), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x30(%rbx)
movq %rcx, (%rdx,%rax,8)
jmp 0x2ab12
// File: /workspace/github_c_makefile_star2_O2/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 %rax
cmpb $0x0, 0x60(%rdi)
je 0x2ab9d
leaq 0x43213(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x28b, %ecx            # imm = 0x28B
jmp 0x2ac25
leal -0x51(%rdx), %eax
cmpl $0x2, %eax
jb 0x2abb0
leal -0x97(%rdx), %eax
cmpl $0x2, %eax
jae 0x2ab86
cmpq %rsi, 0x30(%rdi)
jbe 0x2abff
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rsi
cmpl $0x0, (%rsi)
jne 0x2ac13
cmpl $0x54, 0x8(%rsi)
jne 0x2ac13
movl %edx, 0x8(%rsi)
xorl %eax, %eax
cmpl $0x51, %edx
sete %al
cmpl $0x98, %edx
leaq 0x18(,%rax,8), %rax
pushq $0x20
popq %rdx
cmovneq %rax, %rdx
movq (%rdi,%rdx), %rax
leaq 0x1(%rax), %r8
movq %r8, (%rdi,%rdx)
movq %rax, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
jmp 0x2ac2c
leaq 0x4319a(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x290, %ecx            # imm = 0x290
jmp 0x2ac25
leaq 0x43186(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %r8, %rdi
movl $0x297, %ecx            # imm = 0x297
callq 0x1429e
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
callq 0x12150
testq %rax, %rax
je 0x2ac7a
movq %rax, %rbx
movq %r14, %rdi
callq 0x2d644
movq %rax, 0x18(%rbx)
cmpl $0x0, (%r14)
jne 0x2ac70
movq %r14, %rdi
callq 0x2d3ac
movq %rax, 0x28(%rbx)
cmpl $0x0, (%r14)
je 0x2ac9c
movq %rbx, %rdi
callq 0x2aca2
jmp 0x2ac91
leaq 0x4311f(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x1429e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x20(%rbx)
jmp 0x2ac93
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x2acee
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r14
jae 0x2acc8
movq (%rdi,%r14,8), %rdi
callq 0x2b14d
incq %r14
jmp 0x2acb1
callq 0x122c0
movq 0x18(%rbx), %rdi
callq 0x2d7b8
movq 0x28(%rbx), %rdi
callq 0x2d3f8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r10d
movq %r8, %r11
movq %rcx, %rax
movq %rdx, %r8
movq 0x40(%rsp), %rbx
movq 0x38(%rsp), %r12
movl 0x30(%rsp), %r14d
movq 0x50(%rsp), %r15
pushq $0x2
popq %rdx
pushq $0x9
popq %r9
xorl %ecx, %ecx
pushq %r15
pushq 0x50(%rsp)
pushq %r14
pushq %r10
pushq %r11
pushq %rax
callq 0x2ad3d
addq $0x30, %rsp
cmpl $0x0, (%r15)
je 0x2b036
movq %rbx, %rdi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
movq %r12, 0xd8(%rax)
movq %rbx, 0xd0(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x42d14(%rip), %r14     # 0x6ddac
leaq 0x42d27(%rip), %r15     # 0x6ddc6
pushq $0xa
popq %rbp
xorl %r12d, %r12d
cmpq 0x8(%rbx), %r12
jae 0x2b0f4
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
cmpl $0x0, (%rax)
jne 0x2b0ef
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
movq %r14, %rdi
je 0x2b0ca
movq %r15, %rdi
movq 0x18(%rbx), %rax
movq (%rax), %rax
movq (%rax,%r12,8), %rsi
xorl %eax, %eax
callq 0x12110
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
callq 0x2b12e
movl %ebp, %edi
callq 0x12030
incq %r12
jmp 0x2b0a5
leaq 0x43133(%rip), %rdi     # 0x6e22e
callq 0x12080
movq 0x18(%rbx), %rdi
callq 0x2d80b
pushq $0xa
popq %rdi
callq 0x12030
leaq 0x43134(%rip), %rdi     # 0x6e24c
callq 0x12080
movq 0x28(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d450
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x2b240
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2dc17
xorl %r15d, %r15d
pushq $0x20
popq %r12
pushq $0x30
popq %r13
movq 0x48(%rbx), %rdi
cmpq 0x30(%rbx), %r15
jae 0x2b1b9
movq (%rdi,%r15,8), %r14
movl (%r14), %eax
leal -0x2(%rax), %edx
movq %r12, %rcx
cmpl $0x6, %edx
jb 0x2b1a3
cmpl $0x8, %eax
jne 0x2b1ac
movq 0x28(%r14), %rdi
callq 0x122c0
movq %r13, %rcx
movq (%r14,%rcx), %rdi
callq 0x122c0
movq %r14, %rdi
callq 0x122c0
incq %r15
jmp 0x2b176
callq 0x122c0
xorl %r15d, %r15d
pushq $0x20
popq %r12
pushq $0x30
popq %r13
movq 0x70(%rbx), %rdi
cmpq 0x50(%rbx), %r15
jae 0x2b20c
movq (%rdi,%r15,8), %r14
movl (%r14), %eax
leal -0x2(%rax), %edx
movq %r12, %rcx
cmpl $0x6, %edx
jb 0x2b1f6
cmpl $0x8, %eax
jne 0x2b1ff
movq 0x28(%r14), %rdi
callq 0x122c0
movq %r13, %rcx
movq (%r14,%rcx), %rdi
callq 0x122c0
movq %r14, %rdi
callq 0x122c0
incq %r15
jmp 0x2b1c9
callq 0x122c0
movq 0x78(%rbx), %rdi
callq 0x2a678
movq 0xd8(%rbx), %rax
testq %rax, %rax
je 0x2b22f
movq 0xd0(%rbx), %rdi
callq *%rax
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x1, 0x60(%rdi)
jne 0x2b7a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a9b9
jmp 0x2b7ad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a7bd
cmpl $0x0, (%r14)
jne 0x2b812
pushq $0x38
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2b7e2
movl $0x1, (%rax)
movq %r15, 0x8(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2b7fe
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2b80e
leaq 0x425b7(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r14, %rdi
movl $0x478, %ecx            # imm = 0x478
popq %rbx
popq %r14
popq %r15
jmp 0x1429e
movq 0x30(%rbx), %rcx
movq 0x48(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x30(%rbx)
movq %rax, (%rdx,%rcx,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r15
movl $0x9b, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2a981
cmpl $0x0, (%r12)
jne 0x2b85a
movzbl 0x60(%r14), %ecx
shll $0x5, %ecx
movq 0x30(%rcx,%r14), %rcx
decq %rcx
movq %rcx, (%rbx)
movq %rax, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x60(%rsp), %rbp
movq 0x50(%rsp), %r15
movb 0x58(%rsp), %r14b
cmpb $0x1, 0x60(%rdi)
jne 0x2b8b1
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2a9b9
jmp 0x2b8bc
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2a7bd
cmpl $0x0, (%rbp)
jne 0x2b951
pushq $0x38
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2b918
movl $0x8, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x28(%rax)
movq 0x10(%rsp), %rcx
movq %rcx, 0x30(%rax)
movl 0x8(%rsp), %ecx
movl %ecx, 0x10(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, 0x14(%rax)
movq %r15, 0x18(%rax)
movb %r14b, 0x20(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2b93d
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2b94d
leaq 0x42481(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %rbp, %rdi
movl $0x4c8, %ecx            # imm = 0x4C8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq 0x30(%rbx), %rcx
movq 0x48(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x30(%rbx)
movq %rax, (%rdx,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x60(%rdi)
jne 0x2b9a0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a9b9
jmp 0x2b9ab
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a7bd
cmpl $0x0, (%r15)
jne 0x2ba1d
pushq $0x38
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2b9e4
movl %ebp, (%rax)
movq %r12, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r14, 0x20(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2ba09
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2ba19
leaq 0x423b5(%rip), %rdx     # 0x6dda0
pushq $0x1
popq %rsi
movq %r15, %rdi
movl $0x492, %ecx            # imm = 0x492
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1429e
movq 0x30(%rbx), %rcx
movq 0x48(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x30(%rbx)
movq %rax, (%rdx,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/ir.c
// Function: prv_parse_label
static void prv_parse_label(const char *text, subtilis_ir_label_match_t *label,
			    subtilis_error_t *err)
{
	unsigned long num;
	char *end_ptr = 0;

	if (!strcmp(text, "*")) {
		label->label = 0;
		label->op_match = SUBTILIS_OP_MATCH_ANY;
		return;
	}

	errno = 0;
	num = strtoul(text, &end_ptr, 10);
	if (*end_ptr != 0 || errno != 0 || num > INT_MAX) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	label->label = (size_t)num;
	label->op_match = SUBTILIS_OP_MATCH_FLOATING;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
andq $0x0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %r12
cmpb $0x2a, (%rdi)
jne 0x2c527
cmpb $0x0, 0x1(%r12)
je 0x2c589
callq 0x12040
movq %rax, %r15
andl $0x0, (%rax)
leaq 0x8(%rsp), %r13
pushq $0xa
popq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x12250
movq (%r13), %rcx
cmpb $0x0, (%rcx)
jne 0x2c565
cmpl $0x0, (%r15)
setne %cl
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
seta %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x2c594
leaq 0x41834(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x546, %ecx            # imm = 0x546
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1429e
andq $0x0, (%r14)
andl $0x0, 0x8(%r14)
jmp 0x2c59f
movq %rax, (%r14)
movl $0x2, 0x8(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/common/ir.c
// Function: prv_process_floating_label
static bool prv_process_floating_label(subtilis_ir_match_state_t *state,
				       size_t instr_label, size_t match_label,
				       subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_match_pair_t *pair;

	for (i = 0;
	     i < state->labels_count && state->labels[i].key != match_label;
	     i++)
		;
	if (i == state->labels_count) {
		if (i == MAX_MATCH_WILDCARDS) {
			subtilis_error_set_assertion_failed(err);
			return false;
		}
		pair = &state->labels[i];
		pair->key = match_label;
		pair->value = instr_label;
		state->labels_count++;
		return true;
	}

	return state->labels[i].value == instr_label;
}

// Assembly:
pushq %rax
leaq 0x200(%rdi), %r8
movq 0x310(%rdi), %rax
leaq 0x208(%rdi), %r9
movq %rax, %r11
movq %rax, %r10
subq $0x1, %r10
jb 0x2c5eb
cmpq %rdx, -0x8(%r9)
je 0x2c5de
addq $0x10, %r9
movq %r10, %r11
jmp 0x2c5c9
testq %r11, %r11
je 0x2c5eb
cmpq %rsi, (%r9)
sete %al
jmp 0x2c628
cmpq $0x10, %rax
jne 0x2c60c
leaq 0x417a8(%rip), %rdx     # 0x6dda0
pushq $0xf
popq %rsi
movq %rcx, %rdi
movl $0x635, %ecx            # imm = 0x635
callq 0x1429e
xorl %eax, %eax
jmp 0x2c628
movq %rax, %rcx
shlq $0x4, %rcx
movq %rdx, (%r8,%rcx)
movq %rsi, 0x8(%r8,%rcx)
incq %rax
movq %rax, 0x310(%rdi)
movb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_new
subtilis_hashtable_t *subtilis_hashtable_new(size_t num_buckets,
					     subtilis_hashtable_func_t h_func,
					     subtilis_hashtable_equal_t eq_func,
					     subtilis_hashtable_free_t free_k,
					     subtilis_hashtable_free_t free_v,
					     subtilis_error_t *err)
{
	subtilis_hashtable_t *h = malloc(sizeof(*h));

	if (!h)
		goto on_error;

	h->buckets = calloc(num_buckets, sizeof(subtilis_hashtable_node_t *));
	if (!h->buckets)
		goto on_error;

	h->num_buckets = num_buckets;
	h->elements = 0;
	h->hash_func = h_func;
	h->equal_func = eq_func;
	h->free_key = free_k;
	h->free_value = free_v;

	return h;

on_error:

	subtilis_error_set_oom(err);
	free(h);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x2c68c
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x12150
movq %rax, (%rbx)
testq %rax, %rax
je 0x2c68c
movq %r14, 0x10(%rbx)
andq $0x0, 0x8(%rbx)
movq %rbp, 0x18(%rbx)
movq %r13, 0x20(%rbx)
movq %r12, 0x28(%rbx)
movq (%rsp), %rax
movq %rax, 0x30(%rbx)
jmp 0x2c6ab
leaq 0x41bd9(%rip), %rdx     # 0x6e26c
pushq $0x1
popq %rsi
pushq $0x47
popq %rcx
movq %r15, %rdi
callq 0x1429e
movq %rbx, %rdi
callq 0x122c0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_delete
void subtilis_hashtable_delete(subtilis_hashtable_t *h)
{
	size_t i;

	if (!h)
		return;

	if (h->buckets) {
		for (i = 0; i < h->num_buckets; i++)
			prv_free_bucket(h, i);
		free(h->buckets);
	}
	free(h);
}

// Assembly:
testq %rdi, %rdi
je 0x2c6ff
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2c6f0
xorl %r14d, %r14d
cmpq 0x10(%rbx), %r14
jae 0x2c6e8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c700
incq %r14
jmp 0x2c6d2
movq (%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: prv_free_bucket
static void prv_free_bucket(subtilis_hashtable_t *h, size_t bucket)
{
	subtilis_hashtable_node_t *next;
	subtilis_hashtable_node_t *node = h->buckets[bucket];

	while (node) {
		next = node->next;
		if (h->free_key)
			h->free_key(node->key);
		if (h->free_value)
			h->free_value(node->value);
		free(node);
		node = next;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax,%rsi,8), %r14
testq %r14, %r14
je 0x2c742
movq (%r14), %r15
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2c726
movq 0x8(%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2c735
movq 0x10(%r14), %rdi
callq *%rax
movq %r14, %rdi
callq 0x122c0
movq %r15, %r14
jmp 0x2c70f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_find
void *subtilis_hashtable_find(subtilis_hashtable_t *h, const void *k)
{
	size_t hash = h->hash_func(h, k);
	subtilis_hashtable_node_t *n = prv_find_node(h, k, hash);

	if (!n)
		return NULL;

	return n->value;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq *0x18(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2c778
testq %rax, %rax
je 0x2c76e
movq 0x10(%rax), %rax
jmp 0x2c770
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_insert
bool subtilis_hashtable_insert(subtilis_hashtable_t *h, void *k, void *v,
			       subtilis_error_t *err)
{
	subtilis_hashtable_node_t *old_n;
	size_t hash = h->hash_func(h, k);
	subtilis_hashtable_node_t *n = prv_find_node(h, k, hash);

	if (n)
		return false;

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

	old_n = h->buckets[hash];
	n->key = k;
	n->value = v;
	n->next = old_n;
	h->buckets[hash] = n;
	h->elements++;

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq *0x18(%rdi)
movq %rax, %r13
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2c778
testq %rax, %rax
je 0x2c7df
xorl %eax, %eax
jmp 0x2c808
pushq $0x18
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x2c812
movq (%rbx), %rcx
movq (%rcx,%r13,8), %rdx
movq %r12, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %rdx, (%rax)
movq %rax, (%rcx,%r13,8)
incq 0x8(%rbx)
movb $0x1, %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x41a53(%rip), %rdx     # 0x6e26c
pushq $0x1
popq %rsi
movq %r15, %rdi
movl $0x81, %ecx
callq 0x1429e
jmp 0x2c7db
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_remove
bool subtilis_hashtable_remove(subtilis_hashtable_t *h, const void *k)
{
	subtilis_hashtable_node_t *n;
	subtilis_hashtable_node_t *old_n = NULL;
	size_t hash = h->hash_func(h, k);

	n = h->buckets[hash];
	while (n && !h->equal_func(k, n->key)) {
		old_n = n;
		n = n->next;
	}

	if (!n)
		return false;

	if (h->free_key)
		h->free_key(n->key);
	if (h->free_value)
		h->free_value(n->value);
	if (old_n)
		old_n->next = n->next;
	else
		h->buckets[hash] = n->next;
	free(n);

	h->elements--;

	return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
callq *0x18(%rdi)
movq %rax, %r15
shlq $0x3, %r15
movq (%rbx), %r14
addq %r15, %r14
xorl %ecx, %ecx
movq (%r14), %r14
testq %r14, %r14
je 0x2c8a4
movq %rcx, %r13
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq *0x20(%rbx)
movq %r14, %rcx
testb %al, %al
je 0x2c84c
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2c877
movq 0x8(%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2c886
movq 0x10(%r14), %rdi
callq *%rax
movq (%r14), %rax
testq %r13, %r13
jne 0x2c894
addq (%rbx), %r15
movq %r15, %r13
movq %rax, (%r13)
movq %r14, %rdi
callq 0x122c0
decq 0x8(%rbx)
testq %r14, %r14
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_extract
void *subtilis_hashtable_extract(subtilis_hashtable_t *h, const void *k)
{
	subtilis_hashtable_node_t *n;
	void *retval;
	subtilis_hashtable_node_t *old_n = NULL;
	size_t hash = h->hash_func(h, k);

	n = h->buckets[hash];
	while (n && !h->equal_func(k, n->key)) {
		old_n = n;
		n = n->next;
	}

	if (!n)
		return NULL;

	retval = n->value;
	if (h->free_key)
		h->free_key(n->key);
	if (old_n)
		old_n->next = n->next;
	else
		h->buckets[hash] = n->next;
	free(n);

	h->elements--;

	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
callq *0x18(%rdi)
movq %rax, %r12
shlq $0x3, %r12
movq (%rbx), %r15
addq %r12, %r15
xorl %r14d, %r14d
xorl %ecx, %ecx
movq (%r15), %r15
testq %r15, %r15
je 0x2c927
movq %rcx, %rbp
movq 0x8(%r15), %rsi
movq %r13, %rdi
callq *0x20(%rbx)
movq %r15, %rcx
testb %al, %al
je 0x2c8da
movq 0x10(%r15), %r14
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2c909
movq 0x8(%r15), %rdi
callq *%rax
movq (%r15), %rax
testq %rbp, %rbp
jne 0x2c917
addq (%rbx), %r12
movq %r12, %rbp
movq %rax, (%rbp)
movq %r15, %rdi
callq 0x122c0
decq 0x8(%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_reset
void subtilis_hashtable_reset(subtilis_hashtable_t *h)
{
	size_t i;

	for (i = 0; i < h->num_buckets; i++) {
		prv_free_bucket(h, i);
		h->buckets[i] = NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
cmpq 0x10(%rbx), %r14
jae 0x2c961
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c700
movq (%rbx), %rax
andq $0x0, (%rax,%r14,8)
incq %r14
jmp 0x2c943
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_perfection
size_t subtilis_hashtable_perfection(subtilis_hashtable_t *h)
{
	size_t i;
	subtilis_hashtable_node_t *n;
	size_t percentage;
	size_t list_count = 0;
	size_t duplicates = 0;

	if (h->elements == 0)
		return 100;

	for (i = 0; i < h->num_buckets; i++) {
		n = h->buckets[i];
		while (n) {
			++list_count;
			n = n->next;
		}

		if (list_count > 1)
			duplicates += list_count - 1;

		list_count = 0;
	}

	percentage = 100 - ((duplicates * 100) / h->elements);

	return percentage;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x2c9c9
movq 0x10(%rdi), %rax
xorl %edx, %edx
pushq $-0x1
popq %rsi
pushq $0x1
popq %r8
xorl %r9d, %r9d
cmpq %rax, %rdx
je 0x2c9b6
leaq (,%rdx,8), %r11
addq (%rdi), %r11
decq %r9
movq %rsi, %r10
movq (%r11), %r11
incq %r9
incq %r10
testq %r11, %r11
jne 0x2c998
cmpq $0x1, %r10
cmovaeq %r8, %r10
subq %r10, %r9
incq %rdx
jmp 0x2c982
imulq $0x64, %r9, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
pushq $0x64
popq %rax
subq %rcx, %rax
retq
pushq $0x64
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_sdbm
size_t subtilis_hashtable_sdbm(subtilis_hashtable_t *h, const void *k)
{
	const char *ch;
	size_t hash = 0;

	for (ch = (const char *)k; *ch; ch++)
		hash = *ch + (hash << 6) + (hash << 16) - hash;

	return hash % h->num_buckets;
}

// Assembly:
xorl %eax, %eax
movsbq (%rsi), %rcx
testq %rcx, %rcx
je 0x2c9e7
imulq $0x1003f, %rax, %rax    # imm = 0x1003F
addq %rcx, %rax
incq %rsi
jmp 0x2c9cf
xorl %edx, %edx
divq 0x10(%rdi)
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_djb2
size_t subtilis_hashtable_djb2(subtilis_hashtable_t *h, const void *k)
{
	const char *ch;
	size_t hash = 5381;

	for (ch = (const char *)k; *ch; ch++)
		hash = ((hash << 5) + hash) + *ch;

	return hash % h->num_buckets;
}

// Assembly:
movl $0x1505, %eax           # imm = 0x1505
movsbq (%rsi), %rcx
testq %rcx, %rcx
je 0x2ca0b
imulq $0x21, %rax, %rax
addq %rcx, %rax
incq %rsi
jmp 0x2c9f6
xorl %edx, %edx
divq 0x10(%rdi)
movq %rdx, %rax
retq