LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2cb0c
cmpl $0x0, (%r14)
jne 0x1d783
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x14d03
cmpl $0x0, (%r14)
jne 0x1d783
movq 0x68(%rbx), %rdx
movq 0x78(%rbx), %rcx
pushq $0x2
popq %rsi
movq %rbx, %rdi
movq %r14, %r8
callq 0x4bbc0
cmpl $0x0, (%r14)
jne 0x1d783
decq 0x78(%rbx)
movq 0x68(%rbx), %rdi
movq %r14, %rsi
callq 0x2cb44
cmpl $0x0, (%r14)
jne 0x1d783
movq 0x48(%rbx), %rax
movq 0x78(%rbx), %rsi
movq 0x78(%rax), %rdi
callq 0x2a68e
movq 0x48(%rbx), %rcx
movq %rax, 0x78(%rcx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1dfd5
cmpl $0x0, (%r15)
jne 0x1d81f
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x347d5
cmpl $0x0, (%r15)
jne 0x1d81f
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x5, %eax
je 0x1d7f5
cmpl $0x1, %eax
jne 0x1d801
movq 0x48(%r12), %rdi
movq 0x148(%rbx), %rdx
pushq $0x1b
popq %rsi
movq %r15, %rcx
callq 0x2a981
cmpl $0x0, (%r15)
jne 0x1d817
jmp 0x1d7fc
movq 0x148(%rbx), %rax
movq %rax, (%r14)
jmp 0x1d821
movq (%r12), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
pushq $0x1c
popq %rsi
movq %r15, %rdi
callq 0x1429e
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1dc41
movq %r12, %rdi
callq 0x12a25
cmpl $0x6, (%r12)
jne 0x1dc1e
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x1dc51
cmpl $0x0, (%rbx)
jne 0x1dc41
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 0x1d9d8
addq $0x30, %rsp
jmp 0x1dc47
movq (%r13), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4fc6c(%rip), %r8      # 0x6d89c
pushq $0x67
popq %rsi
movq %rbx, %rdi
movl $0xea, %r9d
callq 0x142c0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d376
testq %rax, %rax
je 0x1dc77
pushq $0x2
jmp 0x1dc8b
movq 0x60(%r12), %rdi
movq %r14, %rsi
callq 0x2d376
testq %rax, %rax
je 0x1dc9b
pushq $0x1
popq %rcx
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 0x4fbee(%rip), %rax     # 0x6d89c
leaq 0x50110(%rip), %rcx     # 0x6ddc5
pushq $0x1b
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
pushq $0x5c9                  # imm = 0x5C9
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
xorl %eax, %eax
jmp 0x1dc8f
// File: /workspace/github_c_makefile_star2_O2/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 0x1dd82
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1dd17
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17044(%rip), %rbp     # 0x34d62
cmpl $0x1, (%r15)
jne 0x1dd05
movl 0x8(%r15), %eax
movq %rbp, %r13
cmpl $0x2d, %eax
je 0x1dd3c
cmpl $0x5a, %eax
jne 0x1dd05
leaq 0x16fc8(%rip), %r13     # 0x34d04
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x1dcf1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1dd82
cmpl $0x0, (%r14)
jne 0x1dcf3
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%r13
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1dd1e
jmp 0x1dcf1
// File: /workspace/github_c_makefile_star2_O2/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 0x1ed50
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1ddea
cmpl $0x1, (%r15)
jne 0x1ddfe
cmpl $0x7, 0x8(%r15)
jne 0x1ddfe
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x1ddea
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1ed50
cmpl $0x0, (%r14)
jne 0x1ddec
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x34ca6
jmp 0x1dd98
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x18
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x1de9f
movq %rax, %r15
movq %r14, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1deb8
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 0x29dcc
addq $0x38, %rsp
jmp 0x1dedf
leaq 0x4f9f6(%rip), %rdx     # 0x6d89c
pushq $0x1
popq %rsi
movq %rbp, %rdi
movl $0x345, %ecx            # imm = 0x345
callq 0x1429e
jmp 0x1ded9
leaq 0x4f9dd(%rip), %rdx     # 0x6d89c
pushq $0x1
popq %rsi
movq 0x58(%rsp), %rdi
movl $0x34b, %ecx            # imm = 0x34B
callq 0x1429e
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_O2/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
pushq $0x30
popq %rdi
callq 0x121d0
testq %rax, %rax
je 0x1df8a
movq %rax, %r14
movq %r15, %rdi
callq 0x120f0
leaq 0x1(%rax), %rdi
callq 0x121d0
testq %rax, %rax
je 0x1dfa3
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
pushq $0x9
popq %rdx
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
xorl %ecx, %ecx
movq %r14, %r8
movq 0x58(%rsp), %r9
pushq 0x68(%rsp)
pushq %rax
pushq $0x2
callq 0x29dcc
addq $0x38, %rsp
jmp 0x1dfca
leaq 0x4f90b(%rip), %rdx     # 0x6d89c
pushq $0x1
popq %rsi
movq %rbp, %rdi
movl $0x36e, %ecx            # imm = 0x36E
callq 0x1429e
jmp 0x1dfc4
leaq 0x4f8f2(%rip), %rdx     # 0x6d89c
pushq $0x1
popq %rsi
movq 0x60(%rsp), %rdi
movl $0x374, %ecx            # imm = 0x374
callq 0x1429e
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_O2/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 0x1dccf
cmpl $0x0, (%rbx)
jne 0x1e04d
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
jne 0x1e045
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x3415f
cmpl $0x0, (%rbx)
je 0x1e04f
movq %rax, %rdi
callq 0x29d88
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1e00b
movq %rax, (%r12)
cmpl $0x0, (%rbx)
je 0x1e091
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rbp
cmpq %r14, %rbp
jae 0x1e082
movq %r13, %rdi
callq 0x12a25
cmpl $0x2, (%r13)
jne 0x1e10b
cmpb $0x2c, (%rax)
jne 0x1e0e2
cmpb $0x0, 0x1(%rax)
jne 0x1e0e2
movq (%r15), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1e082
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x1e00b
movq %rax, (%r12,%rbp,8)
incq %rbp
cmpl $0x0, (%rbx)
je 0x1e094
jmp 0x1e082
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x4f7a8(%rip), %r10     # 0x6d89c
leaq 0x4f497(%rip), %rdx     # 0x6d592
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x3c1                  # imm = 0x3C1
jmp 0x1e132
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x4f77f(%rip), %r10     # 0x6d89c
leaq 0x4f46e(%rip), %rdx     # 0x6d592
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0x3bb                  # imm = 0x3BB
pushq %r10
callq 0x140cd
addq $0x18, %rsp
jmp 0x1e086
// File: /workspace/github_c_makefile_star2_O2/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 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1e1b9
movq %r15, %rdi
callq 0x12a25
cmpb $0x28, (%rax)
jne 0x1e181
cmpb $0x0, 0x1(%rax)
je 0x1e1f7
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4f709(%rip), %rax     # 0x6d89c
leaq 0x4f718(%rip), %rdx     # 0x6d8b2
leaq 0x4fc24(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %rbx, %rdi
pushq $0x3dc                  # imm = 0x3DC
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
cmpl $0x0, (%rbx)
je 0x1e1c9
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 0x2a819
cmpl $0x0, (%rbx)
je 0x1e266
xorl %ebx, %ebx
jmp 0x1e273
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1e1b9
movq %rsp, %rdx
pushq $0x2
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %r8
callq 0x1e057
cmpl $0x0, (%rbx)
jne 0x1e1b9
movq %r15, %rdi
callq 0x12a25
cmpb $0x29, (%rax)
jne 0x1e236
cmpb $0x0, 0x1(%rax)
je 0x1e28e
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4f654(%rip), %rax     # 0x6d89c
leaq 0x52d73(%rip), %rdx     # 0x70fc2
leaq 0x4fb6f(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %rbx, %rdi
pushq $0x3eb                  # imm = 0x3EB
jmp 0x1e1ac
movl %eax, %edi
movq %rbx, %rsi
callq 0x2a336
movq %rax, %rbx
xorl %r14d, %r14d
cmpq $0x2, %r14
je 0x1e1bb
movq (%rsp,%r14,8), %rdi
callq 0x29d88
incq %r14
jmp 0x1e276
movq (%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x12e0e
jmp 0x1e1b4
// File: /workspace/github_c_makefile_star2_O2/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 0x1dfd5
cmpl $0x0, (%rbx)
jne 0x1e318
movq %rax, %r14
movq %r13, %rdi
callq 0x12a25
movq %rax, %r12
cmpl $0x2, (%r13)
jne 0x1e2e1
cmpb $0x29, (%r12)
jne 0x1e2e1
cmpb $0x0, 0x1(%r12)
je 0x1e31b
movq %r14, %rdi
callq 0x29d88
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4f5a1(%rip), %rax     # 0x6d89c
leaq 0x4fac3(%rip), %rcx     # 0x6ddc5
pushq $0x16
popq %rsi
movq %rbx, %rdi
movq %r12, %rdx
pushq $0x41f                  # imm = 0x41F
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1e38c
movq %r14, %rdi
callq 0x12a25
cmpb $0x28, (%rax)
jne 0x1e359
cmpb $0x0, 0x1(%rax)
je 0x1e39e
movq (%r15), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4f531(%rip), %rax     # 0x6d89c
leaq 0x4f540(%rip), %rdx     # 0x6d8b2
leaq 0x4fa4c(%rip), %rcx     # 0x6ddc5
pushq $0x15
popq %rsi
movq %rbx, %rdi
pushq $0x434                  # imm = 0x434
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
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 0x1e2a1
cmpl $0x0, (%rbx)
jne 0x1e38c
movq %rax, %r12
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
je 0x1e38f
movq %r12, %rdi
callq 0x29d88
jmp 0x1e38c
// File: /workspace/github_c_makefile_star2_O2/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 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1e946
movq %r15, %rdi
callq 0x12a25
cmpl $0x2, (%r15)
jne 0x1e8cf
cmpb $0x7d, (%rax)
jne 0x1e8cf
cmpb $0x0, 0x1(%rax)
je 0x1e946
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1dccf
cmpl $0x0, (%rbx)
jne 0x1e946
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x347d5
cmpl $0x0, (%rbx)
jne 0x1e946
movq %rax, %r12
movq %r15, %rdi
callq 0x12a25
movq %rax, %r15
cmpb $0x7d, (%rax)
jne 0x1e90f
cmpb $0x0, 0x1(%r15)
je 0x1e949
movq %r12, %rdi
callq 0x29d88
movq (%r14), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4ef73(%rip), %rax     # 0x6d89c
leaq 0x4ecdd(%rip), %rdx     # 0x6d60d
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %r15, %rcx
pushq $0x546                  # imm = 0x546
pushq %rax
callq 0x140cd
popq %rax
popq %rcx
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rsi, %rax
movq %rdi, %r12
pushq $0x40
popq %rsi
movq %rax, %rdi
callq 0x12100
testq %rax, %rax
je 0x1eb97
movq %rax, %r15
incq %r15
movq 0x60(%r12), %rdi
movq %r15, %rsi
callq 0x2d376
testq %rax, %rax
je 0x1ebab
cmpl $0x18, 0x8(%rax)
jne 0x1ebe5
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 0x2de8a
leaq 0x4ecfe(%rip), %rdx     # 0x6d89c
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x5a7, %ecx            # imm = 0x5A7
jmp 0x1ebf7
movq (%r12), %rax
movq 0x30(%rax), %r8
movl 0x38(%rax), %r9d
leaq 0x4ecde(%rip), %rax     # 0x6d89c
leaq 0x4f200(%rip), %rcx     # 0x6ddc5
pushq $0x26
popq %rsi
movq %rbx, %rdi
movq %r15, %rdx
pushq $0x5af                  # imm = 0x5AF
pushq %rax
callq 0x140cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4ecb0(%rip), %rdx     # 0x6d89c
pushq $0xf
popq %rsi
movq %rbx, %rdi
movl $0x5b4, %ecx            # imm = 0x5B4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1429e
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x12
popq %rsi
movq %r15, %rcx
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x1ec74
movq %rax, %rbp
movq 0x48(%r12), %rdi
pushq $0x12
popq %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x1ec74
movq 0x48(%r12), %rdi
pushq $0x17
popq %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbx, %r9
movq %rax, %r13
callq 0x2a8c1
cmpl $0x0, (%rbx)
je 0x1ec83
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdx
movq 0x48(%r12), %rdi
pushq $0x17
popq %rsi
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 0x2a8c1
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x11
popq %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x1ed1a
movq %rax, %rbp
movq 0x48(%r12), %rdi
pushq $0x11
popq %rsi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x2a819
cmpl $0x0, (%rbx)
jne 0x1ed1a
movq 0x48(%r12), %rdi
pushq $0x16
popq %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
movq %rbx, %r9
movq %rax, %r13
callq 0x2a8c1
cmpl $0x0, (%rbx)
je 0x1ed29
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdx
movq 0x48(%r12), %rdi
pushq $0x16
popq %rsi
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 0x2a8c1
// File: /workspace/github_c_makefile_star2_O2/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 0x1efdb
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1ef04
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r12, %rdi
callq 0x12a25
cmpl $0x4, (%r12)
jne 0x1ef4e
xorl %ecx, %ecx
cmpl 0x8(%r12), %ecx
jno 0x1ef4e
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x4e96e(%rip), %r10     # 0x6d89c
leaq 0x4ee90(%rip), %rcx     # 0x6ddc5
pushq $0x8
popq %rsi
movq %r14, %rdi
movq %rax, %rdx
pushq $0x295                  # imm = 0x295
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
jmp 0x1eee3
cmpl $0x2, (%r12)
jne 0x1eef7
movq %r12, %rdi
callq 0x12a25
movzbl (%rax), %ecx
cmpl $0x2d, %ecx
je 0x1ef79
cmpl $0x2b, %ecx
jne 0x1eef7
cmpb $0x0, 0x1(%rax)
jne 0x1eef7
leaq 0xb664(%rip), %r13      # 0x2a5db
jmp 0x1ef8a
cmpb $0x0, 0x1(%rax)
jne 0x1eef7
leaq 0x15f0e(%rip), %r13     # 0x34e98
movq (%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x1eee3
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1efdb
cmpl $0x0, (%r14)
jne 0x1eee5
movq %r15, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%r13
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1ef4e
jmp 0x1eee3
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority3
static subtilis_exp_t *prv_priority3(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_priority2(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;
	while ((t->type == SUBTILIS_TOKEN_OPERATOR) ||
	       (t->type == SUBTILIS_TOKEN_KEYWORD)) {
		tbuf = subtilis_token_get_text(t);
		if (t->type == SUBTILIS_TOKEN_KEYWORD) {
			if (t->tok.keyword.type == SUBTILIS_KEYWORD_DIV)
				exp_fn = subtilis_type_if_div;
			else if (t->tok.keyword.type == SUBTILIS_KEYWORD_MOD)
				exp_fn = subtilis_type_if_mod;
			else
				break;
		} else if (!strcmp(tbuf, "*")) {
			exp_fn = subtilis_type_if_mul;
		} else if (!strcmp(tbuf, "/")) {
			exp_fn = subtilis_type_if_divr;
		} else {
			break;
		}
		subtilis_lexer_get(p->l, t, err);
		if (err->type != SUBTILIS_ERROR_OK)
			goto cleanup;
		e2 = prv_priority2(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 0x1f0d6
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1f023
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15ed0(%rip), %r13     # 0x34efa
movl (%r15), %eax
decl %eax
cmpl $0x1, %eax
ja 0x1f011
movq %r15, %rdi
callq 0x12a25
cmpl $0x1, (%r15)
jne 0x1f05c
movl 0x8(%r15), %eax
movq %r13, %rbp
cmpl $0x20, %eax
je 0x1f085
cmpl $0x4d, %eax
jne 0x1f011
leaq 0x15f20(%rip), %rbp     # 0x34f7a
jmp 0x1f085
movzbl (%rax), %ecx
cmpl $0x2f, %ecx
je 0x1f078
cmpl $0x2a, %ecx
jne 0x1f011
cmpb $0x0, 0x1(%rax)
leaq 0x15b87(%rip), %rbp     # 0x34bfb
je 0x1f085
jmp 0x1f011
cmpb $0x0, 0x1(%rax)
leaq 0x15f77(%rip), %rbp     # 0x34ffa
jne 0x1f011
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x1effd
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f0d6
cmpl $0x0, (%r14)
jne 0x1efff
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq *%rbp
movq %rax, %rbx
cmpl $0x0, (%r14)
je 0x1f02a
jmp 0x1effd
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_exp.c
// Function: prv_priority2
static subtilis_exp_t *prv_priority2(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;

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

	while (t->type == SUBTILIS_TOKEN_OPERATOR) {
		tbuf = subtilis_token_get_text(t);
		if (strcmp(tbuf, "^"))
			break;

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

		e1 = subtilis_type_if_pow(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 0x1f16d
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x1f14a
cmpl $0x2, (%r15)
jne 0x1f15e
movq %r15, %rdi
callq 0x12a25
cmpb $0x5e, (%rax)
jne 0x1f15e
cmpb $0x0, 0x1(%rax)
jne 0x1f15e
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x12e0e
cmpl $0x0, (%r14)
jne 0x1f14a
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f16d
cmpl $0x0, (%r14)
jne 0x1f14c
movq %r12, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movq %r14, %rcx
callq 0x352bb
jmp 0x1f0ec
xorl %eax, %eax
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rdi
callq 0x29d88
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_file.c
// Function: prv_open
static subtilis_exp_t *prv_open(subtilis_parser_t *p, subtilis_token_t *t,
				subtilis_op_instr_type_t itype,
				subtilis_error_t *err)
{
	subtilis_exp_t *file_name;
	size_t ret;
	subtilis_exp_t *handle = NULL;

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

	if (file_name->type.type == SUBTILIS_TYPE_STRING) {
		file_name = subtilis_string_zt_non_const(p, file_name, err);
	} else if (file_name->type.type == SUBTILIS_TYPE_CONST_STRING) {
		file_name = subtilis_string_lca_const_zt(p, file_name, err);
	} else {
		subtilis_error_set_string_expected(err, p->l->stream->name,
						   p->l->line);
		goto cleanup;
	}

	ret = subtilis_ir_section_add_instr2(p->current, itype,
					     file_name->exp.ir_op, err);
	if (err->type != SUBTILIS_ERROR_OK)
		goto cleanup;

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

	handle = subtilis_exp_new_int32_var(ret, err);

cleanup:

	subtilis_exp_delete(file_name);

	return handle;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %r15
movq %rcx, %rdx
callq 0x1e328
cmpl $0x0, (%r14)
je 0x1fde0
xorl %r14d, %r14d
jmp 0x1fe7a
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x3, %eax
je 0x1fdff
cmpl $0x7, %eax
jne 0x1fe4f
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4612a
jmp 0x1fe0d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x45d61
movq %rax, %rbx
movq 0x48(%r15), %rdi
movq 0x148(%rax), %rdx
movl %ebp, %esi
movq %r14, %rcx
callq 0x2a981
cmpl $0x0, (%r14)
jne 0x1fe6f
movq %rax, %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x29c49
cmpl $0x0, (%r14)
jne 0x1fe6f
movl %r12d, %edi
movq %r14, %rsi
callq 0x2a336
movq %rax, %r14
jmp 0x1fe72
movq (%r15), %rax
movq 0x30(%rax), %rdx
movl 0x38(%rax), %ecx
leaq 0x4da99(%rip), %r8      # 0x6d8f9
pushq $0x49
popq %rsi
pushq $0x2c
popq %r9
movq %r14, %rdi
callq 0x142c0
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x29d88
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_file.c
// Function: subtilis_parser_close
void subtilis_parser_close(subtilis_parser_t *p, subtilis_token_t *t,
			   subtilis_error_t *err)
{
	subtilis_ir_operand_t handle;

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

	subtilis_ir_section_add_instr_no_reg(
	    p->current, SUBTILIS_OP_INSTR_CLOSE, handle, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_exp_handle_errors(p, err);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x1fee7
cmpl $0x0, (%rbx)
jne 0x1fecd
movq 0x48(%r14), %rdi
movl $0x8e, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2a997
cmpl $0x0, (%rbx)
je 0x1fed5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x29c49
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_file.c
// Function: prv_parse_handle
static subtilis_ir_operand_t prv_parse_handle(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_error_t *err)
{
	subtilis_exp_t *handle;
	subtilis_ir_operand_t ret;

	ret.reg = SIZE_MAX;

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

	handle = subtilis_parser_int_var_expression(p, t, err);
	if (err->type != SUBTILIS_ERROR_OK)
		return ret;

	ret = handle->exp.ir_op;

	subtilis_exp_delete(handle);

	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
callq 0x12e0e
pushq $-0x1
popq %rbx
cmpl $0x0, (%r14)
jne 0x1ff2c
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1e00b
cmpl $0x0, (%r14)
jne 0x1ff2c
movq 0x148(%rax), %rbx
movq %rax, %rdi
callq 0x29d88
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_file.c
// Function: parse_1arg_bkt_file_op
static subtilis_exp_t *parse_1arg_bkt_file_op(subtilis_parser_t *p,
					      subtilis_token_t *t,
					      subtilis_op_instr_type_t itype,
					      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, "(")) {
		subtilis_error_set_expected(err, "( ", tbuf, p->l->stream->name,
					    p->l->line);
		return NULL;
	}

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

	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);
		goto cleanup;
	}

	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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
movq %rcx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x1ffb1
movq %r14, %rdi
callq 0x12a25
cmpl $0x2, (%r14)
jne 0x1ff81
cmpb $0x28, (%rax)
jne 0x1ff81
cmpb $0x0, 0x1(%rax)
je 0x1ffc0
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x4d966(%rip), %r10     # 0x6d8f9
leaq 0x4d918(%rip), %rdx     # 0x6d8b2
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0xa6
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1fee7
cmpl $0x0, (%rbx)
jne 0x1ffb1
movq 0x48(%r15), %rdi
movl %ebp, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0x2a981
cmpl $0x0, (%rbx)
jne 0x1ffb1
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x29c49
cmpl $0x0, (%rbx)
jne 0x1ffb1
movl %r12d, %edi
movq %rbx, %rsi
callq 0x2a336
cmpl $0x0, (%rbx)
jne 0x1ffb1
movq %rax, %r12
movq %r14, %rdi
callq 0x12a25
cmpl $0x2, (%r14)
jne 0x20028
cmpb $0x29, (%rax)
jne 0x20028
cmpb $0x0, 0x1(%rax)
je 0x20065
movq (%r15), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x4d8bf(%rip), %r10     # 0x6d8f9
leaq 0x50f81(%rip), %rdx     # 0x70fc2
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0xb1
pushq %r10
callq 0x140cd
popq %rax
popq %rcx
movq %r12, %rdi
callq 0x29d88
jmp 0x1ffb1
movq (%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x20058
jmp 0x1ffb4
// File: /workspace/github_c_makefile_star2_O2/markdryan[P]subtilis/frontend/parser_file.c
// Function: subtilis_parser_bput
void subtilis_parser_bput(subtilis_parser_t *p, subtilis_token_t *t,
			  subtilis_error_t *err)
{
	subtilis_ir_operand_t handle;
	const char *tbuf;
	subtilis_exp_t *val;

	handle = prv_parse_handle(p, 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;

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

	subtilis_ir_section_add_instr_no_reg2(
	    p->current, SUBTILIS_OP_INSTR_BPUT, val->exp.ir_op, handle, err);
	subtilis_exp_delete(val);
	if (err->type != SUBTILIS_ERROR_OK)
		return;

	subtilis_exp_handle_errors(p, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x1fee7
cmpl $0x0, (%rbx)
je 0x2009e
addq $0x8, %rsp
jmp 0x200ed
movq %rax, %r15
movq %r12, %rdi
callq 0x12a25
cmpl $0x2, (%r12)
jne 0x200bb
cmpb $0x2c, (%rax)
jne 0x200bb
cmpb $0x0, 0x1(%rax)
je 0x200f5
movq (%r14), %rcx
movq 0x30(%rcx), %r8
movl 0x38(%rcx), %r9d
leaq 0x4d82c(%rip), %r10     # 0x6d8f9
leaq 0x4d4be(%rip), %rdx     # 0x6d592
pushq $0x1d
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
pushq $0xd4
pushq %r10
callq 0x140cd
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x12e0e
cmpl $0x0, (%rbx)
jne 0x20098
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1e00b
cmpl $0x0, (%rbx)
jne 0x20098
movq %rax, %r12
movq 0x48(%r14), %rdi
movq 0x148(%rax), %rdx
movl $0x90, %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x2a9a4
movq %r12, %rdi
callq 0x29d88
cmpl $0x0, (%rbx)
jne 0x20098
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x29c49