LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_proc_compound
static void prv_proc_compound(subtilis_parser_t *p, subtilis_token_t *t,
			      subtilis_error_t *err)
{
	unsigned int start;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
		    (t->tok.keyword.type == SUBTILIS_KEYWORD_ENDPROC))
			break;

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

	if (t->type == SUBTILIS_TOKEN_EOF)
		subtilis_error_set_compund_not_term(err, p->l->stream->name,
						    start);
	//	p->current->endproc = false;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x38(%rax), %ebp
movl (%r15), %eax
cmpl $0x1, %eax
je 0x1d7e1
testl %eax, %eax
jne 0x1d7e8
jmp 0x1d802
cmpl $0x28, 0x8(%r15)
je 0x1d7fe
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x150d5
cmpl $0x0, (%r14)
je 0x1d7d3
jmp 0x1d83e
testl %eax, %eax
jne 0x1d825
movq (%rbx), %rax
movq 0x30(%rax), %rdx
leaq 0x55e10(%rip), %r8      # 0x73620
movq %r14, %rdi
movl $0x1e, %esi
movl %ebp, %ecx
movl $0x3b0, %r9d            # imm = 0x3B0
callq 0x14618
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2be75
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_array_param_type
static void prv_process_array_param_type(subtilis_parser_t *p,
					 subtilis_token_t *t,
					 const subtilis_type_t *type,
					 subtilis_type_t *ptype,
					 subtilis_error_t *err)
{
	subtilis_exp_t *e;
	int32_t num_dims;
	size_t i;

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

	if (e->type.type != SUBTILIS_TYPE_CONST_INTEGER) {
		subtilis_exp_delete(e);
		subtilis_error_set_const_integer_expected(
		    err, p->l->stream->name, p->l->line);
		return;
	}
	num_dims = e->exp.ir_op.integer;
	subtilis_exp_delete(e);

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

	subtilis_type_if_array_of(type, ptype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ptype->params.array.num_dims = num_dims;
	for (i = 0; i < ptype->params.array.num_dims; i++)
		ptype->params.array.dims[i] = SUBTILIS_DYNAMIC_DIMENSION;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %r8, %rdx
callq 0x1ee69
cmpl $0x0, (%r14)
je 0x1d880
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, (%rax)
jne 0x1d8db
movl 0x148(%rax), %ebp
movq %rax, %rdi
callq 0x2b4c3
movq (%r12), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x1d871
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3610f
cmpl $0x0, (%r14)
jne 0x1d871
movl %ebp, 0x8(%rbx)
testl %ebp, %ebp
je 0x1d871
xorl %eax, %eax
movl $0xffffffff, 0xc(%rbx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb 0x1d8c5
jmp 0x1d871
movq %rax, %rdi
callq 0x2b4c3
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x55d2b(%rip), %r8      # 0x73620
movq %r14, %rdi
movl $0x43, %esi
movl $0x21e, %r9d            # imm = 0x21E
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14618
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_process_vector_param_type
static void prv_process_vector_param_type(subtilis_parser_t *p,
					  subtilis_token_t *t,
					  const subtilis_type_t *type,
					  subtilis_type_t *ptype,
					  subtilis_error_t *err)
{
	const char *tbuf;

	subtilis_lexer_get(p->l, t, 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_expected(err, "} ", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

	ptype->params.array.num_dims = 1;

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

	subtilis_type_if_vector_of(type, ptype, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	ptype->params.array.dims[0] = SUBTILIS_DYNAMIC_DIMENSION;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1d9d6
movq %r12, %rdi
callq 0x12ad0
cmpl $0x2, (%r12)
je 0x1d99f
movq %rax, %rbp
leaq 0x55cbe(%rip), %rsi     # 0x7361b
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x1d99f
movq (%r13), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x55ca4(%rip), %rax     # 0x73620
leaq 0x55c9a(%rip), %rdx     # 0x7361d
movq %rbx, %rdi
movl $0x1d, %esi
movq %rbp, %rcx
pushq $0x240                  # imm = 0x240
pushq %rax
callq 0x1442a
addq $0x18, %rsp
jmp 0x1d9da
movl $0x1, 0x8(%r14)
movq (%r13), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1d9d6
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x36164
cmpl $0x0, (%rbx)
jne 0x1d9d6
movl $0xffffffff, 0xc(%r14)  # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_compound.c
// Function: prv_local_array_ref
static void prv_local_array_ref(subtilis_parser_t *p, subtilis_token_t *t,
				const char *var_name,
				const subtilis_type_t *type,
				subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e;
	subtilis_type_t array_type;

	subtilis_lexer_get(p->l, t, 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_right_bkt_expected(
		    err, tbuf, p->l->stream->name, p->l->line);
		return;
	}

	subtilis_lexer_get(p->l, t, 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_exp_expected(err, "= ", p->l->stream->name,
						p->l->line);
		return;
	}

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

	subtilis_type_if_array_of(type, &array_type, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_parser_create_array_ref(p, var_name, &array_type, e, true,
					 err);
	subtilis_type_free(&array_type);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x1decc
addq $0x148, %rsp            # imm = 0x148
jmp 0x1df24
movq %r13, %rdi
callq 0x12ad0
movq %rax, %rbp
cmpl $0x2, (%r13)
jne 0x1def1
leaq 0x55c08(%rip), %rsi     # 0x73aed
movq %rbp, %rdi
callq 0x12160
testl %eax, %eax
je 0x1df2f
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5574b(%rip), %rax     # 0x7364e
leaq 0x55eeb(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x16, %esi
movq %rbp, %rdx
pushq $0x2e
pushq %rax
callq 0x1442a
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1dec3
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x1df64
leaq 0x556ac(%rip), %rsi     # 0x73604
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x1df90
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x556d8(%rip), %rax     # 0x7364e
leaq 0x5627d(%rip), %rdx     # 0x741fa
leaq 0x55e71(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x3a
jmp 0x1df17
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1eb88
cmpl $0x0, (%rbx)
jne 0x1dec3
movq %rax, %r13
movq %rsp, %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x3610f
cmpl $0x0, (%rbx)
jne 0x1dec3
movq %rsp, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq 0x17f38
movq %r12, %rdi
callq 0x2f843
jmp 0x1dec3
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_compound.c
// Function: prv_local_vector_ref
static void prv_local_vector_ref(subtilis_parser_t *p, subtilis_token_t *t,
				 const char *var_name,
				 const subtilis_type_t *type,
				 subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e;
	subtilis_type_t vector_type;

	subtilis_lexer_get(p->l, t, 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_expected(err, "}", tbuf, p->l->stream->name,
					    p->l->line);
		return;
	}

	subtilis_lexer_get(p->l, t, 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_exp_expected(err, "= ", p->l->stream->name,
						p->l->line);
		return;
	}

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

	subtilis_type_if_vector_of(type, &vector_type, err);
	if (err->type != SUBTILIS_ERROR_OK) {
		subtilis_exp_delete(e);
		return;
	}

	subtilis_parser_create_array_ref(p, var_name, &vector_type, e, true,
					 err);
	subtilis_type_free(&vector_type);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x1e024
addq $0x148, %rsp            # imm = 0x148
jmp 0x1e07c
movq %r13, %rdi
callq 0x12ad0
movq %rax, %rbp
cmpl $0x2, (%r13)
jne 0x1e049
leaq 0x555de(%rip), %rsi     # 0x7361b
movq %rbp, %rdi
callq 0x12160
testl %eax, %eax
je 0x1e087
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x555f3(%rip), %rax     # 0x7364e
leaq 0x555b9(%rip), %rdx     # 0x7361b
movq %rbx, %rdi
movl $0x1d, %esi
movq %rbp, %rcx
pushq $0x5b
pushq %rax
callq 0x1442a
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1e01b
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x1e0bc
leaq 0x55554(%rip), %rsi     # 0x73604
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x1e0e8
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x55580(%rip), %rax     # 0x7364e
leaq 0x56125(%rip), %rdx     # 0x741fa
leaq 0x55d19(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x67
jmp 0x1e06f
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1eb88
cmpl $0x0, (%rbx)
jne 0x1e01b
movq %rax, %r13
movq %rsp, %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x36164
cmpl $0x0, (%rbx)
je 0x1e122
movq %r13, %rdi
callq 0x2b4c3
jmp 0x1e01b
movq %rsp, %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq 0x17f38
movq %r12, %rdi
callq 0x2f843
jmp 0x1e01b
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_compound.c
// Function: subtilis_parser_compound_at_sym_level
void subtilis_parser_compound_at_sym_level(subtilis_parser_t *p,
					   subtilis_token_t *t, int end_key,
					   subtilis_error_t *err)
{
	unsigned int start;
	subtilis_ir_operand_t var_reg;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		if ((t->type == SUBTILIS_TOKEN_KEYWORD) &&
		    (t->tok.keyword.type == end_key))
			break;
		subtilis_parser_statement(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}

	if (t->type == SUBTILIS_TOKEN_EOF)
		subtilis_error_set_compund_not_term(err, p->l->stream->name,
						    start);
	if ((end_key != SUBTILIS_KEYWORD_NEXT) &&
	    (end_key != SUBTILIS_KEYWORD_UNTIL) &&
	    (end_key != SUBTILIS_KEYWORD_ENDPROC))
		p->current->endproc = false;

	var_reg.reg = SUBTILIS_IR_REG_LOCAL;
	subtilis_reference_deallocate_refs(p, var_reg, p->local_st, p->level,
					   err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->level--;
	subtilis_symbol_table_level_down(p->local_st, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x38(%rax), %r15d
movl (%r12), %eax
cmpl $0x1, %eax
je 0x1e175
testl %eax, %eax
jne 0x1e17c
jmp 0x1e199
cmpl %ebp, 0x8(%r12)
je 0x1e195
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x150d5
cmpl $0x0, (%r14)
je 0x1e166
jmp 0x1e227
testl %eax, %eax
jne 0x1e1bd
movq (%rbx), %rax
movq 0x30(%rax), %rdx
leaq 0x554a7(%rip), %r8      # 0x7364e
movq %r14, %rdi
movl $0x1e, %esi
movl %r15d, %ecx
movl $0x117, %r9d            # imm = 0x117
callq 0x14618
cmpl $0x28, %ebp
je 0x1e1da
cmpl $0x51, %ebp
je 0x1e1da
cmpl $0x8b, %ebp
je 0x1e1da
movq 0x48(%rbx), %rax
movb $0x0, 0x88(%rax)
movq 0x68(%rbx), %rdx
movq 0x78(%rbx), %rcx
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %r8
callq 0x4e94e
cmpl $0x0, (%r14)
jne 0x1e227
decq 0x78(%rbx)
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2e667
cmpl $0x0, (%r14)
jne 0x1e227
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2be75
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_compound.c
// Function: subtilis_parser_compound_statement_at_level
void subtilis_parser_compound_statement_at_level(subtilis_parser_t *p,
						 subtilis_token_t *t,
						 subtilis_error_t *err)
{
	subtilis_ir_operand_t var_reg;

	subtilis_symbol_table_level_up(p->local_st, p->l, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

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

	var_reg.reg = SUBTILIS_IR_REG_LOCAL;
	subtilis_reference_deallocate_refs(p, var_reg, p->local_st, p->level,
					   err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	p->level--;
	subtilis_symbol_table_level_down(p->local_st, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;
	p->current->handler_list =
	    subtilis_handler_list_truncate(p->current->handler_list, p->level);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rsi
movq 0x68(%rdi), %rdi
callq 0x2e62b
cmpl $0x0, (%r14)
jne 0x1e2fc
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x150d5
cmpl $0x0, (%r14)
jne 0x1e2fc
movq 0x68(%rbx), %rdx
movq 0x78(%rbx), %rcx
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %r8
callq 0x4e94e
cmpl $0x0, (%r14)
jne 0x1e2fc
decq 0x78(%rbx)
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2e667
cmpl $0x0, (%r14)
jne 0x1e2fc
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2be75
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_cond.c
// Function: subtilis_parser_conditional_exp
subtilis_exp_t *subtilis_parser_conditional_exp(subtilis_parser_t *p,
						subtilis_token_t *t,
						subtilis_ir_operand_t *cond,
						subtilis_error_t *err)
{
	subtilis_exp_t *e;
	size_t reg;

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

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

	if (e->type.type == SUBTILIS_TYPE_CONST_INTEGER) {
		reg = subtilis_ir_section_add_instr2(
		    p->current, SUBTILIS_OP_INSTR_MOVI_I32, e->exp.ir_op, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		cond->reg = reg;
	} else if (e->type.type == SUBTILIS_TYPE_INTEGER) {
		cond->reg = e->exp.ir_op.reg;
	} else {
		subtilis_error_set_integer_exp_expected(err, p->l->stream->name,
							p->l->line);
		goto cleanup;
	}

	return e;

cleanup:
	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %r12
movq %rcx, %rdx
callq 0x1eb88
cmpl $0x0, (%r15)
jne 0x1e39b
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x3691f
cmpl $0x0, (%r15)
jne 0x1e39b
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x5, %eax
je 0x1e36f
cmpl $0x1, %eax
jne 0x1e37b
movq 0x48(%r12), %rdi
movq 0x148(%rbx), %rdx
movl $0x1b, %esi
movq %r15, %rcx
callq 0x2c189
cmpl $0x0, (%r15)
jne 0x1e393
jmp 0x1e376
movq 0x148(%rbx), %rax
movq %rax, (%r14)
jmp 0x1e39d
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
movq %r15, %rdi
movl $0x1c, %esi
callq 0x145f4
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_exp_get_lvalue
bool subtilis_exp_get_lvalue(subtilis_parser_t *p, subtilis_token_t *t,
			     subtilis_ir_operand_t *op, subtilis_type_t *type,
			     subtilis_error_t *err)
{
	const subtilis_symbol_t *s;
	const char *tbuf;
	size_t mem_reg = SUBTILIS_IR_REG_LOCAL;

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

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

	s = subtilis_parser_get_symbol(p, tbuf, &mem_reg, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return false;

	return subtilis_exp_get_lvalue_with_sym(
	    p, t, &s->t, s->key, mem_reg, s->loc, op, type, s->is_reg, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movq $0x2, 0x8(%rsp)
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1e7dd
movq %r12, %rdi
callq 0x12ad0
cmpl $0x6, (%r12)
jne 0x1e7b8
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x1e7ed
cmpl $0x0, (%rbx)
jne 0x1e7dd
movq %rax, %rdx
addq $0x8, %rdx
movq 0x298(%rax), %rcx
movq 0x8(%rsp), %r8
movq (%rax), %r9
movzbl 0x2a8(%rax), %eax
movq %r13, %rdi
movq %r12, %rsi
pushq %rbx
pushq %rax
pushq %r15
pushq %r14
callq 0x1e560
addq $0x30, %rsp
jmp 0x1e7e3
movq (%r13), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x550e2(%rip), %r8      # 0x738ac
movq %rbx, %rdi
movl $0x67, %esi
movl $0xea, %r9d
callq 0x14618
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_get_symbol
const subtilis_symbol_t *subtilis_parser_get_symbol(subtilis_parser_t *p,
						    const char *var_name,
						    size_t *mem_reg,
						    subtilis_error_t *err)
{
	const subtilis_symbol_t *s;

	s = subtilis_symbol_table_lookup(p->local_st, var_name);
	if (s) {
		*mem_reg = SUBTILIS_IR_REG_LOCAL;
	} else {
		s = subtilis_symbol_table_lookup(p->st, var_name);
		if (!s) {
			subtilis_error_set_unknown_variable(
			    err, var_name, p->l->stream->name, p->l->line);
			return NULL;
		}
		*mem_reg = SUBTILIS_IR_REG_GLOBAL;
	}

	return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x68(%rdi), %rdi
callq 0x2eec8
testq %rax, %rax
je 0x1e816
movl $0x2, %ecx
jmp 0x1e82d
movq 0x60(%r12), %rdi
movq %r14, %rsi
callq 0x2eec8
testq %rax, %rax
je 0x1e83c
movl $0x1, %ecx
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5505d(%rip), %rax     # 0x738ac
leaq 0x5559f(%rip), %rcx     # 0x73df5
movq %r15, %rdi
movl $0x1b, %esi
movq %r14, %rdx
pushq $0x5c9                  # imm = 0x5C9
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %eax, %eax
jmp 0x1e830
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_priority7
subtilis_exp_t *subtilis_parser_priority7(subtilis_parser_t *p,
					  subtilis_token_t *t,
					  subtilis_error_t *err)
{
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;
	subtilis_exp_fn_t exp_fn;

	e1 = prv_priority6(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while (t->type == SUBTILIS_TOKEN_KEYWORD) {
		if (t->tok.keyword.type == SUBTILIS_KEYWORD_EOR)
			exp_fn = subtilis_type_if_eor;
		else if (t->tok.keyword.type == SUBTILIS_KEYWORD_OR)
			exp_fn = subtilis_type_if_or;
		else
			break;
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority6(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e1 = exp_fn(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_exp_delete(e2);
	subtilis_exp_delete(e1);
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1e927
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1e8bc
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1857b(%rip), %rbp     # 0x36e3e
cmpl $0x1, (%r15)
jne 0x1e8aa
movl 0x8(%r15), %eax
movq %rbp, %r13
cmpl $0x2d, %eax
je 0x1e8e1
cmpl $0x5a, %eax
jne 0x1e8aa
leaq 0x1851a(%rip), %r13     # 0x36dfb
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x1e896
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1e927
cmpl $0x0, (%r14)
jne 0x1e898
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%r13
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1e8c3
jmp 0x1e896
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority6
static subtilis_exp_t *prv_priority6(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_error_t *err)
{
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;

	e1 = prv_priority5(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while (t->type == SUBTILIS_TOKEN_KEYWORD &&
	       t->tok.keyword.type == SUBTILIS_KEYWORD_AND) {
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority5(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e1 = subtilis_type_if_and(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_exp_delete(e2);
	subtilis_exp_delete(e1);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x1fa15
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1e98f
cmpl $0x1, (%r15)
jne 0x1e9a3
cmpl $0x7, 0x8(%r15)
jne 0x1e9a3
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x1e98f
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fa15
cmpl $0x0, (%r14)
jne 0x1e991
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36db8
jmp 0x1e93d
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_call_1_arg_fn
subtilis_exp_t *subtilis_parser_call_1_arg_fn(subtilis_parser_t *p,
					      const char *name, size_t reg,
					      subtilis_builtin_type_t ftype,
					      subtilis_ir_reg_type_t ptype,
					      const subtilis_type_t *rtype,
					      bool check_errors,
					      subtilis_error_t *err)
/* clang-format on */
{
	subtilis_ir_arg_t *args = NULL;
	char *name_dup = NULL;

	args = malloc(sizeof(*args) * 1);
	if (!args) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	name_dup = malloc(strlen(name) + 1);
	if (!name_dup) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	strcpy(name_dup, name);

	args[0].type = ptype;
	args[0].reg = reg;

	return subtilis_exp_add_call(p, name_dup, ftype, NULL, args, rtype, 1,
				     check_errors, err);

cleanup:

	free(args);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %r13d
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x58(%rsp), %rbp
movl $0x18, %edi
callq 0x121d0
testq %rax, %rax
je 0x1ea46
movq %rax, %r15
movq %r14, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1ea61
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
callq 0x12070
movl %r13d, (%r15)
movq %rbx, 0x8(%r15)
subq $0x8, %rsp
movzbl 0x58(%rsp), %eax
movq %r12, %rdi
movq %rbp, %rsi
movl 0x14(%rsp), %edx
xorl %ecx, %ecx
movq %r15, %r8
movq 0x18(%rsp), %r9
pushq 0x60(%rsp)
pushq %rax
pushq $0x1
callq 0x2b507
addq $0x38, %rsp
jmp 0x1ea8a
leaq 0x54e5f(%rip), %rdx     # 0x738ac
movq %rbp, %rdi
movl $0x1, %esi
movl $0x345, %ecx            # imm = 0x345
callq 0x145f4
jmp 0x1ea84
leaq 0x54e44(%rip), %rdx     # 0x738ac
movq 0x58(%rsp), %rdi
movl $0x1, %esi
movl $0x34b, %ecx            # imm = 0x34B
callq 0x145f4
movq %r15, %rdi
callq 0x122c0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_call_2_arg_fn
subtilis_exp_t *subtilis_parser_call_2_arg_fn(subtilis_parser_t *p,
					      const char *name, size_t arg1,
					      size_t arg2,
					      subtilis_ir_reg_type_t ptype1,
					      subtilis_ir_reg_type_t ptype2,
					      const subtilis_type_t *rtype,
					      bool check_errors,
					      subtilis_error_t *err)
/* clang-format on */

{
	subtilis_ir_arg_t *args = NULL;
	char *name_dup = NULL;

	args = malloc(sizeof(*args) * 2);
	if (!args) {
		subtilis_error_set_oom(err);
		return NULL;
	}

	name_dup = malloc(strlen(name) + 1);
	if (!name_dup) {
		subtilis_error_set_oom(err);
		goto cleanup;
	}
	strcpy(name_dup, name);

	args[0].type = ptype1;
	args[0].reg = arg1;
	args[1].type = ptype2;
	args[1].reg = arg2;

	return subtilis_exp_add_call(p, name_dup, SUBTILIS_BUILTINS_MAX, NULL,
				     args, rtype, 2, check_errors, err);

cleanup:

	free(args);

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, 0xc(%rsp)
movl %r8d, %r13d
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq 0x60(%rsp), %rbp
movl $0x30, %edi
callq 0x121d0
testq %rax, %rax
je 0x1eb39
movq %rax, %r14
movq %r15, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1eb54
movq %rax, %rbp
movq %rax, %rdi
movq %r15, %rsi
callq 0x12070
movl %r13d, (%r14)
movq %rbx, 0x8(%r14)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%r14)
movq %r12, 0x20(%r14)
subq $0x8, %rsp
movzbl 0x60(%rsp), %eax
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
movl $0x9, %edx
xorl %ecx, %ecx
movq %r14, %r8
movq 0x58(%rsp), %r9
pushq 0x68(%rsp)
pushq %rax
pushq $0x2
callq 0x2b507
addq $0x38, %rsp
jmp 0x1eb7d
leaq 0x54d6c(%rip), %rdx     # 0x738ac
movq %rbp, %rdi
movl $0x1, %esi
movl $0x36e, %ecx            # imm = 0x36E
callq 0x145f4
jmp 0x1eb77
leaq 0x54d51(%rip), %rdx     # 0x738ac
movq 0x60(%rsp), %rdi
movl $0x1, %esi
movl $0x374, %ecx            # imm = 0x374
callq 0x145f4
movq %r14, %rdi
callq 0x122c0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_int_var_expression
subtilis_exp_t *subtilis_parser_int_var_expression(subtilis_parser_t *p,
						   subtilis_token_t *t,
						   subtilis_error_t *err)
{
	subtilis_exp_t *e = NULL;

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

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

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

	return e;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x1e874
cmpl $0x0, (%rbx)
jne 0x1ec00
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
jne 0x1ebf8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x36269
cmpl $0x0, (%rbx)
je 0x1ec02
movq %rax, %rdi
callq 0x2b4c3
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_statement_int_args
void subtilis_parser_statement_int_args(subtilis_parser_t *p,
					subtilis_token_t *t, subtilis_exp_t **e,
					size_t expected, subtilis_error_t *err)
{
	size_t i;
	const char *tbuf;

	e[0] = subtilis_parser_int_var_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	for (i = 1; i < expected; i++) {
		tbuf = subtilis_token_get_text(t);
		if (t->type != SUBTILIS_TOKEN_OPERATOR) {
			subtilis_error_set_expected(
			    err, ",", tbuf, p->l->stream->name, p->l->line);
			return;
		}

		if (strcmp(tbuf, ",")) {
			subtilis_error_set_expected(
			    err, ",", tbuf, p->l->stream->name, p->l->line);
			return;
		}

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

		e[i] = subtilis_parser_int_var_expression(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			return;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r12
movq %r8, %rdx
callq 0x1ebbe
movq %r15, (%rsp)
movq %rax, (%r15)
cmpl $0x0, (%rbx)
setne %al
cmpq $0x2, %r14
setb %cl
orb %al, %cl
jne 0x1ecac
addq $-0x2, %r14
xorl %r15d, %r15d
movq %r13, %rdi
callq 0x12ad0
movq %rax, %rbp
cmpl $0x2, (%r13)
jne 0x1ecb2
movq %rbp, %rdi
leaq 0x54931(%rip), %rsi     # 0x73598
callq 0x12160
movq (%r12), %rdi
testl %eax, %eax
jne 0x1ecbd
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1ecac
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1ebbe
movq (%rsp), %rcx
movq %rax, 0x8(%rcx,%r15,8)
cmpl $0x0, (%rbx)
jne 0x1ecac
leaq 0x1(%r15), %rax
cmpq %r15, %r14
movq %rax, %r15
jne 0x1ec4b
addq $0x8, %rsp
jmp 0x1ecef
movq (%r12), %rdi
movl $0x3bb, %eax            # imm = 0x3BB
jmp 0x1ecc2
movl $0x3c1, %eax            # imm = 0x3C1
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x54bdb(%rip), %r10     # 0x738ac
leaq 0x548c0(%rip), %rdx     # 0x73598
movq %rbx, %rdi
movl $0x1d, %esi
movq %rbp, %rcx
pushq %rax
pushq %r10
callq 0x1442a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_bracketed_2_int_args
subtilis_exp_t *
subtilis_parser_bracketed_2_int_args(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_op_instr_type_t itype,
				     subtilis_error_t *err)
{
	subtilis_exp_t *e[2];
	size_t reg;
	size_t i;
	subtilis_exp_t *retval = NULL;

	memset(&e, 0, sizeof(e));

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

	reg = subtilis_ir_section_add_instr(p->current, itype, e[0]->exp.ir_op,
					    e[1]->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

	retval = subtilis_exp_new_int32_var(reg, err);

cleanup:

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

	return retval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1eda5
movq %r15, %rdi
callq 0x12ad0
leaq 0x554dd(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
movq (%r14), %rdi
testl %eax, %eax
je 0x1ed7a
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x54b59(%rip), %rax     # 0x738ac
leaq 0x54b68(%rip), %rdx     # 0x738c2
leaq 0x55094(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x3dc                  # imm = 0x3DC
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x1eda5
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1eda5
movq %rsp, %rdx
movl $0x2, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x1ec0a
cmpl $0x0, (%rbx)
je 0x1ee0c
cmpl $0x0, (%rbx)
je 0x1edae
xorl %ebx, %ebx
jmp 0x1edfe
movq 0x48(%r14), %rdi
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x148(%rax), %rdx
movq 0x148(%rcx), %rcx
movl %ebp, %esi
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
je 0x1eddc
xorl %ebx, %ebx
jmp 0x1ede9
movl %eax, %edi
movq %rbx, %rsi
callq 0x2ba99
movq %rax, %rbx
xorl %r14d, %r14d
movq (%rsp,%r14,8), %rdi
callq 0x2b4c3
incq %r14
cmpq $0x1, %r14
je 0x1edec
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x12ad0
leaq 0x54cd2(%rip), %rsi     # 0x73aed
movq %rax, %rdi
callq 0x12160
movq (%r14), %rdi
testl %eax, %eax
je 0x1ee59
movq 0x30(%rdi), %r8
movl 0x38(%rdi), %r9d
leaq 0x54a73(%rip), %rax     # 0x738ac
leaq 0x581ae(%rip), %rdx     # 0x76fee
leaq 0x54fae(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x3eb                  # imm = 0x3EB
jmp 0x1ed6e
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12eda
jmp 0x1eda5
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_bracketed_exp_internal
subtilis_exp_t *subtilis_parser_bracketed_exp_internal(subtilis_parser_t *p,
						       subtilis_token_t *t,
						       subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e;

	e = subtilis_parser_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return NULL;
	tbuf = subtilis_token_get_text(t);
	if ((t->type != SUBTILIS_TOKEN_OPERATOR) || strcmp(tbuf, ")")) {
		subtilis_exp_delete(e);
		subtilis_error_set_right_bkt_expected(
		    err, tbuf, p->l->stream->name, p->l->line);
		return NULL;
	}

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r15
callq 0x1eb88
cmpl $0x0, (%rbx)
jne 0x1eee8
movq %rax, %r14
movq %r13, %rdi
callq 0x12ad0
movq %rax, %r12
cmpl $0x2, (%r13)
jne 0x1eead
leaq 0x54c4c(%rip), %rsi     # 0x73aed
movq %r12, %rdi
callq 0x12160
testl %eax, %eax
je 0x1eeeb
movq %r14, %rdi
callq 0x2b4c3
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x549e5(%rip), %rax     # 0x738ac
leaq 0x54f27(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x16, %esi
movq %r12, %rdx
pushq $0x41f                  # imm = 0x41F
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_parser_bracketed_exp
subtilis_exp_t *subtilis_parser_bracketed_exp(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e = NULL;

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

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

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

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

	return e;

cleanup:

	subtilis_exp_delete(e);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1ef9f
movq %r14, %rdi
callq 0x12ad0
leaq 0x552e9(%rip), %rsi     # 0x74212
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x1ef6e
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x54965(%rip), %rax     # 0x738ac
leaq 0x54974(%rip), %rdx     # 0x738c2
leaq 0x54ea0(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x434                  # imm = 0x434
pushq %rax
callq 0x1442a
addq $0x10, %rsp
jmp 0x1ef9f
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ee69
cmpl $0x0, (%rbx)
jne 0x1ef9f
movq %rax, %r12
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12eda
cmpl $0x0, (%rbx)
je 0x1efa2
movq %r12, %rdi
callq 0x2b4c3
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_curly_bracketed_arg_have_b
subtilis_exp_t *subtilis_curly_bracketed_arg_have_b(subtilis_parser_t *p,
						    subtilis_token_t *t,
						    subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e;

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

	tbuf = subtilis_token_get_text(t);
	if ((t->type == SUBTILIS_TOKEN_OPERATOR) && !strcmp(tbuf, "}"))
		return NULL;

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

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

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

	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
callq 0x12eda
cmpl $0x0, (%rbx)
jne 0x1f5d8
movq %r15, %rdi
callq 0x12ad0
cmpl $0x2, (%r15)
jne 0x1f556
leaq 0x540d5(%rip), %rsi     # 0x7361b
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x1f5d8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1e874
cmpl $0x0, (%rbx)
jne 0x1f5d8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x3691f
cmpl $0x0, (%rbx)
jne 0x1f5d8
movq %rax, %r12
movq %r15, %rdi
callq 0x12ad0
movq %rax, %r15
leaq 0x5408a(%rip), %rsi     # 0x7361b
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x1f5db
movq %r12, %rdi
callq 0x2b4c3
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x542f5(%rip), %rax     # 0x738ac
leaq 0x5405f(%rip), %rdx     # 0x7361d
movq %rbx, %rdi
movl $0x1d, %esi
movq %r15, %rcx
pushq $0x546                  # imm = 0x546
pushq %rax
callq 0x1442a
addq $0x10, %rsp
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_complete_custom_type
void subtilis_complete_custom_type(subtilis_parser_t *p, const char *var_name,
				   subtilis_type_t *type, subtilis_error_t *err)
{
	const subtilis_symbol_t *f_s;
	const char *type_name;

	type_name = strchr(var_name, '@');
	if (!type_name) {
		subtilis_error_set_assertion_failed(err);
		return;
	}
	type_name++;

	f_s = subtilis_symbol_table_lookup(p->st, type_name);
	if (!f_s) {
		subtilis_error_set_unknown_type(err, type_name,
						p->l->stream->name, p->l->line);
		return;
	}

	if (f_s->t.type != SUBTILIS_TYPE_TYPEDEF) {
		subtilis_error_set_assertion_failed(err);
		return;
	}

	subtilis_type_copy(type, &f_s->sub_t, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r12
movq %rsi, %rdi
movl $0x40, %esi
callq 0x12100
testq %rax, %rax
je 0x1f846
movq %rax, %r15
incq %r15
movq 0x60(%r12), %rdi
movq %r15, %rsi
callq 0x2eec8
testq %rax, %rax
je 0x1f85c
cmpl $0x18, 0x8(%rax)
jne 0x1f898
addq $0x150, %rax            # imm = 0x150
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2fa5f
leaq 0x5405f(%rip), %rdx     # 0x738ac
movq %rbx, %rdi
movl $0xf, %esi
movl $0x5a7, %ecx            # imm = 0x5A7
jmp 0x1f8ac
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5403d(%rip), %rax     # 0x738ac
leaq 0x5457f(%rip), %rcx     # 0x73df5
movq %rbx, %rdi
movl $0x26, %esi
movq %r15, %rdx
pushq $0x5af                  # imm = 0x5AF
pushq %rax
callq 0x1442a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5400d(%rip), %rdx     # 0x738ac
movq %rbx, %rdi
movl $0xf, %esi
movl $0x5b4, %ecx            # imm = 0x5B4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x145f4
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_exp_swap_int32_mem
void subtilis_exp_swap_int32_mem(subtilis_parser_t *p, size_t dest_reg,
				 size_t source_reg, int32_t off,
				 subtilis_error_t *err)
{
	subtilis_ir_operand_t op2;
	subtilis_ir_operand_t tmp1;
	subtilis_ir_operand_t tmp2;
	subtilis_ir_operand_t d;
	subtilis_ir_operand_t s;

	d.reg = dest_reg;
	s.reg = source_reg;

	op2.integer = off;
	tmp1.reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I32, s, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tmp2.reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I32, d, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_I32, tmp1, d, op2, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_I32, tmp2, s, op2, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movl %ecx, %r15d
movl $0x12, %esi
movq %r15, %rcx
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x1f92f
movq %rax, %rbp
movq 0x48(%r12), %rdi
movl $0x12, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x1f92f
movq 0x48(%r12), %rdi
movl $0x17, %esi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbx, %r9
movq %rax, %r13
callq 0x2c0c2
cmpl $0x0, (%rbx)
je 0x1f93e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdx
movq 0x48(%r12), %rdi
movl $0x17, %esi
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c0c2
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: subtilis_exp_swap_int8_mem
void subtilis_exp_swap_int8_mem(subtilis_parser_t *p, size_t reg1, size_t reg2,
				int32_t off, subtilis_error_t *err)
{
	subtilis_ir_operand_t op1;
	subtilis_ir_operand_t op2;
	subtilis_ir_operand_t zero;
	subtilis_ir_operand_t tmp;
	subtilis_ir_operand_t tmp2;

	op1.reg = reg1;
	op2.reg = reg2;
	zero.integer = off;

	tmp.reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I8, op1, zero, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	tmp2.reg = subtilis_ir_section_add_instr(
	    p->current, SUBTILIS_OP_INSTR_LOADO_I8, op2, zero, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_I8, tmp, op2, zero, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_ir_section_add_instr_reg(
	    p->current, SUBTILIS_OP_INSTR_STOREO_I8, tmp2, op1, zero, err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r12
movq 0x48(%rdi), %rdi
movl %ecx, %r15d
movl $0x11, %esi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x1f9dd
movq %rax, %rbp
movq 0x48(%r12), %rdi
movl $0x11, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2c00f
cmpl $0x0, (%rbx)
jne 0x1f9dd
movq 0x48(%r12), %rdi
movl $0x16, %esi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbx, %r9
movq %rax, %r13
callq 0x2c0c2
cmpl $0x0, (%rbx)
je 0x1f9ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdx
movq 0x48(%r12), %rdi
movl $0x16, %esi
movq %r14, %rcx
movq %r15, %r8
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2c0c2
// File: /workspace/github_c_makefile_star2_O1/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority4
static subtilis_exp_t *prv_priority4(subtilis_parser_t *p, subtilis_token_t *t,
				     subtilis_error_t *err)
{
	const char *tbuf;
	subtilis_exp_t *e1 = NULL;
	subtilis_exp_t *e2 = NULL;
	subtilis_exp_fn_t exp_fn;

	e1 = prv_priority3(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	tbuf = subtilis_token_get_text(t);

	/*
	 * Special case for number too big.
	 */

	if ((t->type == SUBTILIS_TOKEN_INTEGER) &&
	    (t->tok.integer == -2147483648)) {
		subtilis_error_set_number_too_long(
		    err, tbuf, p->l->stream->name, p->l->line);
		goto cleanup;
	}

	while (t->type == SUBTILIS_TOKEN_OPERATOR) {
		tbuf = subtilis_token_get_text(t);
		if (!strcmp(tbuf, "+"))
			exp_fn = subtilis_exp_add;
		else if (!strcmp(tbuf, "-"))
			exp_fn = subtilis_type_if_sub;
		else
			break;
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority3(p, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;

		e1 = exp_fn(p, e1, e2, err);
		e2 = NULL;
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
	}

	return e1;

cleanup:

	subtilis_exp_delete(e2);
	subtilis_exp_delete(e1);
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
callq 0x1fcd9
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fbee
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b4c3
movq %rbx, %rdi
callq 0x2b4c3
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x12ad0
cmpl $0x4, (%r12)
jne 0x1fc3c
xorl %ecx, %ecx
cmpl 0x8(%r12), %ecx
jno 0x1fc3c
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x53c94(%rip), %r10     # 0x738ac
leaq 0x541d6(%rip), %rcx     # 0x73df5
movq %r14, %rdi
movl $0x8, %esi
movq %rax, %rdx
pushq $0x295                  # imm = 0x295
pushq %r10
callq 0x1442a
addq $0x10, %rsp
jmp 0x1fbcd
cmpl $0x2, (%r12)
jne 0x1fbe1
movq %r12, %rdi
callq 0x12ad0
movq %rax, %r13
leaq 0x53c80(%rip), %rsi     # 0x738d5
movq %rax, %rdi
callq 0x12160
testl %eax, %eax
je 0x1fc81
leaq 0x56dc1(%rip), %rsi     # 0x76a29
movq %r13, %rdi
callq 0x12160
testl %eax, %eax
jne 0x1fbe1
leaq 0x172a4(%rip), %r13     # 0x36f23
jmp 0x1fc88
leaq 0xc133(%rip), %r13      # 0x2bdbb
movq (%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x12eda
cmpl $0x0, (%r14)
jne 0x1fbcd
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1fcd9
cmpl $0x0, (%r14)
jne 0x1fbcf
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%r13
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1fc3c
jmp 0x1fbcd