LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_left_str_exp
subtilis_exp_t *subtilis_parser_left_str_exp(subtilis_parser_t *p,
					     subtilis_token_t *t,
					     subtilis_error_t *err)
{
	subtilis_exp_t *e[2];

	prv_left_right_args(p, t, e, 1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_string_type_left_exp(p, e[0], e[1], err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0x1, %ecx
callq 0x32760
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32731
movq $0x0, -0x8(%rbp)
jmp 0x3274a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x67c30
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/parser_string.c
// Function: prv_left_right_args
static void prv_left_right_args(subtilis_parser_t *p, subtilis_token_t *t,
				subtilis_exp_t **e, int32_t default_val,
				subtilis_error_t *err)
{
	size_t args;
	size_t i;
	const char *tbuf;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tbuf = subtilis_token_get_text(t);
	if (strcmp(tbuf, "(")) {
		subtilis_error_set_exp_expected(err, "( ", p->l->stream->name,
						p->l->line);
		return;
	}

	args = subtilis_var_bracketed_args_have_b(p, t, e, 2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (args == 0) {
		subtilis_error_set_string_expected(err, p->l->stream->name,
						   p->l->line);
		goto cleanup;
	}

	if (args == 1) {
		e[1] = subtilis_exp_new_int32(default_val, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return;

cleanup:

	for (i = 0; i < args; i++)
		subtilis_exp_delete(e[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3279d
jmp 0x328eb
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
leaq 0x78ae7(%rip), %rsi     # 0xab29c
callq 0x12140
cmpl $0x0, %eax
je 0x32809
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x15, %esi
leaq 0x7811d(%rip), %rdx     # 0xaa902
leaq 0x78a8a(%rip), %rcx     # 0xab276
leaq 0x7831d(%rip), %rax     # 0xaab10
movq %rax, (%rsp)
movl $0x6a, 0x8(%rsp)
callq 0x156d0
jmp 0x328eb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %r8
movl $0x2, %ecx
callq 0x255b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32835
jmp 0x328eb
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x133f0
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32854
jmp 0x328ba
cmpq $0x0, -0x30(%rbp)
jne 0x3288d
movq -0x28(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %ecx
movl $0x49, %esi
leaq 0x78290(%rip), %r8      # 0xaab10
movl $0x78, %r9d
callq 0x15930
jmp 0x328ba
cmpq $0x1, -0x30(%rbp)
jne 0x328b8
movl -0x1c(%rbp), %edi
movq -0x28(%rbp), %rsi
callq 0x37800
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x328b6
jmp 0x328ba
jmp 0x328b8
jmp 0x328eb
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x328eb
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x36ee0
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x328c2
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_string.c
// Function: subtilis_parser_right_str_exp
subtilis_exp_t *subtilis_parser_right_str_exp(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_error_t *err)
{
	subtilis_exp_t *e[2];

	prv_left_right_args(p, t, e, 1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	return subtilis_string_type_right_exp(p, e[0], e[1], err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x20(%rbp), %r8
movl $0x1, %ecx
callq 0x32760
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32941
movq $0x0, -0x8(%rbp)
jmp 0x3295a
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x68440
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/parser_string.c
// Function: subtilis_parser_left_str
void subtilis_parser_left_str(subtilis_parser_t *p, subtilis_token_t *t,
			      subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e[2];
	subtilis_exp_t *value;

	prv_left_right_args(p, t, e, -1, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_OPERATOR) || strcmp(tbuf, "=")) {
		subtilis_error_set_assignment_op_expected(
		    err, tbuf, p->l->stream->name, p->l->line);
		goto cleanup;
	}

	value = subtilis_parser_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	subtilis_string_type_left(p, e[0], e[1], value, err);
	return;

cleanup:
	subtilis_exp_delete(e[0]);
	subtilis_exp_delete(e[1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdx
movq -0x18(%rbp), %r8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x32760
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x32fcc
jmp 0x33088
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x32ff7
movq -0x20(%rbp), %rdi
leaq 0x77627(%rip), %rsi     # 0xaa614
callq 0x12140
cmpl $0x0, %eax
je 0x3303b
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x14, %esi
leaq 0x78255(%rip), %rcx     # 0xab276
leaq 0x77ae8(%rip), %rax     # 0xaab10
movq %rax, (%rsp)
movl $0x151, 0x8(%rsp)       # imm = 0x151
callq 0x156d0
jmp 0x33076
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x24a20
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3305b
jmp 0x33076
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %r8
callq 0x69650
jmp 0x33088
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq -0x28(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_rec.c
// Function: subtilis_parser_rec_init
void subtilis_parser_rec_init(subtilis_parser_t *p, subtilis_token_t *t,
			      const subtilis_type_t *type, const char *var_name,
			      bool local, bool push, subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	const char *tbuf;

	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	/*
	 * Special case here.  If we're creating a new local variable from a
	 * temporary REC returned from a function we can just promote the
	 * temporary and avoid the copy.
	 */

	tbuf = subtilis_token_get_text(t);
	if (local &&
	    !((t->type == SUBTILIS_TOKEN_OPERATOR) && !strcmp(tbuf, "("))) {
		prv_rec_init_check_tmp(p, t, type, var_name, push, err);
		return;
	}
	s = subtilis_symbol_table_insert(local ? p->local_st : p->st, var_name,
					 type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	prv_rec_init(p, t, type,
		     local ? SUBTILIS_IR_REG_LOCAL : SUBTILIS_IR_REG_GLOBAL,
		     s->loc, push, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %r8d, -0x54(%rbp)
movq %rcx, %rax
movl -0x54(%rbp), %ecx
movq %rax, -0x50(%rbp)
movq %rdx, %rax
movq -0x50(%rbp), %rdx
movq %rax, -0x48(%rbp)
movq %rsi, %rax
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq %rdi, %r8
movq -0x40(%rbp), %rdi
movb %r9b, %al
movq 0x10(%rbp), %r9
movq %r8, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %cl
movb %cl, -0x21(%rbp)
andb $0x1, %al
movb %al, -0x22(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq 0x10(%rbp), %rdx
callq 0x133f0
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x34e97
jmp 0x34f77
movq -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x38(%rbp)
testb $0x1, -0x21(%rbp)
je 0x34eef
movq -0x10(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x34ec8
movq -0x38(%rbp), %rdi
leaq 0x763de(%rip), %rsi     # 0xab29c
callq 0x12140
cmpl $0x0, %eax
je 0x34eef
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movb -0x22(%rbp), %al
movq 0x10(%rbp), %r9
andb $0x1, %al
movzbl %al, %r8d
callq 0x34f80
jmp 0x34f77
testb $0x1, -0x21(%rbp)
je 0x34f03
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0x34f0f
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq 0x10(%rbp), %rcx
callq 0x3c480
movq %rax, -0x30(%rbp)
movq 0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x34f33
jmp 0x34f77
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movb -0x21(%rbp), %r8b
movl $0x1, %eax
movl $0x2, %ecx
testb $0x1, %r8b
cmovnel %ecx, %eax
movslq %eax, %rcx
movq -0x30(%rbp), %rax
movq (%rax), %r8
movb -0x22(%rbp), %r9b
movq 0x10(%rbp), %rax
andb $0x1, %r9b
movzbl %r9b, %r9d
movq %rax, (%rsp)
callq 0x350e0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_rec.c
// Function: prv_rec_init_check_tmp
static void prv_rec_init_check_tmp(subtilis_parser_t *p, subtilis_token_t *t,
				   const subtilis_type_t *type,
				   const char *var_name, bool push,
				   subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	subtilis_exp_t *e = NULL;

	e = subtilis_parser_priority7(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	e = subtilis_type_if_coerce_type(p, e, type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	if (e->temporary) {
		(void)subtilis_symbol_table_promote_tmp(
		    p->local_st, type, e->temporary, var_name, err);
	} else {
		s = subtilis_symbol_table_insert(p->local_st, var_name, type,
						 err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		subtilis_rec_type_copy(p, type, SUBTILIS_IR_REG_LOCAL, s->loc,
				       e->exp.ir_op.reg, true, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		if (push && subtilis_type_rec_need_deref(type))
			subtilis_reference_type_push_reference(
			    p, type, SUBTILIS_IR_REG_LOCAL, s->loc, err);
	}

cleanup:
	subtilis_exp_delete(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq %r9, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x24550
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x34fcf
jmp 0x350d1
movq -0x8(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x4a2e0
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x34ff6
jmp 0x350c8
movq -0x40(%rbp), %rax
cmpq $0x0, 0x158(%rax)
je 0x3502d
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x40(%rbp), %rax
movq 0x158(%rax), %rdx
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x3cac0
jmp 0x350c6
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x3c480
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x35055
jmp 0x350c8
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x40(%rbp), %rax
movq 0x148(%rax), %r8
movq -0x30(%rbp), %rax
movl $0x2, %edx
movl $0x1, %r9d
movq %rax, (%rsp)
callq 0x62680
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x35092
jmp 0x350c8
testb $0x1, -0x21(%rbp)
je 0x350c4
movq -0x18(%rbp), %rdi
callq 0x3f560
testb $0x1, %al
jne 0x350a7
jmp 0x350c4
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rax
movq (%rax), %rcx
movq -0x30(%rbp), %r8
movl $0x2, %edx
callq 0x6d540
jmp 0x350c6
jmp 0x350c8
movq -0x40(%rbp), %rdi
callq 0x36ee0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_rec.c
// Function: subtilis_parser_rec_reset
void subtilis_parser_rec_reset(subtilis_parser_t *p, subtilis_token_t *t,
			       const subtilis_type_t *type, size_t mem_reg,
			       size_t loc, subtilis_error_t *err)
{
	subtilis_lexer_get(p->l, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	prv_rec_reset(p, t, type, mem_reg, loc, 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 %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x133f0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x356cf
jmp 0x356ec
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0x35700
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_rec.c
// Function: prv_check_id
static void prv_check_id(subtilis_parser_t *p, subtilis_token_t *t,
			 subtilis_type_t *field_type, subtilis_error_t *err)
{
	const char *tbuf;

	tbuf = subtilis_token_get_text(t);
	if (t->type != SUBTILIS_TOKEN_IDENTIFIER) {
		subtilis_error_set_id_expected(err, tbuf, p->l->stream->name,
					       p->l->line);
		return;
	}

	subtilis_type_init_copy(field_type, &t->tok.id_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if ((field_type->type == SUBTILIS_TYPE_FN) ||
	    (field_type->type == SUBTILIS_TYPE_REC)) {
		subtilis_complete_custom_type(p, tbuf, field_type, err);
		if (err->type != SUBTILIS_ERROR_OK)
			subtilis_type_free(field_type);
	}
}

// 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 -0x10(%rbp), %rdi
callq 0x12d70
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x6, (%rax)
je 0x360f2
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x30(%rax), %r8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x38(%rax), %r9d
movl $0x12, %esi
leaq 0x7519e(%rip), %rcx     # 0xab276
leaq 0x74a57(%rip), %rax     # 0xaab36
movq %rax, (%rsp)
movl $0x27, 0x8(%rsp)
callq 0x156d0
jmp 0x3614d
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
callq 0x3dec0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x36112
jmp 0x3614d
movq -0x18(%rbp), %rax
cmpl $0x9, (%rax)
je 0x36124
movq -0x18(%rbp), %rax
cmpl $0x16, (%rax)
jne 0x3614d
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x25e50
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3614b
movq -0x18(%rbp), %rdi
callq 0x3e100
jmp 0x3614d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/parser_rnd.c
// Function: prv_rnd_const
static subtilis_exp_t *prv_rnd_const(subtilis_parser_t *p, subtilis_exp_t *e,
				     subtilis_error_t *err)
{
	int32_t val = e->exp.ir_op.integer;

	subtilis_exp_delete(e);
	if (val == 0)
		return subtilis_builtins_ir_rnd_0(p, err);
	else if (val == 1)
		return subtilis_builtins_ir_rnd_1(p, err);
	else if (val < 0)
		return subtilis_builtins_ir_rnd_neg(p, val, err);
	else
		return subtilis_builtins_ir_rnd_pos(p, val, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x148(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36ee0
cmpl $0x0, -0x24(%rbp)
jne 0x366e3
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x404a0
movq %rax, -0x8(%rbp)
jmp 0x3672c
cmpl $0x1, -0x24(%rbp)
jne 0x366fc
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x405e0
movq %rax, -0x8(%rbp)
jmp 0x3672c
cmpl $0x0, -0x24(%rbp)
jge 0x36718
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x40900
movq %rax, -0x8(%rbp)
jmp 0x3672c
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x40760
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/expression.c
// Function: subtilis_exp_add_call_addrs
void subtilis_exp_add_call_addrs(subtilis_parser_t *p,
				 subtilis_parser_call_addr_t *call_addr,
				 subtilis_error_t *err)
{
	subtilis_parser_call_addr_t **new_call_addrs;
	size_t new_max;

	if (p->num_call_addrs == p->max_call_addrs) {
		new_max = p->max_call_addrs + SUBTILIS_CONFIG_PROC_GRAN;
		new_call_addrs =
		    realloc(p->call_addrs, new_max * sizeof(*new_call_addrs));
		if (!new_call_addrs) {
			subtilis_error_set_oom(err);
			return;
		}
		p->call_addrs = new_call_addrs;
		p->max_call_addrs = new_max;
	}
	p->call_addrs[p->num_call_addrs++] = call_addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0xa0(%rcx), %rax
jne 0x36bec
movq -0x8(%rbp), %rax
movq 0xa0(%rax), %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x36bce
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x73fa4(%rip), %rdx     # 0xaab66
movl $0x3b, %ecx
callq 0x158e0
jmp 0x36c18
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa8(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x98(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x98(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_return_default_value
void subtilis_exp_return_default_value(subtilis_parser_t *p,
				       subtilis_error_t *err)
{
	subtilis_ir_operand_t end_label;

	end_label.label = p->current->end_label;
	if ((p->current == p->main) ||
	    (p->current->type->type.params.fn.ret_val->type ==
	     SUBTILIS_TYPE_VOID)) {
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_JMP, end_label, err);
		return;
	}

	subtilis_type_if_zero_reg(p, p->current->type->type.params.fn.ret_val,
				  p->current->ret_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	subtilis_ir_section_add_instr_no_reg(p->current, SUBTILIS_OP_INSTR_JMP,
					     end_label, err);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x98(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x50(%rcx), %rax
je 0x36c6a
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x8, (%rax)
jne 0x36c86
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
jmp 0x36cd7
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0xa8(%rax), %rdx
movq -0x10(%rbp), %rcx
callq 0x47940
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0x36cbd
jmp 0x36cd7
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_delete
void subtilis_exp_delete(subtilis_exp_t *e)
{
	if (!e)
		return;
	if (e->type.type == SUBTILIS_TYPE_CONST_STRING)
		subtilis_buffer_free(&e->exp.str);
	subtilis_type_free(&e->type);
	free(e->partial_name);
	free(e->temporary);
	free(e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x36ef5
jmp 0x36f40
movq -0x8(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x36f0e
movq -0x8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x16650
movq -0x8(%rbp), %rdi
callq 0x3e100
movq -0x8(%rbp), %rax
movq 0x160(%rax), %rdi
callq 0x12290
movq -0x8(%rbp), %rax
movq 0x158(%rax), %rdi
callq 0x12290
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/expression.c
// Function: prv_tmp_ref_return
static void prv_tmp_ref_return(subtilis_parser_t *p,
			       const subtilis_type_t *fn_type,
			       subtilis_exp_t *e, subtilis_error_t *err)
{
	size_t reg;
	char *tmp_name = NULL;

	if (fn_type->type != SUBTILIS_TYPE_VOID &&
	    fn_type->type != SUBTILIS_TYPE_FN &&
	    !subtilis_type_if_is_numeric(fn_type)) {
		reg = prv_create_tmp_ref(p, e->exp.ir_op.reg, fn_type,
					 &tmp_name, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
		e->exp.ir_op.reg = reg;
		e->temporary = tmp_name;
	}
}

// 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 $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x8, (%rax)
je 0x3721c
movq -0x10(%rbp), %rax
cmpl $0x9, (%rax)
je 0x3721c
movq -0x10(%rbp), %rdi
callq 0x49d10
testb $0x1, %al
jne 0x3721c
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x148(%rax), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %r8
leaq -0x30(%rbp), %rcx
callq 0x37e30
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x371fe
jmp 0x3721c
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x30(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x158(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: prv_add_builtin
static void prv_add_builtin(subtilis_parser_t *p, char *name,
			    subtilis_builtin_type_t ftype,
			    subtilis_error_t *err)
{
	subtilis_type_section_t *ts;

	ts = subtilis_builtin_ts(ftype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	(void)subtilis_ir_prog_section_new(p->prog, name, 0, ts, ftype,
					   "builtin", 0, p->eflag_offset,
					   p->error_offset, NULL, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		if (err->type != SUBTILIS_ERROR_ALREADY_DEFINED)
			goto on_error;
		subtilis_error_init(err);
	}

	return;

on_error:

	subtilis_type_section_delete(ts);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
callq 0x3f990
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37262
jmp 0x372dd
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %r8d
movq -0x8(%rbp), %rax
movl 0xb0(%rax), %r11d
movq -0x8(%rbp), %rax
movl 0xb4(%rax), %r10d
movq -0x20(%rbp), %rax
xorl %edx, %edx
leaq 0x738e3(%rip), %r9      # 0xaab7c
movq $0x0, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0x38bd0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x372db
movq -0x20(%rbp), %rax
cmpl $0x20, (%rax)
je 0x372d2
jmp 0x372dd
movq -0x20(%rbp), %rdi
callq 0x15670
jmp 0x372e6
movq -0x28(%rbp), %rdi
callq 0x3e040
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: prv_add_call
static void prv_add_call(subtilis_parser_t *p, subtilis_parser_call_t *call,
			 subtilis_error_t *err)
{
	subtilis_parser_call_t **new_calls;
	size_t new_max;

	if (p->num_calls == p->max_calls) {
		new_max = p->max_calls + SUBTILIS_CONFIG_PROC_GRAN;
		new_calls = realloc(p->calls, new_max * sizeof(*new_calls));
		if (!new_calls) {
			subtilis_error_set_oom(err);
			return;
		}
		p->calls = new_calls;
		p->max_calls = new_max;
	}
	p->calls[p->num_calls++] = call;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x88(%rcx), %rax
jne 0x3738c
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0x121e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3736e
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x73804(%rip), %rdx     # 0xaab66
movl $0x26, %ecx
callq 0x158e0
jmp 0x373b8
movq -0x20(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x28(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x88(%rax)
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rax
movq -0x8(%rbp), %rsi
movq 0x80(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x80(%rsi)
movq %rdx, (%rax,%rcx,8)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_add_call_ptr
subtilis_exp_t *subtilis_exp_add_call_ptr(subtilis_parser_t *p,
					  subtilis_ir_arg_t *args,
					  const subtilis_type_t *fn_type,
					  size_t ptr, size_t num_params,
					  subtilis_error_t *err)
{
	size_t call_site;
	subtilis_exp_t *e = NULL;

	if (fn_type->type == SUBTILIS_TYPE_VOID)
		subtilis_ir_section_add_call_ptr(p->current, num_params, args,
						 ptr, err);
	else
		e = subtilis_type_if_call_ptr(p, fn_type, args, num_params, ptr,
					      err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;
	args = NULL;

	/* For calls made inside handlers we will add the offset from the start
	 * of the handler section and fix it up later on when checking the
	 * calls.
	 */

	call_site = p->current->in_error_handler ? p->current->error_len
						 : p->current->len;
	call_site--;

	subtilis_exp_handle_errors(p, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	prv_tmp_ref_return(p, fn_type, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	return e;

on_error:

	subtilis_exp_delete(e);
	free(args);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %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)
movq $0x0, -0x48(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x8, (%rax)
jne 0x37410
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %r8
callq 0x39f60
jmp 0x37431
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x38(%rbp), %r9
callq 0x49df0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3743f
jmp 0x374cd
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
testb $0x1, 0x60(%rax)
je 0x37467
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x50(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x37477
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x36ce0
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x374a3
jmp 0x374cd
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x37190
movq -0x38(%rbp), %rax
cmpl $0x0, (%rax)
je 0x374c3
jmp 0x374cd
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x374e7
movq -0x48(%rbp), %rdi
callq 0x36ee0
movq -0x18(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_empty
subtilis_exp_t *subtilis_exp_new_empty(const subtilis_type_t *type,
				       subtilis_error_t *err)
{
	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;
	}

	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3754e
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x7362c(%rip), %rdx     # 0xaab66
movl $0x18c, %ecx            # imm = 0x18C
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x37583
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3dec0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x3757b
movq -0x20(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
jmp 0x37583
movq -0x20(%rbp), %rax
movq %rax, -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/expression.c
// Function: subtilis_exp_new_var
subtilis_exp_t *subtilis_exp_new_var(const subtilis_type_t *type,
				     unsigned int reg, subtilis_error_t *err)
{
	subtilis_exp_t *e = subtilis_exp_new_empty(type, err);

	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;

	e->exp.ir_op.reg = reg;
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x37500
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x375c7
movq $0x0, -0x8(%rbp)
jmp 0x375df
movl -0x14(%rbp), %eax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_new_tmp_var
subtilis_exp_t *subtilis_exp_new_tmp_var(const subtilis_type_t *type,
					 unsigned int reg, char *tmp_name,
					 subtilis_error_t *err)
{
	subtilis_exp_t *e = subtilis_exp_new_var(type, reg, err);

	if (err->type != SUBTILIS_ERROR_OK) {
		free(tmp_name);
		return NULL;
	}

	e->temporary = tmp_name;
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
callq 0x37590
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37637
movq -0x20(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
jmp 0x3764e
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x158(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12130
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x376bc
movq -0x30(%rbp), %rdi
movl $0x1, %esi
leaq 0x734c1(%rip), %rdx     # 0xaab66
movl $0x1be, %ecx            # imm = 0x1BE
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x37762
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x3dec0
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x376e9
movq -0x48(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
jmp 0x37762
cmpq $0x0, -0x28(%rbp)
jbe 0x37737
movl -0x1c(%rbp), %eax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rcx
movl $0x9, %esi
callq 0x38230
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37735
jmp 0x37751
jmp 0x37747
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x48(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37762
movq -0x48(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3784d
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x7332d(%rip), %rdx     # 0xaab66
movl $0x1f3, %ecx            # imm = 0x1F3
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x3786c
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x148(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x378cf
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x732ab(%rip), %rdx     # 0xaab66
movl $0x201, %ecx            # imm = 0x201
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x378f2
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
movsd -0x10(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x148(%rax)
movq -0x20(%rbp), %rax
movq %rax, -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/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12130
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3794e
movq -0x18(%rbp), %rdi
movl $0x1, %esi
leaq 0x7322c(%rip), %rdx     # 0xaab66
movl $0x210, %ecx            # imm = 0x210
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x379c1
movq -0x20(%rbp), %rax
movl $0x3, (%rax)
movq -0x20(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x15f80
movq -0x10(%rbp), %rdi
callq 0x16270
cmpq $0x0, %rax
jbe 0x379b9
movq -0x20(%rbp), %rax
addq $0x148, %rax            # imm = 0x148
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x16270
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rdx
movq -0x18(%rbp), %rcx
callq 0x16200
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12130
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x37a22
movq -0x20(%rbp), %rdi
movl $0x1, %esi
leaq 0x73158(%rip), %rdx     # 0xaab66
movl $0x222, %ecx            # imm = 0x222
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x37a66
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3dec0
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37a5e
movq -0x28(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
jmp 0x37a66
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1, %edi
movl $0x170, %esi            # imm = 0x170
callq 0x12130
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x37ac9
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x730b4(%rip), %rdx     # 0xaab66
movl $0x236, %ecx            # imm = 0x236
callq 0x158e0
movq $0x0, -0x8(%rbp)
jmp 0x37bc6
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x148(%rax)
movq -0x30(%rbp), %rax
movl $0x9, (%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x10(%rax)
movl $0x148, %edi            # imm = 0x148
callq 0x121b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x37b2d
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x73048(%rip), %rdx     # 0xaab66
movl $0x23e, %ecx            # imm = 0x23E
callq 0x158e0
jmp 0x37bb5
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movl $0x8, (%rax)
movq -0x18(%rbp), %rdi
callq 0x120d0
movq %rax, %rdi
addq $0x1, %rdi
callq 0x121b0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x160(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x160(%rax)
jne 0x37b88
movq -0x28(%rbp), %rdi
movl $0x1, %esi
leaq 0x72fea(%rip), %rdx     # 0xaab66
movl $0x244, %ecx            # imm = 0x244
callq 0x158e0
jmp 0x37bb5
movq -0x30(%rbp), %rax
movq 0x160(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x12060
movq -0x20(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x168(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37bc6
movq -0x30(%rbp), %rdi
callq 0x36ee0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: subtilis_exp_generate_error
void subtilis_exp_generate_error(subtilis_parser_t *p, subtilis_exp_t *e,
				 subtilis_error_t *err)
{
	subtilis_ir_operand_t target_label;

	subtilis_var_assign_hidden(p, subtilis_err_hidden_var,
				   &subtilis_type_integer, e, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	if (p->current->in_error_handler) {
		/*
		 * We're in an error handler. Let's set the error flag and
		 * return the default value for the function type.
		 */

		subtilis_var_set_eflag(p, true, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		subtilis_exp_return_default_value(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	} else if (p->current->handler_list) {
		/*
		 * We're not in an error handler but one is defined.
		 * Let's jump there.
		 */

		target_label.label = p->current->handler_list->label;
		subtilis_ir_section_add_instr_no_reg(
		    p->current, SUBTILIS_OP_INSTR_JMP, target_label, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	} else {
		/*
		 * We're not in an error handler and none has been defined.
		 * Let's set the error flag and return the default value.
		 */

		subtilis_var_set_eflag(p, true, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;

		subtilis_exp_return_default_value(p, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x9cb11(%rip), %rax     # 0xd4840
movq (%rax), %rsi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq 0x73b8f(%rip), %rdx     # 0xab8d0
callq 0x47150
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37d54
jmp 0x37e25
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
testb $0x1, 0x60(%rax)
je 0x37da2
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x473b0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37d82
jmp 0x37e25
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36c20
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37d9d
jmp 0x37e25
jmp 0x37e25
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0x37dec
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x78(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
movl $0x45, %esi
callq 0x38540
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37dea
jmp 0x37e25
jmp 0x37e23
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
movl $0x1, %esi
callq 0x473b0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37e09
jmp 0x37e25
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x36c20
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37e21
jmp 0x37e25
jmp 0x37e23
jmp 0x37e25
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/frontend/expression.c
// Function: prv_create_tmp_ref
static size_t prv_create_tmp_ref(subtilis_parser_t *p, size_t reg,
				 const subtilis_type_t *fn_type,
				 char **tmp_name, subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	subtilis_ir_operand_t dest;
	subtilis_ir_operand_t op2;
	subtilis_ir_operand_t source;
	char *name;

	s = subtilis_symbol_table_insert_tmp(p->local_st, fn_type, &name, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return 0;
	dest.reg = SUBTILIS_IR_REG_LOCAL;
	op2.integer = s->loc;

	if (s->loc > 0) {
		dest.reg = subtilis_ir_section_add_instr(
		    p->current, SUBTILIS_OP_INSTR_ADDI_I32, dest, op2, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto on_error;
	}

	source.reg = reg;
	subtilis_type_if_copy_ret(p, fn_type, dest.reg, source.reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	*tmp_name = name;
	return dest.reg;

on_error:

	free(name);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rcx
leaq -0x58(%rbp), %rdx
callq 0x3c920
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37e7f
movq $0x0, -0x8(%rbp)
jmp 0x37f1c
movq $0x2, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x48(%rbp)
movq -0x38(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x37eca
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x30(%rbp), %r8
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %rcx
movl $0x9, %esi
callq 0x38230
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37ec8
jmp 0x37f0b
jmp 0x37eca
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x47690
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
je 0x37ef6
jmp 0x37f0b
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37f1c
movq -0x58(%rbp), %rdi
callq 0x12290
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_handler_list_free
void subtilis_handler_list_free(subtilis_handler_list_t *list)
{
	subtilis_handler_list_t *p;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x37f62
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12290
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37f3c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/markdryan[P]subtilis/common/ir.c
// Function: subtilis_handler_list_truncate
subtilis_handler_list_t *
subtilis_handler_list_truncate(subtilis_handler_list_t *list, size_t level)
{
	subtilis_handler_list_t *p;

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

	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x19(%rbp)
je 0x37f9d
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
setb %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x37fa6
jmp 0x37fc5
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x12290
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x37f80
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop