LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_var_block
subtilis_exp_t *subtilis_exp_new_var_block(subtilis_parser_t *p,
					   const subtilis_type_t *type,
					   unsigned int mem_reg, size_t offset,
					   subtilis_error_t *err)
{
	subtilis_ir_operand_t op0;
	subtilis_ir_operand_t op1;
	subtilis_exp_t *e = calloc(1, sizeof(*e));

	if (!e) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	subtilis_type_init_copy(&e->type, type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		free(e);
		return NULL;
	}

	if (offset > 0) {
		op0.reg = mem_reg;
		op1.integer = offset;
		e->exp.ir_op.reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_ADDI_I32, op0, op1, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	} else {
		e->exp.ir_op.reg = mem_reg;
	}

	return e;

on_error:

	subtilis_exp_delete(e);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r13
movq %rdi, %r12
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2b6b6
movq %rax, %rbx
movq %rax, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x2f457
cmpl $0x0, (%r14)
je 0x2b6e3
movq %rbx, %rdi
callq 0x122c0
jmp 0x2b6cf
leaq 0x4845d(%rip), %rdx     # 0x73b1a
movq %r14, %rdi
movl $0x1, %esi
movl $0x1be, %ecx            # imm = 0x1BE
callq 0x145a4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edx
testq %r15, %r15
je 0x2b716
movq 0x48(%r12), %rdi
movl %r15d, %ecx
movl $0x9, %esi
movq %r14, %r8
callq 0x2bc8f
movq %rax, 0x148(%rbx)
cmpl $0x0, (%r14)
je 0x2b6d1
movq %rbx, %rdi
callq 0x2b166
jmp 0x2b6cf
movq %rdx, 0x148(%rbx)
jmp 0x2b6d1
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_int32
subtilis_exp_t *subtilis_exp_new_int32(int32_t integer, 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_INTEGER;
	e->exp.ir_op.integer = integer;

	return e;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
movq %rax, %rbx
testq %rax, %rax
je 0x2b7dd
movl $0x1, (%rbx)
movl %ebp, 0x148(%rbx)
jmp 0x2b7f6
leaq 0x48336(%rip), %rdx     # 0x73b1a
movq %r14, %rdi
movl $0x1, %esi
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x145a4
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
movq %rax, %rbx
testq %rax, %rax
je 0x2b830
movsd (%rsp), %xmm0
movsd %xmm0, 0x148(%rbx)
jmp 0x2b849
leaq 0x482e3(%rip), %rdx     # 0x73b1a
movq %r14, %rdi
movl $0x1, %esi
movl $0x201, %ecx            # imm = 0x201
callq 0x145a4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
movq %rax, %rbx
testq %rax, %rax
je 0x2b8c5
movq %rax, %r12
movl $0x3, (%rbx)
addq $0x148, %r12            # imm = 0x148
movq (%r15), %rsi
movq %r12, %rdi
callq 0x149f4
movq %r15, %rdi
callq 0x14b57
testq %rax, %rax
je 0x2b8de
movq 0x8(%r15), %r13
addq $0x18, %r13
movq %r15, %rdi
callq 0x14b57
movq %r12, %rdi
movq %r13, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x14ae8
jmp 0x2b8de
leaq 0x4824e(%rip), %rdx     # 0x73b1a
movq %r14, %rdi
movl $0x1, %esi
movl $0x210, %ecx            # imm = 0x210
callq 0x145a4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2b938
movq %rax, %rbx
movq %r12, 0x148(%rax)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2f457
cmpl $0x0, (%r14)
je 0x2b953
movq %rbx, %rdi
callq 0x2b166
jmp 0x2b951
leaq 0x481db(%rip), %rdx     # 0x73b1a
movq %r14, %rdi
movl $0x1, %esi
movl $0x222, %ecx            # imm = 0x222
callq 0x145a4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12150
testq %rax, %rax
je 0x2b9e5
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 0x2ba00
movl $0x8, (%rax)
movq %r12, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
movq %rax, 0x160(%rbx)
testq %rax, %rax
je 0x2ba07
movq %rax, %rdi
movq %r12, %rsi
callq 0x12070
movq %r15, 0x168(%rbx)
jmp 0x2ba2a
leaq 0x4812e(%rip), %rdx     # 0x73b1a
movq %r14, %rdi
movl $0x1, %esi
movl $0x236, %ecx            # imm = 0x236
callq 0x145a4
jmp 0x2ba28
movl $0x23e, %ecx            # imm = 0x23E
jmp 0x2ba0c
movl $0x244, %ecx            # imm = 0x244
leaq 0x48107(%rip), %rdx     # 0x73b1a
movq %r14, %rdi
movl $0x1, %esi
callq 0x145a4
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x2baf0
pushq %rbx
movq 0x10(%rdi), %rbx
callq 0x122c0
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2bade
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
je 0x2bb1e
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpq %rbx, (%rdi)
jbe 0x2bb15
movq 0x10(%rdi), %r14
callq 0x122c0
movq %r14, %rdi
testq %r14, %r14
jne 0x2bafd
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2bb20
xorl %edi, %edi
movq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bb42
cmpq %r12, (%rbx)
jae 0x2bb61
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x2bb7e
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq %rax, %rbx
jmp 0x2bb9f
jbe 0x2bb9b
leaq 0x48286(%rip), %rdx     # 0x73df0
movq %r14, %rdi
movl $0xf, %esi
movl $0x133, %ecx            # imm = 0x133
callq 0x145a4
jmp 0x2bb9f
leaq 0x4826b(%rip), %rdx     # 0x73df0
movq %r14, %rdi
movl $0x1, %esi
movl $0x129, %ecx            # imm = 0x129
callq 0x145a4
xorl %ebx, %ebx
jmp 0x2bb9f
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_O3/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 0x2bc10
movq %rsi, %r14
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bc31
cmpl $0x0, (%r14)
jne 0x2bc2b
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 0x2bbce
leaq 0x50(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x70(%rbx), %rdi
callq 0x122c0
movq $0x0, 0x70(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bc6b
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x8000(,%r15,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x2bc71
addq $0x1000, %r15           # imm = 0x1000
movq %r15, 0x38(%rbx)
movq %rax, 0x48(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x48178(%rip), %rdx     # 0x73df0
movq %r14, %rdi
movl $0x1, %esi
movl $0x159, %ecx            # imm = 0x159
popq %rbx
popq %r14
popq %r15
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x70f63(%rip), %rdx     # 0x9cc10
movl 0x8(%rax,%rdx), %eax
leaq (%rax,%rax,2), %rax
leaq 0x47ee4(%rip), %rdx     # 0x73ba0
cmpq $0x0, (%rdx,%rax,8)
je 0x2bcde
movq %rdi, %r14
leaq (%rdx,%rax,8), %rax
movl 0x8(%rax), %eax
testl %eax, %eax
je 0x2bcf4
cmpl $0x1, %eax
jne 0x2bd17
movl $0x20, %r12d
jmp 0x2bcfa
leaq 0x4810b(%rip), %rdx     # 0x73df0
movq %rbx, %rdi
movl $0xf, %esi
movl $0x1c4, %ecx            # imm = 0x1C4
jmp 0x2bd2b
movl $0x18, %r12d
movq (%r14,%r12), %r15
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %r9
callq 0x2bd42
cmpl $0x0, (%rbx)
jne 0x2bd30
incq (%r14,%r12)
jmp 0x2bd33
leaq 0x480d2(%rip), %rdx     # 0x73df0
movq %rbx, %rdi
movl $0xf, %esi
movl $0x1cc, %ecx            # imm = 0x1CC
callq 0x145a4
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2bd71
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2be46
jmp 0x2bd7c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2bc31
cmpl $0x0, (%r12)
jne 0x2bdfa
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2bdbf
movl $0x0, (%rax)
movl %ebp, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2bde6
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2bdf6
leaq 0x4802a(%rip), %rdx     # 0x73df0
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 0x145a4
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_O3/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 0x2be80
movq %rsi, %r14
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
leaq 0x8000(,%r15,8), %rsi
callq 0x12210
testq %rax, %rax
je 0x2be86
addq $0x1000, %r15           # imm = 0x1000
movq %r15, 0x58(%rbx)
movq %rax, 0x70(%rbx)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x47f63(%rip), %rdx     # 0x73df0
movq %r14, %rdi
movl $0x1, %esi
movl $0x16c, %ecx            # imm = 0x16C
popq %rbx
popq %r14
popq %r15
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x2bed9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2be46
jmp 0x2bee4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bc31
cmpl $0x0, (%r14)
jne 0x2bf69
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2bf2e
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 0x2bf55
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2bf65
leaq 0x47ebb(%rip), %rdx     # 0x73df0
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 0x145a4
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_O3/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 0x2bf95
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2be46
jmp 0x2bfa0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bc31
cmpl $0x0, (%r14)
je 0x2bfb0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2bfef
movq %rax, %rcx
movl $0x0, (%rax)
movl $0x54, 0x8(%rax)
movq 0x30(%rbx), %rax
cmpb $0x1, 0x60(%rbx)
jne 0x2c00a
movq 0x50(%rbx), %rdx
movq 0x70(%rbx), %rsi
leaq 0x1(%rdx), %rdi
movq %rdi, 0x50(%rbx)
movq %rcx, (%rsi,%rdx,8)
jmp 0x2bfa8
leaq 0x47dfa(%rip), %rdx     # 0x73df0
movq %r14, %rdi
movl $0x1, %esi
movl $0x26f, %ecx            # imm = 0x26F
callq 0x145a4
jmp 0x2bfa6
movq 0x48(%rbx), %rdx
leaq 0x1(%rax), %rsi
movq %rsi, 0x30(%rbx)
movq %rcx, (%rdx,%rax,8)
jmp 0x2bfa8
// File: /workspace/github_c_makefile_star2_O3/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 0x2c03c
leaq 0x47dc6(%rip), %rdx     # 0x73df0
movq %r8, %rdi
movl $0xf, %esi
movl $0x28b, %ecx            # imm = 0x28B
jmp 0x2c0ca
leal -0x51(%rdx), %eax
cmpl $0x2, %eax
jb 0x2c04f
leal -0x97(%rdx), %eax
cmpl $0x2, %eax
jae 0x2c023
cmpq %rsi, 0x30(%rdi)
jbe 0x2c0a0
movq 0x48(%rdi), %rax
movq (%rax,%rsi,8), %rsi
cmpl $0x0, (%rsi)
jne 0x2c0b6
cmpl $0x54, 0x8(%rsi)
jne 0x2c0b6
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 0x2c0d1
leaq 0x47d49(%rip), %rdx     # 0x73df0
movq %r8, %rdi
movl $0xf, %esi
movl $0x290, %ecx            # imm = 0x290
jmp 0x2c0ca
leaq 0x47d33(%rip), %rdx     # 0x73df0
movq %r8, %rdi
movl $0xf, %esi
movl $0x297, %ecx            # imm = 0x297
callq 0x145a4
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2c123
movq %rax, %rbx
movq %r14, %rdi
callq 0x2eec8
movq %rax, 0x18(%rbx)
cmpl $0x0, (%r14)
jne 0x2c119
movq %r14, %rdi
callq 0x2ebfc
movq %rax, 0x28(%rbx)
cmpl $0x0, (%r14)
je 0x2c147
movq %rbx, %rdi
callq 0x2c14d
jmp 0x2c13c
leaq 0x47cc6(%rip), %rdx     # 0x73df0
movq %r14, %rdi
movl $0x1, %esi
movl $0x2ad, %ecx            # imm = 0x2AD
callq 0x145a4
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r15, 0x20(%rbx)
jmp 0x2c13e
// File: /workspace/github_c_makefile_star2_O3/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 0x2c1a1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2c178
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2c638
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x2c163
movq (%rbx), %rdi
callq 0x122c0
movq 0x18(%rbx), %rdi
callq 0x2f052
movq 0x28(%rbx), %rdi
callq 0x2ec50
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2c5dc
leaq 0x47892(%rip), %r14     # 0x73dfc
leaq 0x478a5(%rip), %r15     # 0x73e16
xorl %r12d, %r12d
movq (%rbx), %rcx
movq (%rcx,%r12,8), %rcx
cmpl $0x0, (%rcx)
jne 0x2c5d4
movq 0x8(%rcx), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
movq %r14, %rdi
je 0x2c593
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 0x2c9bb
movq 0x50(%r13), %rsi
movq 0x70(%r13), %rdi
callq 0x2c9bb
movl $0xa, %edi
callq 0x12030
movq 0x8(%rbx), %rax
incq %r12
cmpq %rax, %r12
jb 0x2c574
leaq 0x47c9b(%rip), %rdi     # 0x7427e
callq 0x12080
movq 0x18(%rbx), %rdi
callq 0x2f0ad
movl $0xa, %edi
callq 0x12030
leaq 0x47c9a(%rip), %rdi     # 0x7429c
callq 0x12080
movq 0x28(%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2ecb2
// File: /workspace/github_c_makefile_star2_O3/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 0x2c73e
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x2f4fb
cmpq $0x0, 0x30(%rbx)
je 0x2c6a1
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 0x2c687
cmpl $0x8, %eax
jne 0x2c690
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 0x2c65c
movq 0x48(%rbx), %rdi
callq 0x122c0
cmpq $0x0, 0x50(%rbx)
je 0x2c6f9
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 0x2c6df
cmpl $0x8, %eax
jne 0x2c6e8
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 0x2c6b4
movq 0x70(%rbx), %rdi
callq 0x122c0
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x2c71c
movq 0x10(%rdi), %r14
callq 0x122c0
movq %r14, %rdi
testq %r14, %r14
jne 0x2c70b
movq 0xd8(%rbx), %rax
testq %rax, %rax
je 0x2c731
movq 0xd0(%rbx), %rdi
callq *%rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ccc7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2be46
jmp 0x2ccd2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2bc31
cmpl $0x0, (%r15)
jne 0x2cd3b
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2cd09
movl $0x1, (%rax)
movq %r14, 0x8(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2cd27
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2cd37
leaq 0x470e0(%rip), %rdx     # 0x73df0
movq %r15, %rdi
movl $0x1, %esi
movl $0x478, %ecx            # imm = 0x478
popq %rbx
popq %r14
popq %r15
jmp 0x145a4
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_O3/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 0x2bc8f
cmpl $0x0, (%r12)
jne 0x2cd8c
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_O3/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 0x2cde3
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2be46
jmp 0x2cdee
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x2bc31
cmpl $0x0, (%rbp)
jne 0x2ce87
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2ce4c
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 0x2ce73
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2ce83
leaq 0x46f9d(%rip), %rdx     # 0x73df0
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 0x145a4
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_O3/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 0x2ced8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2be46
jmp 0x2cee3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2bc31
cmpl $0x0, (%r12)
jne 0x2cf5a
movl $0x38, %edi
callq 0x121d0
testq %rax, %rax
je 0x2cf1f
movl %ebp, (%rax)
movq %r15, 0x8(%rax)
movq %r13, 0x10(%rax)
movq %r14, 0x20(%rax)
cmpb $0x1, 0x60(%rbx)
jne 0x2cf46
movq 0x50(%rbx), %rcx
movq 0x70(%rbx), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x50(%rbx)
jmp 0x2cf56
leaq 0x46eca(%rip), %rdx     # 0x73df0
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 0x145a4
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_O3/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 0x2cea9
cmpl $0x0, (%r15)
jne 0x2d02e
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_O3/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 0x2cea9
cmpl $0x0, (%r14)
je 0x2d077
xorl %eax, %eax
jmp 0x2d0ab
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_O3/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 0x2cea9
cmpl $0x0, (%r14)
je 0x2d0dd
xorl %eax, %eax
jmp 0x2d111
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_O3/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)
cmpb $0x2a, (%rdi)
jne 0x2dca8
cmpb $0x0, 0x1(%r15)
je 0x2dd12
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 0x2dcec
cmpl $0x0, (%r12)
setne %cl
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
seta %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x2dd22
leaq 0x460fd(%rip), %rdx     # 0x73df0
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 0x145a4
movq $0x0, (%rbx)
movl $0x0, 0x8(%rbx)
jmp 0x2dd2c
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_O3/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), %rax
movq 0x310(%rdi), %r8
xorl %r9d, %r9d
testq %r8, %r8
je 0x2dd67
movq %rax, %r10
cmpq %rdx, (%r10)
je 0x2dd67
incq %r9
addq $0x10, %r10
cmpq %r9, %r8
jne 0x2dd54
jmp 0x2dd6c
cmpq %r8, %r9
jne 0x2dd8f
cmpq $0x10, %r8
jne 0x2dd9d
leaq 0x46077(%rip), %rdx     # 0x73df0
movq %rcx, %rdi
movl $0xf, %esi
movl $0x635, %ecx            # imm = 0x635
callq 0x145a4
xorl %eax, %eax
jmp 0x2ddb9
shlq $0x4, %r9
cmpq %rsi, 0x8(%rax,%r9)
sete %al
jmp 0x2ddb9
movq %r8, %rcx
shlq $0x4, %rcx
movq %rdx, (%rax,%rcx)
movq %rsi, 0x8(%rax,%rcx)
incq %r8
movq %r8, 0x310(%rdi)
movb $0x1, %al
popq %rcx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x2de23
movl $0x8, %esi
movq %r14, %rdi
callq 0x12150
movq %rax, (%rbx)
testq %rax, %rax
je 0x2de23
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 0x2de46
leaq 0x46492(%rip), %rdx     # 0x742bc
movq %r12, %rdi
movl $0x1, %esi
movl $0x47, %ecx
callq 0x145a4
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_O3/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 0x2dea1
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2de92
cmpq $0x0, 0x10(%rbx)
je 0x2de8d
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2dea2
incq %r14
cmpq 0x10(%rbx), %r14
jb 0x2de76
movq (%rbx), %rdi
callq 0x122c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x122c0
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2dee7
movq %rdi, %rbx
movq (%r14), %r15
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2dec8
movq 0x8(%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2ded7
movq 0x10(%r14), %rdi
callq *%rax
movq %r14, %rdi
callq 0x122c0
movq %r15, %r14
testq %r15, %r15
jne 0x2deb6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r14
callq *0x18(%rdi)
movq %rax, %r12
shlq $0x3, %r12
addq (%r14), %r12
xorl %r15d, %r15d
movq (%r12), %r12
testq %r12, %r12
je 0x2df29
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq *0x20(%r14)
testb %al, %al
je 0x2df0b
movq 0x10(%r12), %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2df78
movq 0x8(%rbp), %rsi
movq %r12, %rdi
callq *0x20(%rbx)
testb %al, %al
je 0x2df5f
jmp 0x2dfbe
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x2dfa5
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 0x2dfc0
leaq 0x46310(%rip), %rdx     # 0x742bc
movq %r15, %rdi
movl $0x1, %esi
movl $0x81, %ecx
callq 0x145a4
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_O3/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 0x2e048
movq %rcx, %r13
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq *0x20(%rbx)
movq %r14, %rcx
testb %al, %al
je 0x2dff0
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x2e01b
movq 0x8(%r14), %rdi
callq *%rax
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x2e02a
movq 0x10(%r14), %rdi
callq *%rax
movq (%r14), %rax
testq %r13, %r13
jne 0x2e038
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