LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
testq %rdi, %rdi
je 0x2be99
movq %rsi, %rbx
cmpq %rbx, (%rdi)
jbe 0x2be99
movq 0x10(%rdi), %r14
callq 0x122c0
movq %r14, %rdi
testq %r14, %r14
jne 0x2be81
jmp 0x2be9c
movq %rdi, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2bec5
cmpq %r12, (%rbx)
jae 0x2bee4
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x2bf01
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %rbx
jmp 0x2bf22
jbe 0x2bf1e
leaq 0x47ee3(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0xf, %esi
movl $0x133, %ecx            # imm = 0x133
callq 0x145f4
jmp 0x2bf22
leaq 0x47ec8(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0x1, %esi
movl $0x129, %ecx            # imm = 0x129
callq 0x145f4
xorl %ebx, %ebx
jmp 0x2bf22
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_O1/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 %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq %rax, 0x80(%rdi)
cmpq $0x0, 0x50(%rdi)
je 0x2bf93
movq %rsi, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bfb1
cmpl $0x0, (%r14)
jne 0x2bfab
movq 0x70(%rbx), %rax
movq (%rax,%r15,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
movq $0x0, (%rax,%r15,8)
incq %r15
cmpq 0x50(%rbx), %r15
jb 0x2bf51
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x70(%rbx), %rdi
callq 0x122c0
movq $0x0, 0x70(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2bfeb
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x8000(,%r15,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x2bff1
addq $0x1000, %r15           # imm = 0x1000
movq %r15, 0x38(%rbx)
movq %rax, 0x48(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x47dd8(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0x1, %esi
movl $0x159, %ecx            # imm = 0x159
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x70be3(%rip), %rdx     # 0x9cc10
movl 0x8(%rax,%rdx), %eax
leaq (%rax,%rax,2), %rax
leaq 0x47b44(%rip), %rdx     # 0x73b80
cmpq $0x0, (%rdx,%rax,8)
je 0x2c05e
movq %rdi, %r14
leaq (%rdx,%rax,8), %rax
movl 0x8(%rax), %eax
testl %eax, %eax
je 0x2c074
cmpl $0x1, %eax
jne 0x2c097
movl $0x20, %r12d
jmp 0x2c07a
leaq 0x47d6b(%rip), %rdx     # 0x73dd0
movq %rbx, %rdi
movl $0xf, %esi
movl $0x1c4, %ecx            # imm = 0x1C4
jmp 0x2c0ab
movl $0x18, %r12d
movq (%r14,%r12), %r15
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %r9
callq 0x2c0c2
cmpl $0x0, (%rbx)
jne 0x2c0b0
incq (%r14,%r12)
jmp 0x2c0b3
leaq 0x47d32(%rip), %rdx     # 0x73dd0
movq %rbx, %rdi
movl $0xf, %esi
movl $0x1cc, %ecx            # imm = 0x1CC
callq 0x145f4
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c0f1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c1c6
jmp 0x2c0fc
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2bfb1
cmpl $0x0, (%r12)
jne 0x2c17a
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2c13f
movl $0x0, (%rax)
movl %ebp, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2c166
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2c176
leaq 0x47c8a(%rip), %rdx     # 0x73dd0
movq %r12, %rdi
movl $0x1, %esi
movl $0x225, %ecx            # imm = 0x225
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
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_O1/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 0x2c200
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
leaq 0x8000(,%r15,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x2c206
addq $0x1000, %r15           # imm = 0x1000
movq %r15, 0x58(%rbx)
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x47bc3(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0x1, %esi
movl $0x16c, %ecx            # imm = 0x16C
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/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 0x2c259
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c1c6
jmp 0x2c264
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bfb1
cmpl $0x0, (%r14)
jne 0x2c2e9
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2c2ae
movl $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 0x2c2d5
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2c2e5
leaq 0x47b1b(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0x1, %esi
movl $0x24e, %ecx            # imm = 0x24E
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
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_O1/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 0x2c315
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c1c6
jmp 0x2c320
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bfb1
cmpl $0x0, (%r14)
je 0x2c330
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2c36f
movq %rax, %rcx
movl $0x0, (%rax)
movl $0x54, 0x8(%rax)
movq 0x30(%rbx), %rax
cmpb $0x1, 0x60(%rbx)
jne 0x2c38a
movq 0x50(%rbx), %rdx
movq 0x70(%rbx), %rsi
leaq 0x1(%rdx), %rdi
movq %rdi, 0x50(%rbx)
movq %rcx, (%rsi,%rdx,8)
jmp 0x2c328
leaq 0x47a5a(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0x1, %esi
movl $0x26f, %ecx            # imm = 0x26F
callq 0x145f4
jmp 0x2c326
movq 0x48(%rbx), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x30(%rbx)
movq %rcx, (%rdx,%rax,8)
jmp 0x2c328
// File: /workspace/github_c_makefile_star2_O1/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 0x2c3bc
leaq 0x47a26(%rip), %rdx     # 0x73dd0
movq %r8, %rdi
movl $0xf, %esi
movl $0x28b, %ecx            # imm = 0x28B
jmp 0x2c44a
leal -0x51(%rdx), %eax
cmpl $0x2, %eax
jb 0x2c3cf
leal -0x97(%rdx), %eax
cmpl $0x2, %eax
jae 0x2c3a3
cmpq %rsi, 0x30(%rdi)
jbe 0x2c420
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rsi
cmpl $0x0, (%rsi)
jne 0x2c436
cmpl $0x54, 0x8(%rsi)
jne 0x2c436
movl %edx, 0x8(%rsi)
xorl %eax, %eax
cmpl $0x51, %edx
sete %al
cmpl $0x98, %edx
leaq 0x18(,%rax,8), %rax
movl $0x20, %edx
cmovneq %rax, %rdx
movq (%rdi,%rdx), %rax
leaq 0x1(%rax), %r8
movq %r8, (%rdi,%rdx)
movq %rax, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
jmp 0x2c451
leaq 0x479a9(%rip), %rdx     # 0x73dd0
movq %r8, %rdi
movl $0xf, %esi
movl $0x290, %ecx            # imm = 0x290
jmp 0x2c44a
leaq 0x47993(%rip), %rdx     # 0x73dd0
movq %r8, %rdi
movl $0xf, %esi
movl $0x297, %ecx            # imm = 0x297
callq 0x145f4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %edi
movl $0x38, %esi
callq 0x12150
testq %rax, %rax
je 0x2c4a3
movq %rax, %rbx
movq %r14, %rdi
callq 0x2f1c4
movq %rax, 0x18(%rbx)
cmpl $0x0, (%r14)
jne 0x2c499
movq %r14, %rdi
callq 0x2ef08
movq %rax, 0x28(%rbx)
cmpl $0x0, (%r14)
je 0x2c4c7
movq %rbx, %rdi
callq 0x2c4cd
jmp 0x2c4bc
leaq 0x47926(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0x1, %esi
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x145f4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x20(%rbx)
jmp 0x2c4be
// File: /workspace/github_c_makefile_star2_O1/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 0x2c521
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2c4f8
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2c993
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x2c4e3
movq (%rbx), %rdi
callq 0x122c0
movq 0x18(%rbx), %rdi
callq 0x2f34d
movq 0x28(%rbx), %rdi
callq 0x2ef4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/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, %eax
movq %r8, %r10
movq %rcx, %r11
movq %rdx, %r8
movq 0x40(%rsp), %rbx
movq 0x38(%rsp), %r12
movl 0x30(%rsp), %r14d
movq 0x50(%rsp), %r15
movl $0x2, %edx
xorl %ecx, %ecx
movl $0x9, %r9d
pushq %r15
pushq 0x50(%rsp)
pushq %r14
pushq %rax
pushq %r10
pushq %r11
callq 0x2c570
addq $0x30, %rsp
cmpl $0x0, (%r15)
je 0x2c85e
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_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2c937
leaq 0x47514(%rip), %r14     # 0x73ddc
leaq 0x47527(%rip), %r15     # 0x73df6
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
cmpl $0x0, (%rax)
jne 0x2c92e
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
movq %r14, %rdi
je 0x2c8f1
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), %r13
movq 0x30(%r13), %rsi
movq 0x48(%r13), %rdi
callq 0x2cd16
movq 0x50(%r13), %rsi
movq 0x70(%r13), %rdi
callq 0x2cd16
movl $0xa, %edi
callq 0x12030
incq %r12
cmpq 0x8(%rbx), %r12
jb 0x2c8d2
leaq 0x47920(%rip), %rdi     # 0x7425e
callq 0x12080
movq 0x18(%rbx), %rdi
callq 0x2f3a8
movl $0xa, %edi
callq 0x12030
leaq 0x4791f(%rip), %rdi     # 0x7427c
callq 0x12080
movq 0x28(%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2efb1
// File: /workspace/github_c_makefile_star2_O1/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 0x2ca99
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2f7d2
cmpq $0x0, 0x30(%rbx)
je 0x2c9fc
xorl %r15d, %r15d
movq 0x48(%rbx), %rax
movq (%rax,%r15,8), %r14
movl (%r14), %eax
leal -0x2(%rax), %edx
movl $0x20, %ecx
cmpl $0x6, %edx
jb 0x2c9e2
cmpl $0x8, %eax
jne 0x2c9eb
movq 0x28(%r14), %rdi
callq 0x122c0
movl $0x30, %ecx
movq (%r14,%rcx), %rdi
callq 0x122c0
movq %r14, %rdi
callq 0x122c0
incq %r15
cmpq 0x30(%rbx), %r15
jb 0x2c9b7
movq 0x48(%rbx), %rdi
callq 0x122c0
cmpq $0x0, 0x50(%rbx)
je 0x2ca54
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
movq (%rax,%r15,8), %r14
movl (%r14), %eax
leal -0x2(%rax), %edx
movl $0x20, %ecx
cmpl $0x6, %edx
jb 0x2ca3a
cmpl $0x8, %eax
jne 0x2ca43
movq 0x28(%r14), %rdi
callq 0x122c0
movl $0x30, %ecx
movq (%r14,%rcx), %rdi
callq 0x122c0
movq %r14, %rdi
callq 0x122c0
incq %r15
cmpq 0x50(%rbx), %r15
jb 0x2ca0f
movq 0x70(%rbx), %rdi
callq 0x122c0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca77
movq 0x10(%rdi), %r14
callq 0x122c0
movq %r14, %rdi
testq %r14, %r14
jne 0x2ca66
movq 0xd8(%rbx), %rax
testq %rax, %rax
je 0x2ca8c
movq 0xd0(%rbx), %rdi
callq *%rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x60(%rdi)
jne 0x2d038
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2c1c6
jmp 0x2d043
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2bfb1
cmpl $0x0, (%r15)
jne 0x2d0ac
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2d07a
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2d098
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2d0a8
leaq 0x46d4f(%rip), %rdx     # 0x73dd0
movq %r15, %rdi
movl $0x1, %esi
movl $0x478, %ecx            # imm = 0x478
popq %rbx
popq %r14
popq %r15
jmp 0x145f4
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_O1/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
movq $-0x1, %r15
movl $0x9b, %esi
movq $-0x1, %rdx
xorl %ecx, %ecx
movq %r12, %r8
callq 0x2c00f
cmpl $0x0, (%r12)
jne 0x2d0fd
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_O1/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 0x2d154
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2c1c6
jmp 0x2d15f
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2bfb1
cmpl $0x0, (%rbp)
jne 0x2d1f8
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2d1bd
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 0x2d1e4
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2d1f4
leaq 0x46c0c(%rip), %rdx     # 0x73dd0
movq %rbp, %rdi
movl $0x1, %esi
movl $0x4c8, %ecx            # imm = 0x4C8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
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_O1/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, %r12
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x60(%rdi)
jne 0x2d249
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2c1c6
jmp 0x2d254
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2bfb1
cmpl $0x0, (%r12)
jne 0x2d2cb
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2d290
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r14, 0x20(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2d2b7
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2d2c7
leaq 0x46b39(%rip), %rdx     # 0x73dd0
movq %r12, %rdi
movl $0x1, %esi
movl $0x492, %ecx            # imm = 0x492
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x145f4
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_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x3, %esi
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2d21a
cmpl $0x0, (%r15)
jne 0x2d338
movzbl 0x60(%rbx), %eax
movl %eax, %ecx
shll $0x5, %ecx
leaq 0x48(%rbx), %rdx
leaq 0x70(%rbx), %rsi
testl %eax, %eax
cmovneq %rsi, %rdx
movq (%rdx), %rax
movq 0x30(%rcx,%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rax
movq 0x18(%rbx), %r14
leaq 0x1(%r14), %rcx
movq %rcx, 0x18(%rbx)
movq %r14, 0x18(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
xorl %r14d, %r14d
movl $0x4, %esi
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2d21a
cmpl $0x0, (%r15)
jne 0x2d39f
movzbl 0x60(%rbx), %eax
movl %eax, %ecx
shll $0x5, %ecx
leaq 0x48(%rbx), %rdx
leaq 0x70(%rbx), %rsi
testl %eax, %eax
cmovneq %rsi, %rdx
movq (%rdx), %rax
movq 0x30(%rcx,%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rax
movq 0x20(%rbx), %r14
leaq 0x1(%r14), %rcx
movq %rcx, 0x20(%rbx)
movq %r14, 0x18(%rax)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x6, %esi
movq %r14, %r9
callq 0x2d21a
cmpl $0x0, (%r14)
je 0x2d3e8
xorl %eax, %eax
jmp 0x2d41c
movzbl 0x60(%rbx), %eax
movl %eax, %ecx
shll $0x5, %ecx
leaq 0x48(%rbx), %rdx
leaq 0x70(%rbx), %rsi
testl %eax, %eax
cmovneq %rsi, %rdx
movq (%rdx), %rax
movq 0x30(%rcx,%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rcx
movq 0x18(%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, 0x18(%rbx)
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r8
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x7, %esi
movq %r14, %r9
callq 0x2d21a
cmpl $0x0, (%r14)
je 0x2d44e
xorl %eax, %eax
jmp 0x2d482
movzbl 0x60(%rbx), %eax
movl %eax, %ecx
shll $0x5, %ecx
leaq 0x48(%rbx), %rdx
leaq 0x70(%rbx), %rsi
testl %eax, %eax
cmovneq %rsi, %rdx
movq (%rdx), %rax
movq 0x30(%rcx,%rbx), %rcx
movq -0x8(%rax,%rcx,8), %rcx
movq 0x20(%rbx), %rax
leaq 0x1(%rax), %rdx
movq %rdx, 0x20(%rbx)
movq %rax, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
leaq 0x4ad52(%rip), %rsi     # 0x78cee
callq 0x12160
testl %eax, %eax
je 0x2e00f
callq 0x12040
movq %rax, %r12
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x12250
movq (%r13), %rcx
cmpb $0x0, (%rcx)
jne 0x2dfe9
cmpl $0x0, (%r12)
setne %cl
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
seta %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x2e01f
leaq 0x45de0(%rip), %rdx     # 0x73dd0
movq %r14, %rdi
movl $0xf, %esi
movl $0x546, %ecx            # imm = 0x546
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x145f4
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
jmp 0x2e029
movq %rax, (%rbx)
movl $0x2, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq 0x310(%rdi), %rax
testq %rax, %rax
je 0x2e064
leaq 0x200(%rdi), %r9
xorl %r8d, %r8d
cmpq %rdx, (%r9)
je 0x2e067
incq %r8
addq $0x10, %r9
cmpq %r8, %rax
jne 0x2e04e
movq %rax, %r8
jmp 0x2e067
xorl %r8d, %r8d
cmpq %rax, %r8
jne 0x2e08f
cmpq $0x10, %r8
jne 0x2e0a0
leaq 0x45d57(%rip), %rdx     # 0x73dd0
movq %rcx, %rdi
movl $0xf, %esi
movl $0x635, %ecx            # imm = 0x635
callq 0x145f4
xorl %eax, %eax
jmp 0x2e0c0
shlq $0x4, %r8
cmpq %rsi, 0x208(%rdi,%r8)
sete %al
jmp 0x2e0c0
shlq $0x4, %r8
movq %rdx, 0x200(%rdi,%r8)
movq %rsi, 0x208(%rdi,%r8)
incq %rax
movq %rax, 0x310(%rdi)
movb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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, %r12
movq %r8, (%rsp)
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0x38, %edi
callq 0x121d0
movq %rax, %rbx
testq %rax, %rax
je 0x2e12b
movl $0x8, %esi
movq %r14, %rdi
callq 0x12150
movq %rax, (%rbx)
testq %rax, %rax
je 0x2e12b
movq %r14, 0x10(%rbx)
movq $0x0, 0x8(%rbx)
movq %rbp, 0x18(%rbx)
movq %r13, 0x20(%rbx)
movq %r15, 0x28(%rbx)
movq (%rsp), %rax
movq %rax, 0x30(%rbx)
jmp 0x2e14e
leaq 0x4616a(%rip), %rdx     # 0x7429c
movq %r12, %rdi
movl $0x1, %esi
movl $0x47, %ecx
callq 0x145f4
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_O1/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 0x2e1a7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2e198
cmpq $0x0, 0x10(%rbx)
je 0x2e190
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e1a8
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x2e17c
movq (%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movq (%rax,%rsi,8), %r14
testq %r14, %r14
je 0x2e1ed
movq %rdi, %rbx
movq (%r14), %r15
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2e1ce
movq 0x8(%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2e1dd
movq 0x10(%r14), %rdi
callq *%rax
movq %r14, %rdi
callq 0x122c0
movq %r15, %r14
testq %r15, %r15
jne 0x2e1bc
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq *0x18(%rdi)
movq %rax, %r12
shlq $0x3, %r12
addq (%r15), %r12
xorl %r14d, %r14d
movq (%r12), %r12
testq %r12, %r12
je 0x2e239
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r15)
testb %al, %al
je 0x2e211
testq %r12, %r12
je 0x2e236
movq 0x10(%r12), %r14
jmp 0x2e239
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
callq *0x18(%rdi)
movq %rax, %r13
movq %rax, %rbp
shlq $0x3, %rbp
addq (%rbx), %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x2e28b
movq 0x8(%rbp), %rsi
movq %r12, %rdi
callq *0x20(%rbx)
testb %al, %al
je 0x2e26f
testq %rbp, %rbp
jne 0x2e2d1
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x2e2b8
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
jmp 0x2e2d3
leaq 0x45fdd(%rip), %rdx     # 0x7429c
movq %r15, %rdi
movl $0x1, %esi
movl $0x81, %ecx
callq 0x145f4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e35b
movq %rcx, %r13
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq *0x20(%rbx)
movq %r14, %rcx
testb %al, %al
je 0x2e303
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2e32e
movq 0x8(%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2e33d
movq 0x10(%r14), %rdi
callq *%rax
movq (%r14), %rax
testq %r13, %r13
jne 0x2e34b
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_O1/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 0x2e3de
movq %rcx, %rbp
movq 0x8(%r15), %rsi
movq %r13, %rdi
callq *0x20(%rbx)
movq %r15, %rcx
testb %al, %al
je 0x2e391
movq 0x10(%r15), %r14
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2e3c0
movq 0x8(%r15), %rdi
callq *%rax
movq (%r15), %rax
testq %rbp, %rbp
jne 0x2e3ce
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_O1/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:
cmpq $0x0, 0x10(%rdi)
je 0x2e427
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2e1a8
movq (%rbx), %rax
movq $0x0, (%rax,%r14,8)
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x2e401
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2e499
movq 0x10(%rdi), %rdx
testq %rdx, %rdx
je 0x2e49f
movq (%rdi), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
leaq (%rsi,%r8,8), %r10
imulq $0x64, %rdi, %rax
addq $-0x64, %rax
decq %rdi
movq $-0x1, %r9
movq (%r10), %r10
addq $0x64, %rax
incq %r9
incq %rdi
testq %r10, %r10
jne 0x2e458
cmpq $0x1, %r9
movl $0x1, %r10d
cmovbq %r9, %r10
subq %r10, %rdi
incq %r8
cmpq %rdx, %r8
jne 0x2e442
cmpq $0x1, %r9
movl $0x1, %edx
cmovbq %r9, %rdx
imulq $0x64, %rdx, %rdx
subq %rdx, %rax
jmp 0x2e4a1
movl $0x64, %eax
retq
xorl %eax, %eax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movl $0x64, %eax
subq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rsi), %cl
testb %cl, %cl
je 0x2e4d6
incq %rsi
xorl %eax, %eax
movsbq %cl, %rcx
imulq $0x1003f, %rax, %rax    # imm = 0x1003F
addq %rcx, %rax
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x2e4bd
jmp 0x2e4d8
xorl %eax, %eax
xorl %edx, %edx
divq 0x10(%rdi)
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movb (%rsi), %cl
testb %cl, %cl
je 0x2e50c
incq %rsi
movl $0x1505, %eax           # imm = 0x1505
movq %rax, %rdx
shlq $0x5, %rdx
addq %rax, %rdx
movsbq %cl, %rax
addq %rdx, %rax
movb (%rsi), %cl
incq %rsi
testb %cl, %cl
jne 0x2e4f0
jmp 0x2e511
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
divq 0x10(%rdi)
movq %rdx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_new
subtilis_symbol_table_t *subtilis_symbol_table_new(subtilis_error_t *err)
{
	subtilis_hashtable_t *h;
	subtilis_symbol_table_t *st;

	h = subtilis_hashtable_new(
	    SUBTILIS_CONFIG_ST_SIZE, subtilis_hashtable_djb2,
	    subtilis_hashtable_string_equal, free, prv_symbol_delete, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	st = calloc(sizeof(*st), 1);
	if (!st) {
		subtilis_error_set_oom(err);
		goto on_error;
	}
	st->h = h;
	st->allocated = 0;
	st->max_allocated = 0;
	st->level = 0;

	return st;

on_error:
	subtilis_hashtable_delete(h);

	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x54(%rip), %rsi       # 0x2e4e2
leaq -0x22(%rip), %rdx       # 0x2e51b
movq 0x77a2c(%rip), %rcx     # 0xa5f70
leaq 0x74(%rip), %r8         # 0x2e5bf
movl $0x400, %edi            # imm = 0x400
movq %rbx, %r9
callq 0x2e0c4
movq %rax, %r14
cmpl $0x0, (%rbx)
je 0x2e56c
movq %r14, %rdi
callq 0x2e160
xorl %eax, %eax
jmp 0x2e59c
movl $0x328, %edi            # imm = 0x328
movl $0x1, %esi
callq 0x12150
testq %rax, %rax
je 0x2e5a4
movq %r14, 0x300(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x308(%rax)
movq $0x0, 0x318(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x45d07(%rip), %rdx     # 0x742b2
movq %rbx, %rdi
movl $0x1, %esi
movl $0x31, %ecx
callq 0x145f4
jmp 0x2e560