LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_parser_assembly
static void prv_parser_assembly(subtilis_parser_t *p, subtilis_token_t *t,
				const char *name,
				subtilis_type_section_t *stype,
				size_t *call_index, subtilis_error_t *err)
{
	subtilis_error_t err2;
	void *asm_code = NULL;

	subtilis_lexer_set_ass_keywords(p->l, true, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	asm_code = p->backend.asm_parse(p->l, t, p->backend.backend_data, stype,
					&p->settings, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_ir_prog_asm_section_new(
	    p->prog, name, stype, p->l->stream->name, p->l->line,
	    p->eflag_offset, p->error_offset, p->backend.asm_free, asm_code,
	    call_index, err);
	stype = NULL;
	if (err->type != SUBTILIS_ERROR_OK)
		goto on_error;

	subtilis_error_init(&err2);
	subtilis_lexer_set_ass_keywords(p->l, false, &err2);

	subtilis_lexer_get(p->l, t, err);
	return;

on_error:

	subtilis_type_section_delete(stype);

	subtilis_error_init(&err2);
	subtilis_lexer_set_ass_keywords(p->l, false, &err2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc18, %rsp            # imm = 0xC18
movq %r9, %r14
movq %r8, %r13
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %esi
movq %r9, %rdx
callq 0x12a77
cmpl $0x0, (%r14)
jne 0x1d623
movq (%rbx), %rdi
movq 0x40(%rbx), %rdx
leaq 0xb8(%rbx), %r8
movq %r15, %rsi
movq %r12, %rcx
movq %r14, %r9
callq *0x30(%rbx)
cmpl $0x0, (%r14)
jne 0x1d623
movq 0x58(%rbx), %rdi
movq (%rbx), %rdx
movq 0x30(%rdx), %rcx
movl 0x38(%rdx), %r8d
movl 0xb0(%rbx), %r9d
movl 0xb4(%rbx), %r10d
subq $0x8, %rsp
movq %rbp, %rsi
movq %r12, %rdx
pushq %r14
pushq %r13
pushq %rax
pushq 0x38(%rbx)
pushq %r10
callq 0x2c49a
addq $0x30, %rsp
cmpl $0x0, (%r14)
je 0x1d657
xorl %r12d, %r12d
movq %r12, %rdi
callq 0x2f4fb
leaq 0xc(%rsp), %r14
movq %r14, %rdi
callq 0x143b4
movq (%rbx), %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x12a77
addq $0xc18, %rsp            # imm = 0xC18
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc(%rsp), %r12
movq %r12, %rdi
callq 0x143b4
movq (%rbx), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x12a77
movq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12edc
jmp 0x1d645
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/parser_call.c
// Function: prv_fn_compound
static void prv_fn_compound(subtilis_parser_t *p, subtilis_token_t *t,
			    subtilis_error_t *err)
{
	unsigned int start;
	const char *tbuf;

	start = p->l->line;
	while (t->type != SUBTILIS_TOKEN_EOF) {
		tbuf = subtilis_token_get_text(t);
		if ((t->type == SUBTILIS_TOKEN_OPERATOR) &&
		    !strcmp(tbuf, "<-") && (p->level == 0))
			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 %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x38(%rax), %ebp
xorl %r14d, %r14d
cmpl $0x0, (%r12)
je 0x1d87d
movq %r12, %rdi
callq 0x12ad0
cmpl $0x2, (%r12)
jne 0x1d867
cmpb $0x3c, (%rax)
jne 0x1d867
cmpb $0x2d, 0x1(%rax)
jne 0x1d867
cmpb $0x0, 0x2(%rax)
jne 0x1d867
cmpq $0x0, 0x78(%rbx)
je 0x1d8a4
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x15089
cmpl $0x0, (%r15)
je 0x1d839
jmp 0x1d8bc
movq (%rbx), %rax
movq 0x30(%rax), %rdx
leaq 0x55dc8(%rip), %r8      # 0x73653
movq %r15, %rdi
movl $0x1e, %esi
movl %ebp, %ecx
movl $0x398, %r9d            # imm = 0x398
callq 0x145c8
movq 0x78(%rbx), %r14
movq 0x48(%rbx), %rax
movq 0x78(%rax), %rdi
movq %r14, %rsi
callq 0x2baf1
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_O3/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 0x1d8e9
testl %eax, %eax
jne 0x1d8f0
jmp 0x1d906
cmpl $0x28, 0x8(%r15)
je 0x1d929
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x15089
cmpl $0x0, (%r14)
je 0x1d8db
jmp 0x1d942
movq (%rbx), %rax
movq 0x30(%rax), %rdx
leaq 0x55d3f(%rip), %r8      # 0x73653
movq %r14, %rdi
movl $0x1e, %esi
movl %ebp, %ecx
movl $0x3b0, %r9d            # imm = 0x3B0
callq 0x145c8
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2baf1
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_O3/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 0x1ef33
cmpl $0x0, (%r14)
je 0x1d984
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x1, (%rax)
jne 0x1d9df
movl 0x148(%rax), %ebp
movq %rax, %rdi
callq 0x2b166
movq (%r12), %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x1d975
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x35fbf
cmpl $0x0, (%r14)
jne 0x1d975
movl %ebp, 0x8(%rbx)
testl %ebp, %ebp
je 0x1d975
xorl %eax, %eax
movl $0xffffffff, 0xc(%rbx,%rax,4) # imm = 0xFFFFFFFF
incq %rax
movslq 0x8(%rbx), %rcx
cmpq %rcx, %rax
jb 0x1d9c9
jmp 0x1d975
movq %rax, %rdi
callq 0x2b166
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x55c5a(%rip), %r8      # 0x73653
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 0x145c8
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
je 0x1da4c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x12ad0
cmpl $0x2, (%r12)
jne 0x1da94
movl $0x1, 0x8(%r14)
movq (%r13), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x1da42
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x36014
cmpl $0x0, (%rbx)
jne 0x1da42
movl $0xffffffff, 0xc(%r14)  # imm = 0xFFFFFFFF
jmp 0x1da42
cmpb $0x7d, (%rax)
jne 0x1da9f
cmpb $0x0, 0x1(%rax)
je 0x1da5b
movq (%r13), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x55ba1(%rip), %r10     # 0x73653
leaq 0x55b97(%rip), %rdx     # 0x73650
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x240                  # imm = 0x240
pushq %r10
callq 0x143da
addq $0x10, %rsp
jmp 0x1da42
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
je 0x1dfb9
addq $0x150, %rsp            # imm = 0x150
jmp 0x1e007
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x1dfd3
cmpb $0x29, (%rax)
jne 0x1dfd3
cmpb $0x0, 0x1(%rax)
je 0x1e011
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x5569a(%rip), %r10     # 0x7367f
leaq 0x55e29(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x16, %esi
movq %rax, %rdx
pushq $0x2e
pushq %r10
callq 0x143da
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r15), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x1dfb0
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x1e03e
cmpb $0x3d, (%rax)
jne 0x1e03e
cmpb $0x0, 0x1(%rax)
je 0x1e06b
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5562f(%rip), %rax     # 0x7367f
leaq 0x561c3(%rip), %rdx     # 0x7421a
leaq 0x55db7(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x3a
pushq %rax
jmp 0x1dffb
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1ec4c
cmpl $0x0, (%rbx)
jne 0x1dfb0
movq %rax, %r13
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x35fbf
cmpl $0x0, (%rbx)
jne 0x1dfb0
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq 0x17e40
movq %r12, %rdi
callq 0x2f56e
jmp 0x1dfb0
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rdi
movq %r8, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
je 0x1e102
addq $0x150, %rsp            # imm = 0x150
jmp 0x1e150
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x1e11c
cmpb $0x7d, (%rax)
jne 0x1e11c
cmpb $0x0, 0x1(%rax)
je 0x1e15a
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x55551(%rip), %r10     # 0x7367f
leaq 0x55565(%rip), %rdx     # 0x7369a
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x5b
pushq %r10
callq 0x143da
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r15), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x1e0f9
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x1e187
cmpb $0x3d, (%rax)
jne 0x1e187
cmpb $0x0, 0x1(%rax)
je 0x1e1b4
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x554e6(%rip), %rax     # 0x7367f
leaq 0x5607a(%rip), %rdx     # 0x7421a
leaq 0x55c6e(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x67
pushq %rax
jmp 0x1e144
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1ec4c
cmpl $0x0, (%rbx)
jne 0x1e0f9
movq %rax, %r13
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x36014
cmpl $0x0, (%rbx)
je 0x1e1f0
movq %r13, %rdi
callq 0x2b166
jmp 0x1e0f9
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %r13, %rcx
movl $0x1, %r8d
movq %rbx, %r9
callq 0x17e40
movq %r12, %rdi
callq 0x2f56e
jmp 0x1e0f9
// File: /workspace/github_c_makefile_star2_O3/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 0x1e245
testl %eax, %eax
jne 0x1e24c
jmp 0x1e265
cmpl %ebp, 0x8(%r12)
je 0x1e289
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x15089
cmpl $0x0, (%r14)
je 0x1e236
jmp 0x1e2f3
movq (%rbx), %rax
movq 0x30(%rax), %rdx
leaq 0x5540c(%rip), %r8      # 0x7367f
movq %r14, %rdi
movl $0x1e, %esi
movl %r15d, %ecx
movl $0x117, %r9d            # imm = 0x117
callq 0x145c8
cmpl $0x28, %ebp
je 0x1e2a6
cmpl $0x51, %ebp
je 0x1e2a6
cmpl $0x8b, %ebp
je 0x1e2a6
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 0x4e90a
cmpl $0x0, (%r14)
jne 0x1e2f3
decq 0x78(%rbx)
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2e342
cmpl $0x0, (%r14)
jne 0x1e2f3
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2baf1
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_O3/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 0x2e306
cmpl $0x0, (%r14)
jne 0x1e3c8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x15089
cmpl $0x0, (%r14)
jne 0x1e3c8
movq 0x68(%rbx), %rdx
movq 0x78(%rbx), %rcx
movl $0x2, %esi
movq %rbx, %rdi
movq %r14, %r8
callq 0x4e90a
cmpl $0x0, (%r14)
jne 0x1e3c8
decq 0x78(%rbx)
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2e342
cmpl $0x0, (%r14)
jne 0x1e3c8
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2baf1
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1ec4c
cmpl $0x0, (%r15)
jne 0x1e467
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x367cf
cmpl $0x0, (%r15)
jne 0x1e467
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x5, %eax
je 0x1e43b
cmpl $0x1, %eax
jne 0x1e447
movq 0x48(%r12), %rdi
movq 0x148(%rbx), %rdx
movl $0x1b, %esi
movq %r15, %rcx
callq 0x2be09
cmpl $0x0, (%r15)
jne 0x1e45f
jmp 0x1e442
movq 0x148(%rbx), %rax
movq %rax, (%r14)
jmp 0x1e469
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
movq %r15, %rdi
movl $0x1c, %esi
callq 0x145a4
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/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 0x12edc
cmpl $0x0, (%rbx)
jne 0x1e8a1
movq %r12, %rdi
callq 0x12ad0
cmpl $0x6, (%r12)
jne 0x1e87c
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x1e8b1
cmpl $0x0, (%rbx)
jne 0x1e8a1
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 0x1e62c
addq $0x30, %rsp
jmp 0x1e8a7
movq (%r13), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x55052(%rip), %r8      # 0x738e0
movq %rbx, %rdi
movl $0x67, %esi
movl $0xea, %r9d
callq 0x145c8
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2ebbc
testq %rax, %rax
je 0x1e8da
movl $0x2, %ecx
jmp 0x1e8f1
movq 0x60(%r12), %rdi
movq %r14, %rsi
callq 0x2ebbc
testq %rax, %rax
je 0x1e900
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 0x54fcd(%rip), %rax     # 0x738e0
leaq 0x554fb(%rip), %rcx     # 0x73e15
movq %r15, %rdi
movl $0x1b, %esi
movq %r14, %rdx
pushq $0x5c9                  # imm = 0x5C9
pushq %rax
callq 0x143da
addq $0x10, %rsp
xorl %eax, %eax
jmp 0x1e8f4
// File: /workspace/github_c_makefile_star2_O3/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 0x1e9eb
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1e980
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18369(%rip), %rbp     # 0x36cf0
cmpl $0x1, (%r15)
jne 0x1e96e
movl 0x8(%r15), %eax
movq %rbp, %r13
cmpl $0x2d, %eax
je 0x1e9a5
cmpl $0x5a, %eax
jne 0x1e96e
leaq 0x18303(%rip), %r13     # 0x36ca8
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x1e95a
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1e9eb
cmpl $0x0, (%r14)
jne 0x1e95c
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%r13
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1e987
jmp 0x1e95a
// File: /workspace/github_c_makefile_star2_O3/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 0x1fa4a
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1ea53
cmpl $0x1, (%r15)
jne 0x1ea67
cmpl $0x7, 0x8(%r15)
jne 0x1ea67
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12edc
cmpl $0x0, (%r14)
jne 0x1ea53
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fa4a
cmpl $0x0, (%r14)
jne 0x1ea55
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x36c60
jmp 0x1ea01
xorl %eax, %eax
movq %rax, %rdi
callq 0x2b166
movq %rbx, %rdi
callq 0x2b166
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/frontend/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 0x1eb0a
movq %rax, %r15
movq %r14, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1eb25
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 0x2b1aa
addq $0x38, %rsp
jmp 0x1eb4e
leaq 0x54dcf(%rip), %rdx     # 0x738e0
movq %rbp, %rdi
movl $0x1, %esi
movl $0x345, %ecx            # imm = 0x345
callq 0x145a4
jmp 0x1eb48
leaq 0x54db4(%rip), %rdx     # 0x738e0
movq 0x58(%rsp), %rdi
movl $0x1, %esi
movl $0x34b, %ecx            # imm = 0x34B
callq 0x145a4
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_O3/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 0x1ebfd
movq %rax, %r14
movq %r15, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1ec18
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 0x2b1aa
addq $0x38, %rsp
jmp 0x1ec41
leaq 0x54cdc(%rip), %rdx     # 0x738e0
movq %rbp, %rdi
movl $0x1, %esi
movl $0x36e, %ecx            # imm = 0x36E
callq 0x145a4
jmp 0x1ec3b
leaq 0x54cc1(%rip), %rdx     # 0x738e0
movq 0x60(%rsp), %rdi
movl $0x1, %esi
movl $0x374, %ecx            # imm = 0x374
callq 0x145a4
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_O3/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 0x1e938
cmpl $0x0, (%rbx)
jne 0x1ecc4
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
jne 0x1ecbc
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x36119
cmpl $0x0, (%rbx)
je 0x1ecc6
movq %rax, %rdi
callq 0x2b166
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rsi, %r13
movq %rdi, %r15
movq %r8, %rdx
callq 0x1ec82
movq %rax, (%r12)
cmpl $0x0, (%rbx)
setne %al
cmpq $0x2, %r14
setb %cl
orb %al, %cl
jne 0x1ed5c
addq $-0x2, %r14
xorl %ebp, %ebp
movq %r13, %rdi
callq 0x12ad0
cmpl $0x2, (%r13)
jne 0x1ed8d
cmpb $0x2c, (%rax)
jne 0x1ed62
cmpb $0x0, 0x1(%rax)
jne 0x1ed62
movq (%r15), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x1ed5c
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1ec82
movq %rax, 0x8(%r12,%rbp,8)
cmpl $0x0, (%rbx)
jne 0x1ed5c
leaq 0x1(%rbp), %rax
cmpq %rbp, %r14
movq %rax, %rbp
jne 0x1ed0b
addq $0x8, %rsp
jmp 0x1edc1
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x54b6c(%rip), %r10     # 0x738e0
leaq 0x54817(%rip), %rdx     # 0x73592
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x3c1                  # imm = 0x3C1
jmp 0x1edb6
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x54b41(%rip), %r10     # 0x738e0
leaq 0x547ec(%rip), %rdx     # 0x73592
movq %rbx, %rdi
movl $0x1d, %esi
movq %rax, %rcx
pushq $0x3bb                  # imm = 0x3BB
pushq %r10
callq 0x143da
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/markdryan[P]subtilis/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 0x12edc
cmpl $0x0, (%rbx)
jne 0x1ee47
movq %r15, %rdi
callq 0x12ad0
cmpb $0x28, (%rax)
jne 0x1ee0b
cmpb $0x0, 0x1(%rax)
je 0x1ee88
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x54ac3(%rip), %rax     # 0x738e0
leaq 0x54ad2(%rip), %rdx     # 0x738f6
leaq 0x54fea(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x3dc                  # imm = 0x3DC
pushq %rax
callq 0x143da
addq $0x10, %rsp
cmpl $0x0, (%rbx)
je 0x1ee57
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
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 0x2bc8f
cmpl $0x0, (%rbx)
je 0x1eefb
xorl %ebx, %ebx
jmp 0x1ef08
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
jne 0x1ee47
movq %rsp, %rdx
movl $0x2, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x1ecce
cmpl $0x0, (%rbx)
jne 0x1ee47
movq %r15, %rdi
callq 0x12ad0
cmpb $0x29, (%rax)
jne 0x1eec9
cmpb $0x0, 0x1(%rax)
je 0x1ef20
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x54a05(%rip), %rax     # 0x738e0
leaq 0x58170(%rip), %rdx     # 0x77052
leaq 0x54f2c(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x3eb                  # imm = 0x3EB
jmp 0x1ee38
movl %eax, %edi
movq %rbx, %rsi
callq 0x2b71f
movq %rax, %rbx
movq (%rsp), %rdi
callq 0x2b166
movq 0x8(%rsp), %rdi
callq 0x2b166
jmp 0x1ee49
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12edc
jmp 0x1ee42
// File: /workspace/github_c_makefile_star2_O3/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 0x1ec4c
cmpl $0x0, (%rbx)
jne 0x1efae
movq %rax, %r14
movq %r13, %rdi
callq 0x12ad0
movq %rax, %r12
cmpl $0x2, (%r13)
jne 0x1ef73
cmpb $0x29, (%r12)
jne 0x1ef73
cmpb $0x0, 0x1(%r12)
je 0x1efb1
movq %r14, %rdi
callq 0x2b166
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x54953(%rip), %rax     # 0x738e0
leaq 0x54e81(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x16, %esi
movq %r12, %rdx
pushq $0x41f                  # imm = 0x41F
pushq %rax
callq 0x143da
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_O3/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 0x12edc
cmpl $0x0, (%rbx)
jne 0x1f026
movq %r14, %rdi
callq 0x12ad0
cmpb $0x28, (%rax)
jne 0x1efef
cmpb $0x0, 0x1(%rax)
je 0x1f038
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x548df(%rip), %rax     # 0x738e0
leaq 0x548ee(%rip), %rdx     # 0x738f6
leaq 0x54e06(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x15, %esi
pushq $0x434                  # imm = 0x434
pushq %rax
callq 0x143da
addq $0x10, %rsp
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ef33
cmpl $0x0, (%rbx)
jne 0x1f026
movq %rax, %r12
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12edc
cmpl $0x0, (%rbx)
je 0x1f029
movq %r12, %rdi
callq 0x2b166
jmp 0x1f026
// File: /workspace/github_c_makefile_star2_O3/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 0x12edc
cmpl $0x0, (%rbx)
jne 0x1f61a
movq %r15, %rdi
callq 0x12ad0
cmpl $0x2, (%r15)
jne 0x1f59f
cmpb $0x7d, (%rax)
jne 0x1f59f
cmpb $0x0, 0x1(%rax)
je 0x1f61a
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1e938
cmpl $0x0, (%rbx)
jne 0x1f61a
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x367cf
cmpl $0x0, (%rbx)
jne 0x1f61a
movq %rax, %r12
movq %r15, %rdi
callq 0x12ad0
movq %rax, %r15
cmpb $0x7d, (%rax)
jne 0x1f5df
cmpb $0x0, 0x1(%r15)
je 0x1f61d
movq %r12, %rdi
callq 0x2b166
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x542e7(%rip), %rax     # 0x738e0
leaq 0x54050(%rip), %rdx     # 0x73650
movq %rbx, %rdi
movl $0x1d, %esi
movq %r15, %rcx
pushq $0x546                  # imm = 0x546
pushq %rax
callq 0x143da
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_O3/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 0x1f87b
movq %rax, %r15
incq %r15
movq 0x60(%r12), %rdi
movq %r15, %rsi
callq 0x2ebbc
testq %rax, %rax
je 0x1f891
cmpl $0x18, 0x8(%rax)
jne 0x1f8cd
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 0x2f78a
leaq 0x5405e(%rip), %rdx     # 0x738e0
movq %rbx, %rdi
movl $0xf, %esi
movl $0x5a7, %ecx            # imm = 0x5A7
jmp 0x1f8e1
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x5403c(%rip), %rax     # 0x738e0
leaq 0x5456a(%rip), %rcx     # 0x73e15
movq %rbx, %rdi
movl $0x26, %esi
movq %r15, %rdx
pushq $0x5af                  # imm = 0x5AF
pushq %rax
callq 0x143da
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x5400c(%rip), %rdx     # 0x738e0
movq %rbx, %rdi
movl $0xf, %esi
movl $0x5b4, %ecx            # imm = 0x5B4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x145a4
// File: /workspace/github_c_makefile_star2_O3/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 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x1f964
movq %rax, %rbp
movq 0x48(%r12), %rdi
movl $0x12, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x1f964
movq 0x48(%r12), %rdi
movl $0x17, %esi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbx, %r9
movq %rax, %r13
callq 0x2bd42
cmpl $0x0, (%rbx)
je 0x1f973
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 0x2bd42
// File: /workspace/github_c_makefile_star2_O3/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 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x1fa12
movq %rax, %rbp
movq 0x48(%r12), %rdi
movl $0x11, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2bc8f
cmpl $0x0, (%rbx)
jne 0x1fa12
movq 0x48(%r12), %rdi
movl $0x16, %esi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbx, %r9
movq %rax, %r13
callq 0x2bd42
cmpl $0x0, (%rbx)
je 0x1fa21
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 0x2bd42