LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_ir_parse_rules
void subtilis_ir_parse_rules(const subtilis_ir_rule_raw_t *raw,
			     subtilis_ir_rule_t *parsed, size_t count,
			     subtilis_error_t *err)
{
	size_t i;
	size_t j;
	const char *rule;

	for (i = 0; i < count; i++) {
		rule = raw[i].text;
		j = 0;
		while (
		    j < SUBTILIS_IR_MAX_MATCHES &&
		    (rule = prv_parse_match(rule, &parsed[i].matches[j], err)))
			j++;
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		if (j == 0) {
			subtilis_error_set_assertion_failed(err);
			return;
		}
		parsed[i].action = raw[i].action;
		parsed[i].matches_count = j;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x3a1a6
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x5, -0x30(%rbp)
movb %al, -0x39(%rbp)
jae 0x3a10d
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
imulq $0x150, -0x28(%rbp), %rax # imm = 0x150
addq %rax, %rsi
movq -0x30(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x3a1b0
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3a116
jmp 0x3a124
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3a0cc
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3a12f
jmp 0x3a1a6
cmpq $0x0, -0x30(%rbp)
jne 0x3a152
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x70cd2(%rip), %rdx     # 0xaae18
movl $0x60c, %ecx            # imm = 0x60C
callq 0x158e0
jmp 0x3a1a6
movq -0x8(%rbp), %rax
movq -0x28(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
imulq $0x150, -0x28(%rbp), %rdx # imm = 0x150
addq %rdx, %rax
movq %rcx, 0x148(%rax)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
imulq $0x150, -0x28(%rbp), %rdx # imm = 0x150
addq %rdx, %rax
movq %rcx, 0x140(%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x3a0a0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_ir_section_new
static subtilis_ir_section_t *prv_ir_section_new(subtilis_error_t *err)
{
	subtilis_ir_section_t *s = calloc(1, sizeof(*s));

	if (!s) {
		subtilis_error_set_oom(err);
		return NULL;
	}
	s->reg_counter = SUBTILIS_IR_REG_TEMP_START;
	s->ftype = SUBTILIS_BUILTINS_MAX;
	s->array_access = SIZE_MAX;
	s->cleanup_stack = SIZE_MAX;
	s->cleanup_stack_nop = SIZE_MAX;
	s->cleanup_stack_reg = SIZE_MAX;

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x1, %edi
movl $0xe8, %esi
callq 0x12130
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x3aa7a
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x703b2(%rip), %rdx     # 0xaae18
movl $0x141, %ecx            # imm = 0x141
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3aad5
movq -0x18(%rbp), %rax
movq $0x4, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x9, 0x40(%rax)
movq -0x18(%rbp), %rax
movq $-0x1, 0xb0(%rax)
movq -0x18(%rbp), %rax
movq $-0x1, 0xb8(%rax)
movq -0x18(%rbp), %rax
movq $-0x1, 0xc0(%rax)
movq -0x18(%rbp), %rax
movq $-0x1, 0xc8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_is_call
static bool prv_is_call(subtilis_ir_op_t *op)
{
	return (op->type == SUBTILIS_OP_CALL) ||
	       (op->type == SUBTILIS_OP_CALLI32) ||
	       (op->type == SUBTILIS_OP_CALLREAL) ||
	       (op->type == SUBTILIS_OP_CALL_PTR) ||
	       (op->type == SUBTILIS_OP_CALLI32_PTR) ||
	       (op->type == SUBTILIS_OP_CALLREAL_PTR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x2, (%rcx)
movb %al, -0x9(%rbp)
je 0x3ab3b
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x3, (%rcx)
movb %al, -0x9(%rbp)
je 0x3ab3b
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x4, (%rcx)
movb %al, -0x9(%rbp)
je 0x3ab3b
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x5, (%rcx)
movb %al, -0x9(%rbp)
je 0x3ab3b
movq -0x8(%rbp), %rcx
movb $0x1, %al
cmpl $0x6, (%rcx)
movb %al, -0x9(%rbp)
je 0x3ab3b
movq -0x8(%rbp), %rax
cmpl $0x7, (%rax)
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_dump_call
static void prv_dump_call(subtilis_op_type_t type, subtilis_ir_call_t *c)
{
	size_t i;

	printf("\t");
	if (type == SUBTILIS_OP_CALLI32 || type == SUBTILIS_OP_CALLI32_PTR)
		printf("r%zu = ", c->reg);
	else if (type == SUBTILIS_OP_CALLREAL ||
		 type == SUBTILIS_OP_CALLREAL_PTR)
		printf("f%zu = ", c->reg);
	if ((type == SUBTILIS_OP_CALL_PTR) ||
	    (type == SUBTILIS_OP_CALLI32_PTR) ||
	    (type == SUBTILIS_OP_CALLREAL_PTR))
		printf("call [%zu]", c->proc_id);
	else
		printf("call %zu", c->proc_id);

	if (c->arg_count > 0) {
		printf(" (");
		printf("%s%zu",
		       c->args[0].type == SUBTILIS_IR_REG_TYPE_REAL ? "f" : "r",
		       c->args[0].reg);
		for (i = 1; i < c->arg_count; i++)
			printf(", %s%zu",
			       c->args[i].type == SUBTILIS_IR_REG_TYPE_REAL
				   ? "f"
				   : "r",
			       c->args[i].reg);
		printf(")");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x7070f(%rip), %rdi     # 0xab275
movb $0x0, %al
callq 0x120f0
cmpl $0x3, -0x4(%rbp)
je 0x3ab79
cmpl $0x6, -0x4(%rbp)
jne 0x3ab91
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x706ef(%rip), %rdi     # 0xab277
movb $0x0, %al
callq 0x120f0
jmp 0x3abb5
cmpl $0x4, -0x4(%rbp)
je 0x3ab9d
cmpl $0x7, -0x4(%rbp)
jne 0x3abb3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x706d3(%rip), %rdi     # 0xab27f
movb $0x0, %al
callq 0x120f0
jmp 0x3abb5
cmpl $0x5, -0x4(%rbp)
je 0x3abc7
cmpl $0x6, -0x4(%rbp)
je 0x3abc7
cmpl $0x7, -0x4(%rbp)
jne 0x3abde
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x706b2(%rip), %rdi     # 0xab287
movb $0x0, %al
callq 0x120f0
jmp 0x3abf3
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0x706a6(%rip), %rdi     # 0xab292
movb $0x0, %al
callq 0x120f0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jbe 0x3acc4
leaq 0x70692(%rip), %rdi     # 0xab29b
movb $0x0, %al
callq 0x120f0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl (%rax), %ecx
leaq 0x73d97(%rip), %rsi     # 0xae9b8
leaq 0x72a99(%rip), %rax     # 0xad6c1
cmpl $0x1, %ecx
cmoveq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x7065e(%rip), %rdi     # 0xab2a0
movb $0x0, %al
callq 0x120f0
movq $0x1, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x3acb6
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %ecx
leaq 0x73d40(%rip), %rsi     # 0xae9b8
leaq 0x72a42(%rip), %rax     # 0xad6c1
cmpl $0x1, %ecx
cmoveq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
leaq 0x705fd(%rip), %rdi     # 0xab29e
movb $0x0, %al
callq 0x120f0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3ac51
leaq 0x6fe94(%rip), %rdi     # 0xaab51
movb $0x0, %al
callq 0x120f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x751b7(%rip), %rsi     # 0xb015e
callq 0x12140
cmpl $0x0, %eax
jne 0x3afc9
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x3b03c
callq 0x12030
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0x12220
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x3b00a
callq 0x12030
cmpl $0x0, (%rax)
jne 0x3b00a
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jbe 0x3b026
movq -0x18(%rbp), %rdi
movl $0xf, %esi
leaq 0x6fdfe(%rip), %rdx     # 0xaae18
movl $0x546, %ecx            # imm = 0x546
callq 0x158e0
jmp 0x3b03c
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x2, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x310(%rdx), %rcx
movb %al, -0x39(%rbp)
jae 0x3b5d8
movq -0x10(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3b5e1
jmp 0x3b5f1
jmp 0x3b5e3
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3b5a0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x310(%rcx), %rax
jne 0x3b675
cmpq $0x10, -0x30(%rbp)
jne 0x3b629
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x6f7ff(%rip), %rdx     # 0xaae18
movl $0x635, %ecx            # imm = 0x635
callq 0x158e0
movb $0x0, -0x1(%rbp)
jmp 0x3b69a
movq -0x10(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x310(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x310(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3b69a
movq -0x10(%rbp), %rax
addq $0x200, %rax            # imm = 0x200
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_process_floating_reg
static bool prv_process_floating_reg(subtilis_ir_match_state_t *state,
				     size_t instr_reg, size_t match_reg,
				     subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_match_pair_t *pair;

	for (i = 0; i < state->regs_count && state->regs[i].key != match_reg;
	     i++)
		;
	if (i == state->regs_count) {
		if (i == MAX_MATCH_WILDCARDS) {
			subtilis_error_set_assertion_failed(err);
			return false;
		}
		pair = &state->regs[i];
		pair->key = match_reg;
		pair->value = instr_reg;
		state->regs_count++;
		return true;
	}

	return state->regs[i].value == instr_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x300(%rdx), %rcx
movb %al, -0x39(%rbp)
jae 0x3b702
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3b70b
jmp 0x3b71b
jmp 0x3b70d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3b6d0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x300(%rcx), %rax
jne 0x3b799
cmpq $0x10, -0x30(%rbp)
jne 0x3b753
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x6f6d5(%rip), %rdx     # 0xaae18
movl $0x64e, %ecx            # imm = 0x64E
callq 0x158e0
movb $0x0, -0x1(%rbp)
jmp 0x3b7b8
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x300(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x300(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3b7b8
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: prv_process_floating_freg
static bool prv_process_floating_freg(subtilis_ir_match_state_t *state,
				      size_t instr_reg, size_t match_reg,
				      subtilis_error_t *err)
{
	size_t i;
	subtilis_ir_match_pair_t *pair;

	for (i = 0; i < state->fregs_count && state->fregs[i].key != match_reg;
	     i++)
		;
	if (i == state->fregs_count) {
		if (i == MAX_MATCH_WILDCARDS) {
			subtilis_error_set_assertion_failed(err);
			return false;
		}
		pair = &state->fregs[i];
		pair->key = match_reg;
		pair->value = instr_reg;
		state->fregs_count++;
		return true;
	}

	return state->fregs[i].value == instr_reg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x308(%rdx), %rcx
movb %al, -0x39(%rbp)
jae 0x3b828
movq -0x10(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
cmpq -0x20(%rbp), %rax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3b831
jmp 0x3b841
jmp 0x3b833
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x3b7f0
movq -0x30(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x308(%rcx), %rax
jne 0x3b8c5
cmpq $0x10, -0x30(%rbp)
jne 0x3b879
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x6f5af(%rip), %rdx     # 0xaae18
movl $0x667, %ecx            # imm = 0x667
callq 0x158e0
movb $0x0, -0x1(%rbp)
jmp 0x3b8ea
movq -0x10(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x308(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x308(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x3b8ea
movq -0x10(%rbp), %rax
addq $0x100, %rax            # imm = 0x100
movq -0x30(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl $0x38, %edi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3b937
jmp 0x3b9ad
movq -0x10(%rbp), %rdi
movl $0x8, %esi
callq 0x12130
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x3b95b
jmp 0x3b9ad
movq -0x10(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3b9d8
movq -0x38(%rbp), %rdi
movl $0x1, %esi
leaq 0x6f943(%rip), %rdx     # 0xab300
movl $0x47, %ecx
callq 0x158e0
movq -0x40(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3ba05
jmp 0x3ba55
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3ba4c
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3ba40
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ba60
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3ba17
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3bae2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3bab2
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3bacf
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rdi
callq 0x12290
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x3ba83
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3bb60
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x3bb3c
movq $0x0, -0x8(%rbp)
jmp 0x3bb48
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/hash_table.c
// Function: prv_find_node
static subtilis_hashtable_node_t *prv_find_node(subtilis_hashtable_t *h,
						const void *key, size_t hash)
{
	subtilis_hashtable_node_t *n;

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

	if (!n)
		return NULL;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x3bbae
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x3bbb7
jmp 0x3bbc4
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x3bb87
cmpq $0x0, -0x28(%rbp)
jne 0x3bbd5
movq $0x0, -0x8(%rbp)
jmp 0x3bbdd
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x3bb60
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0x3bc43
movb $0x0, -0x1(%rbp)
jmp 0x3bcd5
movl $0x18, %edi
callq 0x121b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3bc78
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x6f698(%rip), %rdx     # 0xab300
movl $0x81, %ecx
callq 0x158e0
movb $0x0, -0x1(%rbp)
jmp 0x3bcd5
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x30(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x31(%rbp)
je 0x3bd48
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x3bd51
jmp 0x3bd66
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3bd21
cmpq $0x0, -0x20(%rbp)
jne 0x3bd76
movb $0x0, -0x1(%rbp)
jmp 0x3bdfa
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3bd93
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x3bdb0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
cmpq $0x0, -0x28(%rbp)
je 0x3bdc7
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3bddd
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x39(%rbp)
je 0x3be78
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rsi
callq *%rax
xorb $-0x1, %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3be81
jmp 0x3be96
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3be51
cmpq $0x0, -0x20(%rbp)
jne 0x3bea7
movq $0x0, -0x8(%rbp)
jmp 0x3bf1e
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x3bed0
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rdi
callq *%rax
cmpq $0x0, -0x30(%rbp)
je 0x3bee7
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
jmp 0x3befd
movq -0x20(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x38(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/hash_table.c
// Function: subtilis_hashtable_reset
void subtilis_hashtable_reset(subtilis_hashtable_t *h)
{
	size_t i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3bf80
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3ba60
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3bf44
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3bfc0
movq $0x64, -0x8(%rbp)
jmp 0x3c05c
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x3c036
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x3c009
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x3bfe9
cmpq $0x1, -0x30(%rbp)
jbe 0x3c020
movq -0x30(%rbp), %rax
subq $0x1, %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3bfc8
imulq $0x64, -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
movq %rax, %rcx
movl $0x64, %eax
subq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3c0c9
movq -0x18(%rbp), %rax
movsbq (%rax), %rax
movq -0x20(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq -0x20(%rbp), %rcx
shlq $0x10, %rcx
addq %rcx, %rax
subq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3c08c
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1505, -0x20(%rbp)    # imm = 0x1505
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x3c12e
movq -0x20(%rbp), %rax
shlq $0x5, %rax
addq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movsbq (%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3c0fc
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %r9
movl $0x400, %edi            # imm = 0x400
leaq -0xbc(%rip), %rsi       # 0x3c0e0
leaq -0x53(%rip), %rdx       # 0x3c150
movq 0x97dc6(%rip), %rcx     # 0xd3f70
leaq 0xaf(%rip), %r8         # 0x3c260
callq 0x3b900
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3c1c5
jmp 0x3c241
movl $0x328, %edi            # imm = 0x328
movl $0x1, %esi
callq 0x12130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3c1fb
movq -0x10(%rbp), %rdi
movl $0x1, %esi
leaq 0x6f127(%rip), %rdx     # 0xab316
movl $0x31, %ecx
callq 0x158e0
jmp 0x3c241
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x300(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x308(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x310(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x318(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3c252
movq -0x18(%rbp), %rdi
callq 0x3b9f0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: prv_symbol_delete
static void prv_symbol_delete(void *s)
{
	subtilis_symbol_t *sym = s;

	if (!sym)
		return;

	subtilis_type_free(&sym->sub_t);
	subtilis_type_free(&sym->t);
	free(sym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x3c27d
jmp 0x3c2a3
movq -0x10(%rbp), %rdi
addq $0x150, %rdi            # imm = 0x150
callq 0x3e100
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x3e100
movq -0x10(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_delete
void subtilis_symbol_table_delete(subtilis_symbol_table_t *st)
{
	size_t i;

	if (!st)
		return;
	for (i = 0; i < SUBTILIS_SYMBOL_MAX_LEVELS; i++)
		free(st->levels[i].symbols);
	subtilis_hashtable_delete(st->h);
	free(st);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x3c2c5
jmp 0x3c310
movq $0x0, -0x10(%rbp)
cmpq $0x20, -0x10(%rbp)
jae 0x3c2f7
movq -0x8(%rbp), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3c2cd
movq -0x8(%rbp), %rax
movq 0x300(%rax), %rdi
callq 0x3b9f0
movq -0x8(%rbp), %rdi
callq 0x12290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_level_up
void subtilis_symbol_table_level_up(subtilis_symbol_table_t *st,
				    subtilis_lexer_t *l, subtilis_error_t *err)
{
	if (st->level >= SUBTILIS_SYMBOL_MAX_LEVELS) {
		subtilis_error_set_too_many_blocks(err, l->stream->name,
						   l->line);
		return;
	}

	st->level++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x20, 0x318(%rax)
jb 0x3c36e
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdx
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
movl $0x40, %esi
leaq 0x6efb5(%rip), %r8      # 0xab316
movl $0x66, %r9d
callq 0x15930
jmp 0x3c384
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x318(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_level_down
void subtilis_symbol_table_level_down(subtilis_symbol_table_t *st,
				      subtilis_error_t *err)
{
	size_t i;
	subtilis_symbol_level_t *level;

	if (st->level == 0) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	level = &st->levels[st->level];
	for (i = 0; i < level->size; i++)
		subtilis_symbol_table_remove(st, level->symbols[i]->key);
	level->size = 0;
	st->level--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x318(%rax)
jne 0x3c3ca
movq -0x10(%rbp), %rdi
movl $0xf, %esi
leaq 0x6ef58(%rip), %rdx     # 0xab316
movl $0x74, %ecx
callq 0x158e0
jmp 0x3c445
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rcx
imulq $0x18, 0x318(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x3c424
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x298(%rax), %rsi
callq 0x3c450
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x3c3e9
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x318(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x318(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_insert
const subtilis_symbol_t *
subtilis_symbol_table_insert(subtilis_symbol_table_t *st, const char *key,
			     const subtilis_type_t *id_type,
			     subtilis_error_t *err)
{
	size_t size;

	size = subtilis_type_if_size(id_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return prv_symbol_table_insert(st, key, id_type, NULL, size, st->level,
				       false, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x47420
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3c4bc
movq $0x0, -0x8(%rbp)
jmp 0x3c4f5
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0x318(%rax), %r9
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3c500
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_insert_no_rc
const subtilis_symbol_t *
subtilis_symbol_table_insert_no_rc(subtilis_symbol_table_t *st, const char *key,
				   const subtilis_type_t *id_type,
				   subtilis_error_t *err)
{
	size_t size;

	size = subtilis_type_if_size(id_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return prv_symbol_table_insert(st, key, id_type, NULL, size, st->level,
				       true, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x47420
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3c78c
movq $0x0, -0x8(%rbp)
jmp 0x3c7c2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %r8
movq -0x10(%rbp), %rax
movq 0x318(%rax), %r9
movq -0x28(%rbp), %rax
xorl %ecx, %ecx
movl $0x1, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3c500
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_create_local_buf
const subtilis_symbol_t *
subtilis_symbol_table_create_local_buf(subtilis_symbol_table_t *st, size_t size,
				       subtilis_error_t *err)
{
	char buf[64];

	/*
	 * Everything on the stack needs to be 32 bit word aligned.
	 */

	if (size & 3) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	/*
	 * Subtilis identifiers cannot start with a number so there'll be no
	 * clash here.
	 */

	sprintf(buf, "%zu", st->tmp_count++);
	return prv_symbol_table_insert(st, buf, &subtilis_type_local_buffer,
				       NULL, size, 0, false, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x3c816
movq -0x20(%rbp), %rdi
movl $0xf, %esi
leaq 0x6eb14(%rip), %rdx     # 0xab316
movl $0x10e, %ecx            # imm = 0x10E
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3c877
leaq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x320(%rax), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, 0x320(%rax)
leaq 0x6ea80(%rip), %rsi     # 0xab2ba
movb $0x0, %al
callq 0x12250
movq -0x10(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movq -0x18(%rbp), %r8
movq -0x20(%rbp), %rax
leaq 0x6f598(%rip), %rdx     # 0xabdf0
xorl %ecx, %ecx
movl %ecx, %r9d
xorl %ecx, %ecx
movq %r9, %rcx
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3c500
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_create_named_local_buf
const subtilis_symbol_t *
subtilis_symbol_table_create_named_local_buf(subtilis_symbol_table_t *st,
					     const char *name, size_t size,
					     subtilis_error_t *err)
{
	/*
	 * Everything on the stack needs to be 32 bit word aligned.
	 */

	if (size & 3) {
		subtilis_error_set_assertion_failed(err);
		return NULL;
	}

	return prv_symbol_table_insert(st, name, &subtilis_type_local_buffer,
				       NULL, size, 0, false, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
je 0x3c8da
movq -0x28(%rbp), %rdi
movl $0xf, %esi
leaq 0x6ea50(%rip), %rdx     # 0xab316
movl $0x126, %ecx            # imm = 0x126
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3c910
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %rax
leaq 0x6f4ff(%rip), %rdx     # 0xabdf0
xorl %ecx, %ecx
movl %ecx, %r9d
xorl %ecx, %ecx
movq %r9, %rcx
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3c500
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_insert_tmp
const subtilis_symbol_t *
subtilis_symbol_table_insert_tmp(subtilis_symbol_table_t *st,
				 const subtilis_type_t *id_type,
				 char **tmp_name, subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	char *name = NULL;
	char buf[64];

	/*
	 * Subtilis identifiers cannot start with a number so there'll be no
	 * clash here.
	 */

	sprintf(buf, "%zu", st->tmp_count++);
	if (tmp_name) {
		name = malloc(strlen(buf) + 1);
		if (!name) {
			subtilis_error_set_oom(err);
			return NULL;
		}
		strcpy(name, buf);
	}

	s = subtilis_symbol_table_insert(st, buf, id_type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		free(name);
		return NULL;
	}

	if (tmp_name)
		*tmp_name = name;

	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq $0x0, -0x38(%rbp)
leaq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x320(%rax), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, 0x320(%rax)
leaq 0x6e953(%rip), %rsi     # 0xab2ba
movb $0x0, %al
callq 0x12250
cmpq $0x0, -0x20(%rbp)
je 0x3c9c6
leaq -0x80(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x3c9b9
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x6e971(%rip), %rdx     # 0xab316
movl $0x140, %ecx            # imm = 0x140
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3ca15
movq -0x38(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x12060
movq -0x10(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x3c480
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3c9fb
movq -0x38(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
jmp 0x3ca15
cmpq $0x0, -0x20(%rbp)
je 0x3ca0d
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/symbol_table.c
// Function: subtilis_symbol_table_insert_type
void subtilis_symbol_table_insert_type(subtilis_symbol_table_t *st,
				       const char *name,
				       const subtilis_type_t *type,
				       subtilis_error_t *err)
{
	if (subtilis_hashtable_find(st->h, name)) {
		subtilis_error_set_type_already_defined(err);
		return;
	}
	(void)prv_symbol_table_insert(st, name, &subtilis_type_typedef, type, 0,
				      st->level, false, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x300(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3baf0
cmpq $0x0, %rax
je 0x3ca7e
movq -0x20(%rbp), %rdi
movl $0x68, %esi
leaq 0x6e8a4(%rip), %rdx     # 0xab316
movl $0x158, %ecx            # imm = 0x158
callq 0x158e0
jmp 0x3cab7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x318(%rax), %r9
movq -0x20(%rbp), %rax
leaq 0x6f498(%rip), %rdx     # 0xabf38
xorl %r8d, %r8d
xorl %r10d, %r10d
movl $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3c500
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)