LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_new_context
_RULE_END




ParserContext * fe_parser_new_context(
	const char *file,
	const char *source,
	int len,
	int arch
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	LexerContext *lexctx = fe_lexer_new_context(file, source, len);
	lexer_parse(lexctx);

	FeParserContextData data;
	data.align_node = NULL;
	data.packed_node = NULL;

	ParserContext *ctx = parser_new_context_with_data(
		lexctx, sizeof(data), &data
	);
	ctx->arch = arch;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x22c4b
testq %rsi, %rsi
je 0x22c6a
testl %edx, %edx
js 0x22c89
movl %ecx, %ebx
callq 0x1fed0
movq %rax, %r14
movq %rax, %rdi
callq 0x44d1
xorps %xmm0, %xmm0
leaq -0x20(%rbp), %rdx
movaps %xmm0, (%rdx)
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x5c34
movl %ebx, 0x30(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x18da7(%rip), %rdi     # 0x3b9f9
leaq 0x227d7(%rip), %rsi     # 0x45430
leaq 0x22885(%rip), %rcx     # 0x454e5
movl $0x8aa, %edx            # imm = 0x8AA
callq 0x30a0
leaq 0x188b5(%rip), %rdi     # 0x3b526
leaq 0x227b8(%rip), %rsi     # 0x45430
leaq 0x22866(%rip), %rcx     # 0x454e5
movl $0x8ab, %edx            # imm = 0x8AB
callq 0x30a0
leaq 0x1889d(%rip), %rdi     # 0x3b52d
leaq 0x22799(%rip), %rsi     # 0x45430
leaq 0x22847(%rip), %rcx     # 0x454e5
movl $0x8ac, %edx            # imm = 0x8AC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_print_ast
void fe_parser_print_ast(ParserContext * ctx, FILE *file) {
	assert(ctx);
	assert(ctx->ast);
	assert(file);

	_print_ast(ctx->ast, file, 0, '\t');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23200
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x2321f
testq %rsi, %rsi
je 0x2323e
xorl %edx, %edx
popq %rbp
jmp 0x2325d
leaq 0x1abbd(%rip), %rdi     # 0x3ddc4
leaq 0x22222(%rip), %rsi     # 0x45430
leaq 0x2237f(%rip), %rcx     # 0x45594
movl $0x8eb, %edx            # imm = 0x8EB
callq 0x30a0
leaq 0x1b1a9(%rip), %rdi     # 0x3e3cf
leaq 0x22203(%rip), %rsi     # 0x45430
leaq 0x22360(%rip), %rcx     # 0x45594
movl $0x8ec, %edx            # imm = 0x8EC
callq 0x30a0
leaq 0x187b4(%rip), %rdi     # 0x3b9f9
leaq 0x221e4(%rip), %rsi     # 0x45430
leaq 0x22341(%rip), %rcx     # 0x45594
movl $0x8ed, %edx            # imm = 0x8ED
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: print_ast
static void _print_ast(ParserASTNode *node, FILE *file, int level, char padchr) {
	assert(node);
	assert(file);
	assert(level >= 0);

	for (int i = 0; i < level; i++) {
		fputc(padchr, file);
	}

	fprintf(
		file,
		"@%s#%x#%p#%p",
		node->type_name != NULL ? node->type_name : "N/A",
		node->type,
		node->parent,
		node
	);
	if (node->token != NULL) {
		fputc('(', file);
		for (int i = 0; i < node->token->len; i++) {
			fputc(*(node->token->content + i), file);
		}
		fprintf(file, "#%x)", node->token->type);
	}
	fputc('\n', file);

	for (int i = 0; i < node->nchilds; i++) {
		_print_ast(node->childs[i], file, level + 1, padchr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x23355
movl %edx, %ebx
testl %edx, %edx
js 0x23374
movq %rsi, %r14
movq %rdi, %r15
pushq $0x9
popq %r12
movl %ebx, %r13d
subl $0x1, %r13d
jb 0x2329e
movl %r12d, %edi
movq %r14, %rsi
callq 0x30c0
jmp 0x2328b
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x23bbb(%rip), %rdx     # 0x46e67
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x23b9c(%rip), %rsi     # 0x46e5a
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30e0
cmpq $0x0, 0x10(%r15)
je 0x23316
pushq $0x28
popq %rdi
movq %r14, %rsi
callq 0x30c0
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movslq 0x4(%rax), %rcx
cmpq %rcx, %r12
jge 0x23303
movq 0x8(%rax), %rax
movsbl (%rax,%r12), %edi
movq %r14, %rsi
callq 0x30c0
incq %r12
jmp 0x232e0
movl (%rax), %edx
leaq 0x23b5f(%rip), %rsi     # 0x46e6b
movq %r14, %rdi
xorl %eax, %eax
callq 0x30e0
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x30c0
incl %ebx
xorl %r12d, %r12d
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jge 0x23346
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2325d
incq %r12
jmp 0x23326
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ca96(%rip), %rdi     # 0x3fdf2
leaq 0x220cd(%rip), %rsi     # 0x45430
leaq 0x23ab1(%rip), %rcx     # 0x46e1b
movl $0x8cc, %edx            # imm = 0x8CC
callq 0x30a0
leaq 0x23ad4(%rip), %rdi     # 0x46e4f
leaq 0x220ae(%rip), %rsi     # 0x45430
leaq 0x23a92(%rip), %rcx     # 0x46e1b
movl $0x8ce, %edx            # imm = 0x8CE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint32_val
uint32_t fe_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

	return fe_lexer_get_uint32_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x233b6
testq %rsi, %rsi
je 0x233d5
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x233f4
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1ff78
leaq 0x1aa07(%rip), %rdi     # 0x3ddc4
leaq 0x2206c(%rip), %rsi     # 0x45430
leaq 0x221fb(%rip), %rcx     # 0x455c6
movl $0x8f6, %edx            # imm = 0x8F6
callq 0x30a0
leaq 0x1ca16(%rip), %rdi     # 0x3fdf2
leaq 0x2204d(%rip), %rsi     # 0x45430
leaq 0x221dc(%rip), %rcx     # 0x455c6
movl $0x8f7, %edx            # imm = 0x8F7
callq 0x30a0
leaq 0x2220f(%rip), %rdi     # 0x4560a
leaq 0x2202e(%rip), %rsi     # 0x45430
leaq 0x221bd(%rip), %rcx     # 0x455c6
movl $0x8f8, %edx            # imm = 0x8F8
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint64_val
uint64_t fe_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

	return fe_lexer_get_uint64_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23436
testq %rsi, %rsi
je 0x23455
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x23474
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x20037
leaq 0x1a987(%rip), %rdi     # 0x3ddc4
leaq 0x21fec(%rip), %rsi     # 0x45430
leaq 0x221e2(%rip), %rcx     # 0x4562d
movl $0x901, %edx            # imm = 0x901
callq 0x30a0
leaq 0x1c996(%rip), %rdi     # 0x3fdf2
leaq 0x21fcd(%rip), %rsi     # 0x45430
leaq 0x221c3(%rip), %rcx     # 0x4562d
movl $0x902, %edx            # imm = 0x902
callq 0x30a0
leaq 0x2218f(%rip), %rdi     # 0x4560a
leaq 0x21fae(%rip), %rsi     # 0x45430
leaq 0x221a4(%rip), %rcx     # 0x4562d
movl $0x903, %edx            # imm = 0x903
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint_val
uint64_t fe_parser_get_uint_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

	int arch = ctx->arch;
	if (arch == FE_ARCH_32) {
		return fe_parser_get_uint32_val(ctx, node);
	} else if (arch == FE_ARCH_64) {
		return fe_parser_get_uint64_val(ctx, node);
	} else {
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x234c5
testq %rsi, %rsi
je 0x234e4
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x23503
movl 0x30(%rdi), %eax
cmpl $0x2, %eax
je 0x234bf
cmpl $0x1, %eax
jne 0x23522
callq 0x23393
movl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x23413
leaq 0x1a8f8(%rip), %rdi     # 0x3ddc4
leaq 0x21f5d(%rip), %rsi     # 0x45430
leaq 0x22197(%rip), %rcx     # 0x45671
movl $0x90c, %edx            # imm = 0x90C
callq 0x30a0
leaq 0x1c907(%rip), %rdi     # 0x3fdf2
leaq 0x21f3e(%rip), %rsi     # 0x45430
leaq 0x22178(%rip), %rcx     # 0x45671
movl $0x90d, %edx            # imm = 0x90D
callq 0x30a0
leaq 0x22100(%rip), %rdi     # 0x4560a
leaq 0x21f1f(%rip), %rsi     # 0x45430
leaq 0x22159(%rip), %rcx     # 0x45671
movl $0x90e, %edx            # imm = 0x90E
callq 0x30a0
leaq 0x18e37(%rip), %rdi     # 0x3c360
leaq 0x21f00(%rip), %rsi     # 0x45430
leaq 0x2213a(%rip), %rcx     # 0x45671
movl $0x916, %edx            # imm = 0x916
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_float_val
float fe_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_REAL);

	return fe_lexer_get_float_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23564
testq %rsi, %rsi
je 0x23583
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x235a2
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x200f6
leaq 0x1a859(%rip), %rdi     # 0x3ddc4
leaq 0x21ebe(%rip), %rsi     # 0x45430
leaq 0x2213a(%rip), %rcx     # 0x456b3
movl $0x91e, %edx            # imm = 0x91E
callq 0x30a0
leaq 0x1c868(%rip), %rdi     # 0x3fdf2
leaq 0x21e9f(%rip), %rsi     # 0x45430
leaq 0x2211b(%rip), %rcx     # 0x456b3
movl $0x91f, %edx            # imm = 0x91F
callq 0x30a0
leaq 0x2214a(%rip), %rdi     # 0x456f3
leaq 0x21e80(%rip), %rsi     # 0x45430
leaq 0x220fc(%rip), %rcx     # 0x456b3
movl $0x920, %edx            # imm = 0x920
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_double_val
double fe_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_REAL);

	return fe_lexer_get_double_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x235e4
testq %rsi, %rsi
je 0x23603
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x23622
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x20176
leaq 0x1a7d9(%rip), %rdi     # 0x3ddc4
leaq 0x21e3e(%rip), %rsi     # 0x45430
leaq 0x2211d(%rip), %rcx     # 0x45716
movl $0x929, %edx            # imm = 0x929
callq 0x30a0
leaq 0x1c7e8(%rip), %rdi     # 0x3fdf2
leaq 0x21e1f(%rip), %rsi     # 0x45430
leaq 0x220fe(%rip), %rcx     # 0x45716
movl $0x92a, %edx            # imm = 0x92A
callq 0x30a0
leaq 0x220ca(%rip), %rdi     # 0x456f3
leaq 0x21e00(%rip), %rsi     # 0x45430
leaq 0x220df(%rip), %rcx     # 0x45716
movl $0x92b, %edx            # imm = 0x92B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_char_val
char fe_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_CHAR);

	return fe_lexer_get_char_val(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23664
testq %rsi, %rsi
je 0x23683
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x236a2
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x201f6
leaq 0x1a759(%rip), %rdi     # 0x3ddc4
leaq 0x21dbe(%rip), %rsi     # 0x45430
leaq 0x220df(%rip), %rcx     # 0x45758
movl $0x934, %edx            # imm = 0x934
callq 0x30a0
leaq 0x1c768(%rip), %rdi     # 0x3fdf2
leaq 0x21d9f(%rip), %rsi     # 0x45430
leaq 0x220c0(%rip), %rcx     # 0x45758
movl $0x935, %edx            # imm = 0x935
callq 0x30a0
leaq 0x220ed(%rip), %rdi     # 0x45796
leaq 0x21d80(%rip), %rsi     # 0x45430
leaq 0x220a1(%rip), %rcx     # 0x45758
movl $0x936, %edx            # imm = 0x936
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_var_symbol_to_node
ParserSymbol * fe_parser_add_var_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

	FeParserVarSymbolData data;
	data.type = var_type;
	data.type_node = var_type_node;
	data.func_symbol = NULL;
	data.has_code_gen_name = false;

	ParserSymbol *symbol = parser_add_symbol_to_node(
		ctx,
		node,
		FE_SYM_VAR,
		token,
		sizeof(data),
		&data
	);
	symbol->releaser = _var_symbol_releaser;

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
testq %rdi, %rdi
je 0x2375d
testq %rsi, %rsi
je 0x2377c
movq %rdx, %rax
testq %rdx, %rdx
je 0x2379b
testb %cl, %cl
je 0x237ba
testq %r8, %r8
je 0x237d9
leaq -0x38(%rbp), %r9
movb %cl, (%r9)
movq %r8, 0x8(%r9)
andq $0x0, 0x10(%r9)
movb $0x0, 0x18(%r9)
pushq $0x1
popq %rdx
pushq $0x38
popq %r8
movq %rax, %rcx
callq 0x6820
leaq -0x92(%rip), %rcx       # 0x236c1
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
leaq 0x1a660(%rip), %rdi     # 0x3ddc4
leaq 0x21cc5(%rip), %rsi     # 0x45430
leaq 0x22071(%rip), %rcx     # 0x457e3
movl $0x94d, %edx            # imm = 0x94D
callq 0x30a0
leaq 0x1c66f(%rip), %rdi     # 0x3fdf2
leaq 0x21ca6(%rip), %rsi     # 0x45430
leaq 0x22052(%rip), %rcx     # 0x457e3
movl $0x94e, %edx            # imm = 0x94E
callq 0x30a0
leaq 0x2507a(%rip), %rdi     # 0x4881c
leaq 0x21c87(%rip), %rsi     # 0x45430
leaq 0x22033(%rip), %rcx     # 0x457e3
movl $0x94f, %edx            # imm = 0x94F
callq 0x30a0
leaq 0x2209b(%rip), %rdi     # 0x4585c
leaq 0x21c68(%rip), %rsi     # 0x45430
leaq 0x22014(%rip), %rcx     # 0x457e3
movl $0x950, %edx            # imm = 0x950
callq 0x30a0
leaq 0x22089(%rip), %rdi     # 0x45869
leaq 0x21c49(%rip), %rsi     # 0x45430
leaq 0x21ff5(%rip), %rcx     # 0x457e3
movl $0x951, %edx            # imm = 0x951
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_struct_member_var_symbol_to_symbol
ParserSymbol * fe_parser_add_struct_member_var_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node
) {
	assert(ctx);
	assert(symbol);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

	FeParserStructMemberVarSymbolData data;
	data.type = var_type;
	data.type_node = var_type_node;

	return parser_add_symbol_to_symbol(
		ctx,
		symbol,
		FE_SYM_STRUCT_MEMBER_VAR,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testq %rdi, %rdi
je 0x23843
testq %rsi, %rsi
je 0x23862
movq %rdx, %rax
testq %rdx, %rdx
je 0x23881
testb %cl, %cl
je 0x238a0
testq %r8, %r8
je 0x238bf
leaq -0x10(%rbp), %r9
movb %cl, (%r9)
movq %r8, 0x8(%r9)
pushq $0x5
popq %rdx
pushq $0x10
popq %r8
movq %rax, %rcx
callq 0x6b48
addq $0x10, %rsp
popq %rbp
retq
leaq 0x1a57a(%rip), %rdi     # 0x3ddc4
leaq 0x21bdf(%rip), %rsi     # 0x45430
leaq 0x2201f(%rip), %rcx     # 0x45877
movl $0x96d, %edx            # imm = 0x96D
callq 0x30a0
leaq 0x1c713(%rip), %rdi     # 0x3ff7c
leaq 0x21bc0(%rip), %rsi     # 0x45430
leaq 0x22000(%rip), %rcx     # 0x45877
movl $0x96e, %edx            # imm = 0x96E
callq 0x30a0
leaq 0x24f94(%rip), %rdi     # 0x4881c
leaq 0x21ba1(%rip), %rsi     # 0x45430
leaq 0x21fe1(%rip), %rcx     # 0x45877
movl $0x96f, %edx            # imm = 0x96F
callq 0x30a0
leaq 0x21fb5(%rip), %rdi     # 0x4585c
leaq 0x21b82(%rip), %rsi     # 0x45430
leaq 0x21fc2(%rip), %rcx     # 0x45877
movl $0x970, %edx            # imm = 0x970
callq 0x30a0
leaq 0x21fa3(%rip), %rdi     # 0x45869
leaq 0x21b63(%rip), %rsi     # 0x45430
leaq 0x21fa3(%rip), %rcx     # 0x45877
movl $0x971, %edx            # imm = 0x971
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_new_struct_symbol
ParserSymbol * fe_parser_new_struct_symbol(
	ParserContext *ctx,
	LexerToken *token,
	ParserASTNode *struct_node,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(token);
	assert(body_node);

	FeParserStructSymbolData data;
	data.struct_node = struct_node;
	data.body_node = body_node;
	data.dummy = dummy;

	return parser_new_symbol(
		ctx,
		FE_SYM_STRUCT,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x2391e
movq %rsi, %rax
testq %rsi, %rsi
je 0x2393d
testq %rcx, %rcx
je 0x2395c
leaq -0x18(%rbp), %r9
movq %rdx, (%r9)
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
pushq $0x2
popq %rsi
pushq $0x18
popq %rcx
movq %rax, %rdx
movq %r9, %r8
callq 0x64ee
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1a49f(%rip), %rdi     # 0x3ddc4
leaq 0x21b04(%rip), %rsi     # 0x45430
leaq 0x21fcc(%rip), %rcx     # 0x458ff
movl $0x988, %edx            # imm = 0x988
callq 0x30a0
leaq 0x24ed8(%rip), %rdi     # 0x4881c
leaq 0x21ae5(%rip), %rsi     # 0x45430
leaq 0x21fad(%rip), %rcx     # 0x458ff
movl $0x989, %edx            # imm = 0x989
callq 0x30a0
leaq 0x244d1(%rip), %rdi     # 0x47e34
leaq 0x21ac6(%rip), %rsi     # 0x45430
leaq 0x21f8e(%rip), %rcx     # 0x458ff
movl $0x98a, %edx            # imm = 0x98A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_struct_symbol_to_node
ParserSymbol * fe_parser_add_struct_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(body_node);

	FeParserStructSymbolData data;
	data.body_node = body_node;
	data.dummy = dummy;

	return parser_add_symbol_to_node(
		ctx,
		node,
		FE_SYM_STRUCT,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x239bb
testq %rsi, %rsi
je 0x239da
movq %rdx, %rax
testq %rdx, %rdx
je 0x239f9
testq %rcx, %rcx
je 0x23a18
leaq -0x18(%rbp), %r9
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
pushq $0x2
popq %rdx
pushq $0x18
popq %r8
movq %rax, %rcx
callq 0x6820
addq $0x20, %rsp
popq %rbp
retq
leaq 0x1a402(%rip), %rdi     # 0x3ddc4
leaq 0x21a67(%rip), %rsi     # 0x45430
leaq 0x21fa1(%rip), %rcx     # 0x45971
movl $0x9a1, %edx            # imm = 0x9A1
callq 0x30a0
leaq 0x1c411(%rip), %rdi     # 0x3fdf2
leaq 0x21a48(%rip), %rsi     # 0x45430
leaq 0x21f82(%rip), %rcx     # 0x45971
movl $0x9a2, %edx            # imm = 0x9A2
callq 0x30a0
leaq 0x24e1c(%rip), %rdi     # 0x4881c
leaq 0x21a29(%rip), %rsi     # 0x45430
leaq 0x21f63(%rip), %rcx     # 0x45971
movl $0x9a3, %edx            # imm = 0x9A3
callq 0x30a0
leaq 0x24415(%rip), %rdi     # 0x47e34
leaq 0x21a0a(%rip), %rsi     # 0x45430
leaq 0x21f44(%rip), %rcx     # 0x45971
movl $0x9a4, %edx            # imm = 0x9A4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_func_symbol_to_node
ParserSymbol * fe_parser_add_func_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	ParserASTNode *params_node,
	ParserASTNode *return_type_node,
	bool dummy
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(params_node);

	FeParserFuncSymbolData data;
	data.params_node = params_node;
	data.return_type_node = return_type_node;
	data.dummy = dummy;
	data.counter = 0;

	ParserASTNode *func_type_node = _NEW_NODE(ctx, FE_NODE_TYPE_FUNC, NULL);
	parser_add_child(ctx, func_type_node, params_node);
	if (return_type_node != NULL) {
		parser_add_child(ctx, func_type_node, return_type_node);
	}

	data.func_type_node = func_type_node;

	ParserASTNode *func_pointer_type_node = _NEW_NODE(ctx, FE_NODE_TYPE_POINTER, NULL);
	parser_add_child(ctx, func_pointer_type_node, func_type_node);

	data.func_pointer_type_node = func_pointer_type_node;

	return parser_add_symbol_to_node(
		ctx,
		node,
		FE_SYM_FUNC,
		token,
		sizeof(data),
		&data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x23b20
movq %rsi, %r14
testq %rsi, %rsi
je 0x23b3f
testq %rdx, %rdx
je 0x23b5e
movq %rcx, %r13
movq %rdx, -0x30(%rbp)
testq %rcx, %rcx
je 0x23b7d
movq %r8, %r12
movq %rdi, %r15
movq %r13, -0x58(%rbp)
movq %r8, -0x50(%rbp)
movb %r9b, -0x38(%rbp)
andl $0x0, -0x34(%rbp)
leaq 0x1b5a6(%rip), %rdx     # 0x3f039
movl $0x430, %esi            # imm = 0x430
xorl %ecx, %ecx
callq 0x22a02
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x63c4
testq %r12, %r12
je 0x23ac3
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x63c4
leaq -0x58(%rbp), %r12
movq %rbx, 0x10(%r12)
leaq 0x1b45b(%rip), %rdx     # 0x3ef2e
movq %r15, %rdi
movl $0x440, %esi            # imm = 0x440
xorl %ecx, %ecx
callq 0x22a02
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x63c4
movq %r13, 0x18(%r12)
pushq $0x3
popq %rdx
pushq $0x28
popq %r8
movq %r15, %rdi
movq %r14, %rsi
movq -0x30(%rbp), %rcx
movq %r12, %r9
callq 0x6820
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a29d(%rip), %rdi     # 0x3ddc4
leaq 0x21902(%rip), %rsi     # 0x45430
leaq 0x21eb6(%rip), %rcx     # 0x459eb
movl $0x9bc, %edx            # imm = 0x9BC
callq 0x30a0
leaq 0x1c2ac(%rip), %rdi     # 0x3fdf2
leaq 0x218e3(%rip), %rsi     # 0x45430
leaq 0x21e97(%rip), %rcx     # 0x459eb
movl $0x9bd, %edx            # imm = 0x9BD
callq 0x30a0
leaq 0x24cb7(%rip), %rdi     # 0x4881c
leaq 0x218c4(%rip), %rsi     # 0x45430
leaq 0x21e78(%rip), %rcx     # 0x459eb
movl $0x9be, %edx            # imm = 0x9BE
callq 0x30a0
leaq 0x21ef0(%rip), %rdi     # 0x45a74
leaq 0x218a5(%rip), %rsi     # 0x45430
leaq 0x21e59(%rip), %rcx     # 0x459eb
movl $0x9bf, %edx            # imm = 0x9BF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_has_unsigned_mark
bool fe_parser_has_unsigned_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

	return fe_lexer_has_unsigned_mark(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23bbf
testq %rsi, %rsi
je 0x23bde
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x23bfd
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x202f5
leaq 0x1a1fe(%rip), %rdi     # 0x3ddc4
leaq 0x21863(%rip), %rsi     # 0x45430
leaq 0x21eac(%rip), %rcx     # 0x45a80
movl $0x9e2, %edx            # imm = 0x9E2
callq 0x30a0
leaq 0x1c20d(%rip), %rdi     # 0x3fdf2
leaq 0x21844(%rip), %rsi     # 0x45430
leaq 0x21e8d(%rip), %rcx     # 0x45a80
movl $0x9e3, %edx            # imm = 0x9E3
callq 0x30a0
leaq 0x21a06(%rip), %rdi     # 0x4560a
leaq 0x21825(%rip), %rsi     # 0x45430
leaq 0x21e6e(%rip), %rcx     # 0x45a80
movl $0x9e4, %edx            # imm = 0x9E4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_has_float_mark
bool fe_parser_has_float_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_REAL);

	return fe_lexer_has_float_mark(ctx->lexctx, node->token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23c3f
testq %rsi, %rsi
je 0x23c5e
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x23c7d
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x2037e
leaq 0x1a17e(%rip), %rdi     # 0x3ddc4
leaq 0x217e3(%rip), %rsi     # 0x45430
leaq 0x21e70(%rip), %rcx     # 0x45ac4
movl $0x9ed, %edx            # imm = 0x9ED
callq 0x30a0
leaq 0x1c18d(%rip), %rdi     # 0x3fdf2
leaq 0x217c4(%rip), %rsi     # 0x45430
leaq 0x21e51(%rip), %rcx     # 0x45ac4
movl $0x9ee, %edx            # imm = 0x9EE
callq 0x30a0
leaq 0x21a6f(%rip), %rdi     # 0x456f3
leaq 0x217a5(%rip), %rsi     # 0x45430
leaq 0x21e32(%rip), %rcx     # 0x45ac4
movl $0x9ef, %edx            # imm = 0x9EF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_struct_member_type_node
static ParserASTNode * _get_struct_member_type_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *struct_token,
	LexerToken *id_token
) {
	assert(ctx);
	assert(node);
	assert(struct_token);
	assert(id_token);

	ParserSymbol *struct_symbol = parser_get_symbol_from_node(
		ctx, node, FE_SYM_STRUCT, struct_token
	);
	if (struct_symbol == NULL) {
		_SYNERR_TOKEN(ctx, struct_token, "undefined struct.");
	}

	ParserSymbol *struct_member = parser_get_symbol_from_symbol(
		ctx, struct_symbol, FE_SYM_STRUCT_MEMBER_VAR, id_token
	);
	if (struct_member == NULL) {
		_SYNERR_TOKEN(ctx, id_token, "undefined struct member.");
	}

	return FE_STRUCT_MEMBER_VAR_SYMBOL_GET_TYPE_NODE(struct_member);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x281df
testq %rsi, %rsi
je 0x281fe
movq %rdx, %r15
testq %rdx, %rdx
je 0x2821d
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2823c
movq %rdi, %r14
pushq $0x2
popq %rdx
movq %r15, %rcx
callq 0x6779
movq %rax, %r12
testq %rax, %rax
jne 0x281a8
leaq 0x1fb35(%rip), %rdx     # 0x47cd3
movq %r14, %rdi
movq %r15, %rsi
callq *0x50(%r14)
pushq $0x5
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rcx
callq 0x6ca6
movq %rax, %r15
testq %rax, %rax
jne 0x281d2
leaq 0x22379(%rip), %rdx     # 0x4a541
movq %r14, %rdi
movq %rbx, %rsi
callq *0x50(%r14)
movq 0x38(%r15), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15bde(%rip), %rdi     # 0x3ddc4
leaq 0x1f74d(%rip), %rsi     # 0x4793a
leaq 0x22366(%rip), %rcx     # 0x4a55a
movl $0xca0, %edx            # imm = 0xCA0
callq 0x30a0
leaq 0x17bed(%rip), %rdi     # 0x3fdf2
leaq 0x1f72e(%rip), %rsi     # 0x4793a
leaq 0x22347(%rip), %rcx     # 0x4a55a
movl $0xca1, %edx            # imm = 0xCA1
callq 0x30a0
leaq 0x22307(%rip), %rdi     # 0x4a52b
leaq 0x1f70f(%rip), %rsi     # 0x4793a
leaq 0x22328(%rip), %rcx     # 0x4a55a
movl $0xca2, %edx            # imm = 0xCA2
callq 0x30a0
leaq 0x222f5(%rip), %rdi     # 0x4a538
leaq 0x1f6f0(%rip), %rsi     # 0x4793a
leaq 0x22309(%rip), %rcx     # 0x4a55a
movl $0xca3, %edx            # imm = 0xCA3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_type_by_type_node
static uint8_t _get_type_by_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	switch (node->type) {
		case FE_NODE_TYPE_CHAR: {
			return FE_TYPE_CHAR;
		}
		case FE_NODE_TYPE_INT8: {
			return FE_TYPE_INT8;
		}
		case FE_NODE_TYPE_UINT8: {
			return FE_TYPE_UINT8;
		}
		case FE_NODE_TYPE_INT16: {
			return FE_TYPE_INT16;
		}
		case FE_NODE_TYPE_UINT16: {
			return FE_TYPE_UINT16;
		}
		case FE_NODE_TYPE_INT32: {
			return FE_TYPE_INT32;
		}
		case FE_NODE_TYPE_UINT32: {
			return FE_TYPE_UINT32;
		}
		case FE_NODE_TYPE_INT64: {
			return FE_TYPE_INT64;
		}
		case FE_NODE_TYPE_UINT64: {
			return FE_TYPE_UINT64;
		}
		case FE_NODE_TYPE_FLOAT: {
			return FE_TYPE_FLOAT;
		}
		case FE_NODE_TYPE_DOUBLE: {
			return FE_TYPE_DOUBLE;
		}
		case FE_NODE_TYPE_VA_LIST: {
			return FE_TYPE_VA_LIST;
		}
		case FE_NODE_TYPE_STRUCT: {
			return FE_TYPE_STRUCT;
		}
		case FE_NODE_TYPE_ARRAY: {
			return FE_TYPE_ARRAY;
		}
		case FE_NODE_TYPE_FUNC: {
			return FE_TYPE_FUNC;
		}
		case FE_NODE_TYPE_POINTER: {
			return FE_TYPE_POINTER;
		}
		case FE_NODE_TYPE_VOID: {
			return FE_TYPE_VOID;
		}
		default: {
			assert(0);
		}
	}

	return FE_TYPE_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2862d
testq %rsi, %rsi
je 0x2864c
movl (%rsi), %eax
leal -0x400(%rax), %ecx
cmpl $0x20, %ecx
ja 0x285d8
leaq 0x1e8a5(%rip), %rax     # 0x46e70
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb $0x1, %al
jmp 0x2862b
cmpl $0x430, %eax            # imm = 0x430
je 0x28625
cmpl $0x440, %eax            # imm = 0x440
je 0x28629
cmpl $0x4ff, %eax            # imm = 0x4FF
jne 0x2866b
movb $-0x1, %al
jmp 0x2862b
movb $0x4, %al
jmp 0x2862b
movb $0xe, %al
jmp 0x2862b
movb $0xc, %al
jmp 0x2862b
movb $0x9, %al
jmp 0x2862b
movb $0xd, %al
jmp 0x2862b
movb $0x8, %al
jmp 0x2862b
movb $0x6, %al
jmp 0x2862b
movb $0x5, %al
jmp 0x2862b
movb $0x2, %al
jmp 0x2862b
movb $0x7, %al
jmp 0x2862b
movb $0x3, %al
jmp 0x2862b
movb $0xb, %al
jmp 0x2862b
movb $0xa, %al
jmp 0x2862b
movb $0xf, %al
jmp 0x2862b
movb $0x10, %al
popq %rbp
retq
leaq 0x15790(%rip), %rdi     # 0x3ddc4
leaq 0x1f2ff(%rip), %rsi     # 0x4793a
leaq 0x2209b(%rip), %rcx     # 0x4a6dd
movl $0xb4, %edx
callq 0x30a0
leaq 0x1779f(%rip), %rdi     # 0x3fdf2
leaq 0x1f2e0(%rip), %rsi     # 0x4793a
leaq 0x2207c(%rip), %rcx     # 0x4a6dd
movl $0xb5, %edx
callq 0x30a0
leaq 0x13cee(%rip), %rdi     # 0x3c360
leaq 0x1f2c1(%rip), %rsi     # 0x4793a
leaq 0x2205d(%rip), %rcx     # 0x4a6dd
movl $0xec, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: fe_sem_search_node_along_parent
ParserASTNode * fe_sem_search_node_along_parent(
	ParserASTNode *node,
	...
) {
	assert(node);

	va_list arg_ptr;
	va_start(arg_ptr, node);
	
	return __search_node_along_parent(node, arg_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xa8(%rbp)
testb %al, %al
je 0x286e2
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
testq %rdi, %rdi
je 0x28719
leaq -0xd0(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq %rax, 0x10(%rsi)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x28738
addq $0xd0, %rsp
popq %rbp
retq
leaq 0x176d2(%rip), %rdi     # 0x3fdf2
leaq 0x1f213(%rip), %rsi     # 0x4793a
leaq 0x1f24f(%rip), %rcx     # 0x4797d
movl $0x15ea, %edx           # imm = 0x15EA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: _search_node_along_parent
static ParserASTNode * __search_node_along_parent(
	ParserASTNode *node,
	va_list arg_ptr
) {
	assert(node);
	assert(arg_ptr);

	unsigned int types[32];
	size_t count = 0;

	for (;;) {
		unsigned int type = va_arg(arg_ptr, unsigned int);
		if (type == FE_NODE_INVALID) {
			break;
		}
		if (count >= sizeof(types) / sizeof(unsigned int)) {
			assert(0);
		}
		types[count++] = type;
	}

	ParserASTNode *parent = node;
	while (parent != NULL) {
		for (int i = 0; i < count; i++) {
			if (parent->type == types[i]) {
				return parent;
			}
		}
		parent = parent->parent;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
testq %rsi, %rsi
je 0x287cf
movl (%rsi), %ecx
xorl %eax, %eax
cmpl $0x28, %ecx
ja 0x28762
movl %ecx, %edx
addq 0x10(%rsi), %rdx
addl $0x8, %ecx
movl %ecx, (%rsi)
jmp 0x2876e
movq 0x8(%rsi), %rdx
leaq 0x8(%rdx), %r8
movq %r8, 0x8(%rsi)
movl (%rdx), %edx
testl %edx, %edx
je 0x2879f
cmpq $0x20, %rax
jae 0x287b0
movl %edx, -0x80(%rbp,%rax,4)
incq %rax
jmp 0x28750
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2879b
movl (%rdi), %edx
leaq 0x1(%rcx), %rsi
cmpl -0x80(%rbp,%rcx,4), %edx
movq %rsi, %rcx
jne 0x28785
jmp 0x287a4
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0x28783
movq %rdi, %rax
addq $0x80, %rsp
popq %rbp
retq
leaq 0x13ba9(%rip), %rdi     # 0x3c360
leaq 0x1f17c(%rip), %rsi     # 0x4793a
leaq 0x21f59(%rip), %rcx     # 0x4a71e
movl $0x56d, %edx            # imm = 0x56D
callq 0x30a0
leaq 0x21f9b(%rip), %rdi     # 0x4a771
leaq 0x1f15d(%rip), %rsi     # 0x4793a
leaq 0x21f3a(%rip), %rcx     # 0x4a71e
movl $0x562, %edx            # imm = 0x562
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_func_symbol_by_node
static ParserSymbol * _get_func_symbol_by_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	ParserASTNode *parent = node->parent;
	while (parent != NULL) {
		if (parent->type == FE_NODE_FUNC) {
			ParserSymbol *symbol = FE_FUNC_AST_NODE_GET_SYMBOL(parent);
			assert(symbol);
			return symbol;
		}
		parent = parent->parent;
	}

	assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2883e
testq %rsi, %rsi
je 0x2885d
movq 0x30(%rsi), %rsi
testq %rsi, %rsi
je 0x2881f
cmpl $0xa00, (%rsi)          # imm = 0xA00
jne 0x28803
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x2887c
popq %rbp
retq
leaq 0x13b3a(%rip), %rdi     # 0x3c360
leaq 0x1f10d(%rip), %rsi     # 0x4793a
leaq 0x21f45(%rip), %rcx     # 0x4a779
movl $0x66c, %edx            # imm = 0x66C
callq 0x30a0
leaq 0x1557f(%rip), %rdi     # 0x3ddc4
leaq 0x1f0ee(%rip), %rsi     # 0x4793a
leaq 0x21f26(%rip), %rcx     # 0x4a779
movl $0x65f, %edx            # imm = 0x65F
callq 0x30a0
leaq 0x1758e(%rip), %rdi     # 0x3fdf2
leaq 0x1f0cf(%rip), %rsi     # 0x4793a
leaq 0x21f07(%rip), %rcx     # 0x4a779
movl $0x660, %edx            # imm = 0x660
callq 0x30a0
leaq 0x176f9(%rip), %rdi     # 0x3ff7c
leaq 0x1f0b0(%rip), %rsi     # 0x4793a
leaq 0x21ee8(%rip), %rcx     # 0x4a779
movl $0x666, %edx            # imm = 0x666
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: print_ast
static void _print_ast(ParserASTNode *node, FILE *file, int level, char padchr) {
	assert(node);
	assert(file);
	assert(level >= 0);

	for (int i = 0; i < level; i++) {
		fputc(padchr, file);
	}
	fprintf(
		file,
		"@%s#%x#%p#%p",
		node->type_name != NULL ? node->type_name : "N/A",
		node->type,
		node->parent,
		node
	);
	if (node->token != NULL) {
		fputc('(', file);
		for (int i = 0; i < node->token->len; i++) {
			fputc(*(node->token->content + i), file);
		}
		fprintf(file, "#%x)", node->token->type);
	}
	fputc('\n', file);

	if (FE_IS_EXPR_NODE(node->type)) {
		for (int i = 0; i < level; i++) {
			fputc(padchr, file);
		}
		fputs("|ExprNodeType: ", file);
		ParserASTNode *node_t = FE_EXPR_AST_NODE_GET_TYPE_NODE(node);
		if (node_t != NULL) {
			_print_type_node(node_t, file);
		}
		fputc('\n', file);
	}

	for (int i = 0; i < node->nchilds; i++) {
		_print_ast(node->childs[i], file, level + 1, padchr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28a60
movl %edx, %ebx
testl %edx, %edx
js 0x28a7f
movq %rsi, %r14
movq %rdi, %r15
pushq $0x9
popq %r12
movl %ebx, %r13d
subl $0x1, %r13d
jb 0x28955
movl %r12d, %edi
movq %r14, %rsi
callq 0x30c0
jmp 0x28942
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x1e504(%rip), %rdx     # 0x46e67
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x1e4e5(%rip), %rsi     # 0x46e5a
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30e0
cmpq $0x0, 0x10(%r15)
je 0x289cd
pushq $0x28
popq %rdi
movq %r14, %rsi
callq 0x30c0
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movslq 0x4(%rax), %rcx
cmpq %rcx, %r12
jge 0x289ba
movq 0x8(%rax), %rax
movsbl (%rax,%r12), %edi
movq %r14, %rsi
callq 0x30c0
incq %r12
jmp 0x28997
movl (%rax), %edx
leaq 0x1e4a8(%rip), %rsi     # 0x46e6b
movq %r14, %rdi
xorl %eax, %eax
callq 0x30e0
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x30c0
movzbl 0x1(%r15), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x28a2c
pushq $0x9
popq %r12
movl %ebx, %r13d
subl $0x1, %r13d
jb 0x28a01
movl %r12d, %edi
movq %r14, %rsi
callq 0x30c0
jmp 0x289ee
leaq 0x21dba(%rip), %rdi     # 0x4a7c2
movq %r14, %rsi
callq 0x30b0
movq 0x68(%r15), %rdi
testq %rdi, %rdi
je 0x28a21
movq %r14, %rsi
callq 0x31bb4
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0x30c0
incl %ebx
xorl %r12d, %r12d
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jge 0x28a51
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x28914
incq %r12
jmp 0x28a31
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1738b(%rip), %rdi     # 0x3fdf2
leaq 0x1eecc(%rip), %rsi     # 0x4793a
leaq 0x1e3a6(%rip), %rcx     # 0x46e1b
movl $0x16af, %edx           # imm = 0x16AF
callq 0x30a0
leaq 0x1e3c9(%rip), %rdi     # 0x46e4f
leaq 0x1eead(%rip), %rsi     # 0x4793a
leaq 0x1e387(%rip), %rcx     # 0x46e1b
movl $0x16b1, %edx           # imm = 0x16B1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: var
static void _var(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_VAR);
	assert(node->nchilds > 0);

	ParserASTNode *node_parent = node->parent;
	assert(node_parent);

	return _var_with_parent(ctx, node, node_parent);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0xc00, (%rsi)          # imm = 0xC00
jne 0x28abc
cmpl $0x0, 0x44(%rsi)
jle 0x28adb
movq 0x30(%rsi), %rdx
testq %rdx, %rdx
je 0x28afa
popq %rbp
jmp 0x28b19
leaq 0x1f3d4(%rip), %rdi     # 0x47e97
leaq 0x1ee70(%rip), %rsi     # 0x4793a
leaq 0x1ef5b(%rip), %rcx     # 0x47a2c
movl $0x4b9, %edx            # imm = 0x4B9
callq 0x30a0
leaq 0x15ab3(%rip), %rdi     # 0x3e595
leaq 0x1ee51(%rip), %rsi     # 0x4793a
leaq 0x1ef3c(%rip), %rcx     # 0x47a2c
movl $0x4ba, %edx            # imm = 0x4BA
callq 0x30a0
leaq 0x1ef57(%rip), %rdi     # 0x47a58
leaq 0x1ee32(%rip), %rsi     # 0x4793a
leaq 0x1ef1d(%rip), %rcx     # 0x47a2c
movl $0x4bd, %edx            # imm = 0x4BD
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_wrapper
static void _expr_wrapper(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_EXPR);

	ParserASTNode *child = node->childs[0];

	_expr(ctx, child);

	FE_EXPR_AST_NODE_COPY(node, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x29c0e
movq %rsi, %rbx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x29c2d
movq 0x48(%rbx), %rax
movq (%rax), %r14
movq %r14, %rsi
callq 0x294d8
movups 0x60(%r14), %xmm0
movups 0x70(%r14), %xmm1
movups 0x80(%r14), %xmm2
movups %xmm2, 0x80(%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x161dd(%rip), %rdi     # 0x3fdf2
leaq 0x1dd1e(%rip), %rsi     # 0x4793a
leaq 0x1fb3a(%rip), %rcx     # 0x4975d
movl $0x13d2, %edx           # imm = 0x13D2
callq 0x30a0
leaq 0x15041(%rip), %rdi     # 0x3ec75
leaq 0x1dcff(%rip), %rsi     # 0x4793a
leaq 0x1fb1b(%rip), %rcx     # 0x4975d
movl $0x13d3, %edx           # imm = 0x13D3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_type_for_assign
static bool _is_compatible_type_for_assign(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_is_compatible_primitive_type(ctx, target, source, same)) {
		return true;
	}
	if (_is_compatible_struct_type(ctx, target, source, same)) {
		return true;
	}
	if (_is_compatible_func_type(ctx, target, source, same)) {
		return true;
	}
	if (_is_compatible_pointer_type(ctx, target, source, same)) {
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x29cc2
movq %rdx, %rbx
testq %rdx, %rdx
je 0x29ce1
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x30441
testb %al, %al
jne 0x29c9b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x304a9
testb %al, %al
jne 0x29c9b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x30506
testb %al, %al
je 0x29ca8
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3065c
leaq 0x1afd7(%rip), %rdi     # 0x44ca0
leaq 0x1dc6a(%rip), %rsi     # 0x4793a
leaq 0x1fabb(%rip), %rcx     # 0x49792
movl $0x32a, %edx            # imm = 0x32A
callq 0x30a0
leaq 0x1183e(%rip), %rdi     # 0x3b526
leaq 0x1dc4b(%rip), %rsi     # 0x4793a
leaq 0x1fa9c(%rip), %rcx     # 0x49792
movl $0x32b, %edx            # imm = 0x32B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: check_expr_add_operands
static void _check_expr_add_operands(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_oprd1,
	ParserASTNode *node_oprd2,
	const char *operator,
	bool set_type
) {
	assert(ctx);
	assert(node);
	assert(node_oprd1);
	assert(node_oprd2);
	assert(operator);

	if (_is_pointer_type_node(ctx, node_oprd1) && _is_integer_type_node(ctx, node_oprd2)) {
		if (set_type) {
			FE_EXPR_AST_NODE_COPY(node, node_oprd1);
		}
	} else if (_is_number_type_node(ctx, node_oprd1) && _is_number_type_node(ctx, node_oprd2)) {
		if (set_type) {
			int32_t weight_oprd1_type = _get_primitive_type_weight_by_expr_node(ctx, node_oprd1);
			int32_t weight_oprd2_type = _get_primitive_type_weight_by_expr_node(ctx, node_oprd2);
			if (weight_oprd1_type > weight_oprd2_type) {
				FE_EXPR_AST_NODE_COPY(node, node_oprd1);
			} else {
				FE_EXPR_AST_NODE_COPY(node, node_oprd2);
			}
		}
	} else {
		_SYNERR_NODE(
			ctx,
			node,
			"binary operator '%s' do not support this operand combination.",
			operator
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rdx, %rdx
je 0x2a8e4
movq %rcx, %r15
testq %rcx, %rcx
je 0x2a903
movq %r8, %r13
movq %rsi, -0x30(%rbp)
testq %r8, %r8
je 0x2a922
movl %r9d, %ebx
movq %rdx, %r14
movq %rdi, %r12
movq %rdx, %rdi
callq 0x2b435
testb %al, %al
je 0x2a837
movq %r15, %rdi
callq 0x2b3d4
testb %al, %al
je 0x2a837
testb %bl, %bl
je 0x2a8b3
movups 0x60(%r14), %xmm0
movups 0x70(%r14), %xmm1
movups 0x80(%r14), %xmm2
movq -0x30(%rbp), %rax
movups %xmm2, 0x80(%rax)
movups %xmm1, 0x70(%rax)
movups %xmm0, 0x60(%rax)
jmp 0x2a8b3
movq %r14, %rdi
callq 0x2e394
testb %al, %al
je 0x2a889
movq %r15, %rdi
callq 0x2e394
testb %al, %al
je 0x2a889
testb %bl, %bl
je 0x2a8b3
movzbl 0x60(%r14), %edi
callq 0x28262
movl %eax, %ebx
movzbl 0x60(%r15), %edi
callq 0x28262
movq -0x30(%rbp), %rcx
addq $0x60, %rcx
cmpl %eax, %ebx
jbe 0x2a8c5
addq $0x60, %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
jmp 0x2a8d7
leaq 0x1ea30(%rip), %rsi     # 0x492c0
leaq -0x430(%rbp), %rbx
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3150
movq %r12, %rdi
movq -0x30(%rbp), %rsi
movq %rbx, %rdx
callq *0x58(%r12)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x60, %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
jmp 0x2a8b3
leaq 0x1e9b6(%rip), %rdi     # 0x492a1
leaq 0x1d048(%rip), %rsi     # 0x4793a
leaq 0x1ea05(%rip), %rcx     # 0x492fe
movl $0xfc9, %edx            # imm = 0xFC9
callq 0x30a0
leaq 0x1e9a2(%rip), %rdi     # 0x492ac
leaq 0x1d029(%rip), %rsi     # 0x4793a
leaq 0x1e9e6(%rip), %rcx     # 0x492fe
movl $0xfca, %edx            # imm = 0xFCA
callq 0x30a0
leaq 0x1e98e(%rip), %rdi     # 0x492b7
leaq 0x1d00a(%rip), %rsi     # 0x4793a
leaq 0x1e9c7(%rip), %rcx     # 0x492fe
movl $0xfcb, %edx            # imm = 0xFCB
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: check_expr_mul_operands
static void _check_expr_mul_operands(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_oprd1,
	ParserASTNode *node_oprd2,
	const char *operator,
	bool set_type
) {
	assert(ctx);
	assert(node);
	assert(node_oprd1);
	assert(node_oprd2);
	assert(operator);

	if (!_is_number_type_node(ctx, node_oprd1)
			|| !_is_number_type_node(ctx, node_oprd2)) {
		_SYNERR_NODE(
			ctx, node, "binary operator '+' and '-' need number type operand."
		);
	}

	if (set_type) {
		int32_t weight_oprd1_type = _get_primitive_type_weight_by_expr_node(ctx, node_oprd1);
		int32_t weight_oprd2_type = _get_primitive_type_weight_by_expr_node(ctx, node_oprd2);
		if (weight_oprd1_type > weight_oprd2_type) {
			FE_EXPR_AST_NODE_COPY(node, node_oprd1);
		} else {
			FE_EXPR_AST_NODE_COPY(node, node_oprd2);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rdx, %rdx
je 0x2abc3
movq %rcx, %r14
testq %rcx, %rcx
je 0x2abe2
testq %r8, %r8
je 0x2ac01
movl %r9d, %r12d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rdi
callq 0x2e394
testb %al, %al
je 0x2ab2a
movq %r14, %rdi
callq 0x2e394
testb %al, %al
jne 0x2ab69
movups 0x1e952(%rip), %xmm0    # 0x49483
leaq -0x430(%rbp), %rdx
movaps %xmm0, 0x20(%rdx)
movups 0x1e930(%rip), %xmm0    # 0x49473
movaps %xmm0, 0x10(%rdx)
movups 0x1e915(%rip), %xmm0    # 0x49463
movaps %xmm0, (%rdx)
movabsq $0x2e646e61726570, %rax # imm = 0x2E646E61726570
movq %rax, 0x2e(%rdx)
movq %r13, %rdi
movq %rbx, %rsi
callq *0x58(%r13)
testb %r12b, %r12b
je 0x2abb1
movzbl 0x60(%r15), %edi
addq $0x60, %r15
callq 0x28262
movl %eax, %r12d
movzbl 0x60(%r14), %edi
addq $0x60, %r14
callq 0x28262
cmpl %eax, %r12d
cmovaq %r15, %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, 0x60(%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm2, 0x80(%rbx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e6d7(%rip), %rdi     # 0x492a1
leaq 0x1cd69(%rip), %rsi     # 0x4793a
leaq 0x1e814(%rip), %rcx     # 0x493ec
movl $0xf42, %edx            # imm = 0xF42
callq 0x30a0
leaq 0x1e6c3(%rip), %rdi     # 0x492ac
leaq 0x1cd4a(%rip), %rsi     # 0x4793a
leaq 0x1e7f5(%rip), %rcx     # 0x493ec
movl $0xf43, %edx            # imm = 0xF43
callq 0x30a0
leaq 0x1e6af(%rip), %rdi     # 0x492b7
leaq 0x1cd2b(%rip), %rsi     # 0x4793a
leaq 0x1e7d6(%rip), %rcx     # 0x493ec
movl $0xf44, %edx            # imm = 0xF44
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: check_expr_mod_operands
static void _check_expr_mod_operands(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_oprd1,
	ParserASTNode *node_oprd2,
	const char *operator,
	bool set_type
) {
	assert(ctx);
	assert(node);
	assert(node_oprd1);
	assert(node_oprd2);
	assert(operator);

	if (!_is_integer_type_node(ctx, node_oprd1)
			|| !_is_integer_type_node(ctx, node_oprd2)) {
		_SYNERR_NODE(
			ctx,
			node,
			"binary operator '%s' need number type operand.",
			operator
		);
	}

	if (set_type) {
		int32_t weight_oprd1_type = _get_primitive_type_weight_by_expr_node(ctx, node_oprd1);
		int32_t weight_oprd2_type = _get_primitive_type_weight_by_expr_node(ctx, node_oprd2);
		if (weight_oprd1_type > weight_oprd2_type) {
			FE_EXPR_AST_NODE_COPY(node, node_oprd1);
		} else {
			FE_EXPR_AST_NODE_COPY(node, node_oprd2);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rdx, %rdx
je 0x2acf4
movq %rcx, %r14
testq %rcx, %rcx
je 0x2ad13
movl %r8d, %r12d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rdi
callq 0x2b3d4
testb %al, %al
je 0x2ac6d
movq %r14, %rdi
callq 0x2b3d4
testb %al, %al
jne 0x2ac9a
leaq 0x1e89c(%rip), %rsi     # 0x49510
leaq 0x16fae(%rip), %rdx     # 0x41c29
leaq -0x430(%rbp), %rdi
xorl %eax, %eax
callq 0x3150
movq %r13, %rdi
movq %rbx, %rsi
leaq -0x430(%rbp), %rdx
callq *0x58(%r13)
testb %r12b, %r12b
je 0x2ace2
movzbl 0x60(%r15), %edi
addq $0x60, %r15
callq 0x28262
movl %eax, %r12d
movzbl 0x60(%r14), %edi
addq $0x60, %r14
callq 0x28262
cmpl %eax, %r12d
cmovaq %r15, %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm0, 0x60(%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm2, 0x80(%rbx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e5a6(%rip), %rdi     # 0x492a1
leaq 0x1cc38(%rip), %rsi     # 0x4793a
leaq 0x1e790(%rip), %rcx     # 0x49499
movl $0xf62, %edx            # imm = 0xF62
callq 0x30a0
leaq 0x1e592(%rip), %rdi     # 0x492ac
leaq 0x1cc19(%rip), %rsi     # 0x4793a
leaq 0x1e771(%rip), %rcx     # 0x49499
movl $0xf63, %edx            # imm = 0xF63
callq 0x30a0