LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_func_symbol_to_node
ParserSymbol * be_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);

	BeParserFuncSymbolData 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, BE_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, BE_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,
		BE_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 0x23809
movq %rsi, %r14
testq %rsi, %rsi
je 0x23828
testq %rdx, %rdx
je 0x23847
movq %rcx, %r13
movq %rdx, -0x30(%rbp)
testq %rcx, %rcx
je 0x23866
movq %r8, %r12
movq %rdi, %r15
movq %r13, -0x60(%rbp)
movq %r8, -0x58(%rbp)
movb %r9b, -0x40(%rbp)
movl $0x0, -0x3c(%rbp)
leaq 0x280c1(%rip), %rdx     # 0x4b82d
movl $0x430, %esi            # imm = 0x430
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x66e1
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x69bf
testq %r12, %r12
je 0x237a2
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x69bf
leaq -0x60(%rbp), %r12
movq %rbx, 0x10(%r12)
leaq 0x21e74(%rip), %rdx     # 0x45626
movq %r15, %rdi
movl $0x440, %esi            # imm = 0x440
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x66e1
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x69bf
movq %r13, 0x18(%r12)
movl $0x30, %r8d
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
movq -0x30(%rbp), %rcx
movq %r12, %r9
callq 0x6e67
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2dac6(%rip), %rdi     # 0x512d6
leaq 0x27a51(%rip), %rsi     # 0x4b268
leaq 0x27f7a(%rip), %rcx     # 0x4b798
movl $0xa45, %edx            # imm = 0xA45
callq 0x30a0
leaq 0x1f71c(%rip), %rdi     # 0x42f4b
leaq 0x27a32(%rip), %rsi     # 0x4b268
leaq 0x27f5b(%rip), %rcx     # 0x4b798
movl $0xa46, %edx            # imm = 0xA46
callq 0x30a0
leaq 0x1bc78(%rip), %rdi     # 0x3f4c6
leaq 0x27a13(%rip), %rsi     # 0x4b268
leaq 0x27f3c(%rip), %rcx     # 0x4b798
movl $0xa47, %edx            # imm = 0xA47
callq 0x30a0
leaq 0x27fb4(%rip), %rdi     # 0x4b821
leaq 0x279f4(%rip), %rsi     # 0x4b268
leaq 0x27f1d(%rip), %rcx     # 0x4b798
movl $0xa48, %edx            # imm = 0xA48
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_unsigned_mark
bool be_parser_has_unsigned_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x238a8
testq %rsi, %rsi
je 0x238c7
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x238e6
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x204d1
leaq 0x2da27(%rip), %rdi     # 0x512d6
leaq 0x279b2(%rip), %rsi     # 0x4b268
leaq 0x27f82(%rip), %rcx     # 0x4b83f
movl $0xa6b, %edx            # imm = 0xA6B
callq 0x30a0
leaq 0x1f67d(%rip), %rdi     # 0x42f4b
leaq 0x27993(%rip), %rsi     # 0x4b268
leaq 0x27f63(%rip), %rcx     # 0x4b83f
movl $0xa6c, %edx            # imm = 0xA6C
callq 0x30a0
leaq 0x27aba(%rip), %rdi     # 0x4b3a7
leaq 0x27974(%rip), %rsi     # 0x4b268
leaq 0x27f44(%rip), %rcx     # 0x4b83f
movl $0xa6d, %edx            # imm = 0xA6D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_float_mark
bool be_parser_has_float_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23928
testq %rsi, %rsi
je 0x23947
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x23966
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x2055a
leaq 0x2d9a7(%rip), %rdi     # 0x512d6
leaq 0x27932(%rip), %rsi     # 0x4b268
leaq 0x27f46(%rip), %rcx     # 0x4b883
movl $0xa76, %edx            # imm = 0xA76
callq 0x30a0
leaq 0x1f5fd(%rip), %rdi     # 0x42f4b
leaq 0x27913(%rip), %rsi     # 0x4b268
leaq 0x27f27(%rip), %rcx     # 0x4b883
movl $0xa77, %edx            # imm = 0xA77
callq 0x30a0
leaq 0x27b23(%rip), %rdi     # 0x4b490
leaq 0x278f4(%rip), %rsi     # 0x4b268
leaq 0x27f08(%rip), %rcx     # 0x4b883
movl $0xa78, %edx            # imm = 0xA78
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: rule_expr_mul
_RULE(expr_mul)
	_RULE_RETURNED_NODE(_RULE_NAME(expr_unary)(_RULE_PARSER_CTX))

	for (;_RULE_CURRENT_NODE != NULL;) {
		_RULE_PUSH_LEXCTX
		_RULE_NEXT_TOKEN
		if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_MUL) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_MUL, expr_unary)
		} else if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_DIV) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_DIV, expr_unary)
		} else if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_MOD) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_MOD, expr_unary)
		} else {
			_RULE_POP_LEXCTX
			break;
		}
		_RULE_ABANDON_LEXCTX
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x254b0
callq 0x4662
movq %rbx, %rdi
callq 0x254cf
testq %rax, %rax
je 0x25489
movq %rax, %r13
leaq -0x50(%rbp), %r14
leaq -0x58(%rbp), %r15
movq (%rbx), %rdi
callq 0x4662
movq (%rbx), %rdi
callq 0x440e
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x2548e
movl (%rax), %eax
cmpl $0x4018, %eax           # imm = 0x4018
je 0x253f7
cmpl $0x4017, %eax           # imm = 0x4017
je 0x253b1
cmpl $0x4016, %eax           # imm = 0x4016
jne 0x2548e
movq %rbx, %rdi
callq 0x254cf
movq %rax, %r12
testq %rax, %rax
je 0x2546b
movb $0x0, -0x58(%rbp)
movl $0x0, 0x7(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x30, %r8d
movq %rbx, %rdi
movl $0xeb0, %esi            # imm = 0xEB0
leaq 0x269c1(%rip), %rdx     # 0x4bd6d
jmp 0x25437
movq %rbx, %rdi
callq 0x254cf
movq %rax, %r12
testq %rax, %rax
je 0x2546b
movb $0x0, -0x58(%rbp)
movl $0x0, 0x7(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x30, %r8d
movq %rbx, %rdi
movl $0xeb1, %esi            # imm = 0xEB1
leaq 0x26989(%rip), %rdx     # 0x4bd7e
jmp 0x25437
movq %rbx, %rdi
callq 0x254cf
movq %rax, %r12
testq %rax, %rax
je 0x2546b
movb $0x0, -0x58(%rbp)
movl $0x0, 0x7(%r14)
movq $0x0, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movl $0x30, %r8d
movq %rbx, %rdi
movl $0xeb2, %esi            # imm = 0xEB2
leaq 0x26958(%rip), %rdx     # 0x4bd8f
xorl %ecx, %ecx
movq %r15, %r9
callq 0x66e1
movq %rax, 0x30(%r13)
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x69bf
movq %rax, 0x30(%r12)
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x69bf
movq %rax, %r13
jmp 0x25473
movq (%rbx), %rdi
callq 0x46ca
testq %r12, %r12
je 0x25496
movq (%rbx), %rdi
callq 0x472b
testq %r13, %r13
jne 0x2532c
xorl %r13d, %r13d
jmp 0x25496
movq (%rbx), %rdi
callq 0x46ca
movq (%rbx), %rdi
callq 0x472b
movq %r13, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2648d(%rip), %rdi     # 0x4b944
leaq 0x25daa(%rip), %rsi     # 0x4b268
leaq 0x26879(%rip), %rcx     # 0x4bd3e
movl $0x341, %edx            # imm = 0x341
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/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 (BE_IS_EXPR_NODE(node->type)) {
		for (int i = 0; i < level; i++) {
			fputc(padchr, file);
		}
		fputs("|ExprNodeType: ", file);
		ParserASTNode *node_t = BE_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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x2ad03
movl %edx, %ebx
testl %edx, %edx
js 0x2ad22
movq %rsi, %r14
movq %rdi, %r15
je 0x2abe2
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2abd0
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x229bc(%rip), %rdx     # 0x4d5ac
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x2299d(%rip), %rsi     # 0x4d59f
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30e0
cmpq $0x0, 0x10(%r15)
je 0x2ac64
movl $0x28, %edi
movq %r14, %rsi
callq 0x30c0
movq 0x10(%r15), %rax
cmpl $0x0, 0x4(%rax)
jle 0x2ac51
xorl %r12d, %r12d
movq 0x8(%rax), %rax
movsbl (%rax,%r12), %edi
movq %r14, %rsi
callq 0x30c0
incq %r12
movq 0x10(%r15), %rax
movslq 0x4(%rax), %rcx
cmpq %rcx, %r12
jl 0x2ac30
movl (%rax), %edx
leaq 0x22956(%rip), %rsi     # 0x4d5b0
movq %r14, %rdi
xorl %eax, %eax
callq 0x30e0
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
movzbl 0x1(%r15), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2acd0
testl %ebx, %ebx
je 0x2aca3
cmpl $0x2, %ebx
movl $0x1, %r12d
cmovgel %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2ac91
leaq 0x26199(%rip), %rdi     # 0x50e43
movq %r14, %rsi
callq 0x30b0
movq 0x68(%r15), %rdi
testq %rdi, %rdi
je 0x2acc3
movq %r14, %rsi
callq 0x34e80
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
cmpl $0x0, 0x44(%r15)
jle 0x2acfa
incl %ebx
xorl %r12d, %r12d
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2aba7
incq %r12
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jl 0x2acdc
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18241(%rip), %rdi     # 0x42f4b
leaq 0x2345f(%rip), %rsi     # 0x4e170
leaq 0x22848(%rip), %rcx     # 0x4d560
movl $0x191c, %edx           # imm = 0x191C
callq 0x30a0
leaq 0x2286b(%rip), %rdi     # 0x4d594
leaq 0x23440(%rip), %rsi     # 0x4e170
leaq 0x22829(%rip), %rcx     # 0x4d560
movl $0x191e, %edx           # imm = 0x191E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: be_sem_calc_type_size
size_t be_sem_calc_type_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);

	return _calc_type_size(ctx, node, node_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2ad57
testq %rsi, %rsi
je 0x2ad76
testq %rdx, %rdx
je 0x2ad95
popq %rbp
jmp 0x2adb4
leaq 0x26578(%rip), %rdi     # 0x512d6
leaq 0x2340b(%rip), %rsi     # 0x4e170
leaq 0x2347c(%rip), %rcx     # 0x4e1e8
movl $0x1955, %edx           # imm = 0x1955
callq 0x30a0
leaq 0x181ce(%rip), %rdi     # 0x42f4b
leaq 0x233ec(%rip), %rsi     # 0x4e170
leaq 0x2345d(%rip), %rcx     # 0x4e1e8
movl $0x1956, %edx           # imm = 0x1956
callq 0x30a0
leaq 0x25aa4(%rip), %rdi     # 0x50840
leaq 0x233cd(%rip), %rsi     # 0x4e170
leaq 0x2343e(%rip), %rcx     # 0x4e1e8
movl $0x1957, %edx           # imm = 0x1957
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_struct_member_symbol
static ParserSymbol * _get_struct_member_symbol(
	ParserContext *ctx,
	ParserASTNode *node_struct_id,
	ParserASTNode *node_struct_member_id
) {
	assert(ctx);
	assert(node_struct_id);
	assert(node_struct_id->type == BE_NODE_IDENTIFIER);
	assert(node_struct_member_id);
	assert(node_struct_member_id->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol_struct = _get_struct_symbol_by_id_node(
		ctx, node_struct_id
	);

	ParserSymbol *symbol_struct_member = parser_get_symbol_from_symbol(
		ctx, symbol_struct, BE_SYM_STRUCT_MEMBER_VAR, node_struct_member_id->token
	);
	if (symbol_struct_member == NULL) {
		_SYNERR_TOKEN(ctx, node_struct_member_id->token, "invalid identifier.");
	}

	return symbol_struct_member;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2b477
movq %rsi, %r15
testq %rsi, %rsi
je 0x2b496
cmpl $0x200, (%r15)          # imm = 0x200
jne 0x2b4b5
movq %rdx, %r14
testq %rdx, %rdx
je 0x2b4d4
cmpl $0x200, (%r14)          # imm = 0x200
jne 0x2b4f3
movq %rdi, %rbx
movq 0x10(%r15), %rcx
movq %r15, %rsi
movl $0x2, %edx
callq 0x6d79
movq %rax, %r12
testq %rax, %rax
jne 0x2b43e
movq 0x10(%r15), %rsi
leaq 0x24c8c(%rip), %rdx     # 0x500c4
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x10(%r14), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x731e
movq %rax, %r15
testq %rax, %rax
jne 0x2b46b
movq 0x10(%r14), %rsi
leaq 0x24c5f(%rip), %rdx     # 0x500c4
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25e58(%rip), %rdi     # 0x512d6
leaq 0x22ceb(%rip), %rsi     # 0x4e170
leaq 0x25baf(%rip), %rcx     # 0x5103b
movl $0xfe2, %edx            # imm = 0xFE2
callq 0x30a0
leaq 0x25bf9(%rip), %rdi     # 0x51096
leaq 0x22ccc(%rip), %rsi     # 0x4e170
leaq 0x25b90(%rip), %rcx     # 0x5103b
movl $0xfe3, %edx            # imm = 0xFE3
callq 0x30a0
leaq 0x25be9(%rip), %rdi     # 0x510a5
leaq 0x22cad(%rip), %rsi     # 0x4e170
leaq 0x25b71(%rip), %rcx     # 0x5103b
movl $0xfe4, %edx            # imm = 0xFE4
callq 0x30a0
leaq 0x25bf5(%rip), %rdi     # 0x510d0
leaq 0x22c8e(%rip), %rsi     # 0x4e170
leaq 0x25b52(%rip), %rcx     # 0x5103b
movl $0xfe5, %edx            # imm = 0xFE5
callq 0x30a0
leaq 0x25bec(%rip), %rdi     # 0x510e6
leaq 0x22c6f(%rip), %rsi     # 0x4e170
leaq 0x25b33(%rip), %rcx     # 0x5103b
movl $0xfe6, %edx            # imm = 0xFE6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: expr_wrapper
static void _expr_wrapper(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_EXPR);

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

	_expr(ctx, child);

	BE_EXPR_AST_NODE_COPY(node, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2e5dd
movq %rsi, %rbx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x2e5fc
movq 0x48(%rbx), %rax
movq (%rax), %r14
movq %r14, %rsi
callq 0x2e11b
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 0x14967(%rip), %rdi     # 0x42f4b
leaq 0x1fb85(%rip), %rsi     # 0x4e170
leaq 0x215c6(%rip), %rcx     # 0x4fbb8
movl $0xe64, %edx            # imm = 0xE64
callq 0x30a0
leaq 0x215ea(%rip), %rdi     # 0x4fbed
leaq 0x1fb66(%rip), %rsi     # 0x4e170
leaq 0x215a7(%rip), %rcx     # 0x4fbb8
movl $0xe65, %edx            # imm = 0xE65
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_integer_type_node
static bool _is_integer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_integer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2ef46
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2ef65
movb 0x60(%rdi), %al
decb %al
cmpb $0x9, %al
setb %al
popq %rbp
retq
leaq 0x13ffe(%rip), %rdi     # 0x42f4b
leaq 0x1f21c(%rip), %rsi     # 0x4e170
leaq 0x20904(%rip), %rcx     # 0x4f85f
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x30a0
leaq 0x1ff2a(%rip), %rdi     # 0x4ee96
leaq 0x1f1fd(%rip), %rsi     # 0x4e170
leaq 0x208e5(%rip), %rcx     # 0x4f85f
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_pointer_type_node
static bool _is_pointer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_pointer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2efa4
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2efc3
cmpb $0x10, 0x60(%rdi)
sete %al
popq %rbp
retq
leaq 0x13fa0(%rip), %rdi     # 0x42f4b
leaq 0x1f1be(%rip), %rsi     # 0x4e170
leaq 0x208e4(%rip), %rcx     # 0x4f89d
movl $0x208, %edx            # imm = 0x208
callq 0x30a0
leaq 0x1fecc(%rip), %rdi     # 0x4ee96
leaq 0x1f19f(%rip), %rsi     # 0x4e170
leaq 0x208c5(%rip), %rcx     # 0x4f89d
movl $0x209, %edx            # imm = 0x209
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_primitive_type_node
static bool _is_primitive_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_primitive_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2f005
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2f024
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0x13f3f(%rip), %rdi     # 0x42f4b
leaq 0x1f15d(%rip), %rsi     # 0x4e170
leaq 0x208c1(%rip), %rcx     # 0x4f8db
movl $0x22a, %edx            # imm = 0x22A
callq 0x30a0
leaq 0x1fe6b(%rip), %rdi     # 0x4ee96
leaq 0x1f13e(%rip), %rsi     # 0x4e170
leaq 0x208a2(%rip), %rcx     # 0x4f8db
movl $0x22b, %edx            # imm = 0x22B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_primitive_type_weight_by_expr_node
static int32_t _get_primitive_type_weight_by_expr_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	return _get_primitive_type_weight(
		BE_EXPR_AST_NODE_GET_TYPE(node)
	);
}

// Assembly:
testq %rdi, %rdi
je 0x2f2ab
movzbl 0x60(%rdi), %edi
jmp 0x33be4
pushq %rbp
movq %rsp, %rbp
leaq 0x13c95(%rip), %rdi     # 0x42f4b
leaq 0x1eeb3(%rip), %rsi     # 0x4e170
leaq 0x20774(%rip), %rcx     # 0x4fa38
movl $0x164, %edx            # imm = 0x164
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/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 BE_NODE_TYPE_CHAR: {
			return BE_TYPE_CHAR;
		}
		case BE_NODE_TYPE_INT8: {
			return BE_TYPE_INT8;
		}
		case BE_NODE_TYPE_UINT8: {
			return BE_TYPE_UINT8;
		}
		case BE_NODE_TYPE_INT16: {
			return BE_TYPE_INT16;
		}
		case BE_NODE_TYPE_UINT16: {
			return BE_TYPE_UINT16;
		}
		case BE_NODE_TYPE_INT32: {
			return BE_TYPE_INT32;
		}
		case BE_NODE_TYPE_UINT32: {
			return BE_TYPE_UINT32;
		}
		case BE_NODE_TYPE_INT64: {
			return BE_TYPE_INT64;
		}
		case BE_NODE_TYPE_UINT64: {
			return BE_TYPE_UINT64;
		}
		case BE_NODE_TYPE_FLOAT: {
			return BE_TYPE_FLOAT;
		}
		case BE_NODE_TYPE_DOUBLE: {
			return BE_TYPE_DOUBLE;
		}
		case BE_NODE_TYPE_VA_LIST: {
			return BE_TYPE_VA_LIST;
		}
		case BE_NODE_TYPE_STRUCT: {
			return BE_TYPE_STRUCT;
		}
		case BE_NODE_TYPE_ARRAY: {
			return BE_TYPE_ARRAY;
		}
		case BE_NODE_TYPE_FUNC: {
			return BE_TYPE_FUNC;
		}
		case BE_NODE_TYPE_POINTER: {
			return BE_TYPE_POINTER;
		}
		case BE_NODE_TYPE_VOID: {
			return BE_TYPE_VOID;
		}
		default: {
			assert(0);
		}
	}

	return BE_TYPE_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x32c01
movl (%rdi), %eax
cmpl $0x42f, %eax            # imm = 0x42F
jg 0x32bac
addl $0xfffffc00, %eax       # imm = 0xFFFFFC00
cmpl $0x20, %eax
ja 0x32c20
leaq 0x1af25(%rip), %rcx     # 0x4dac4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
jmp 0x32bff
cmpl $0x430, %eax            # imm = 0x430
je 0x32bfd
cmpl $0x440, %eax            # imm = 0x440
je 0x32bf9
cmpl $0x4ff, %eax            # imm = 0x4FF
jne 0x32c20
movb $-0x1, %al
jmp 0x32bff
movb $0xa, %al
jmp 0x32bff
movb $0xc, %al
jmp 0x32bff
movb $0xb, %al
jmp 0x32bff
movb $0x7, %al
jmp 0x32bff
movb $0x6, %al
jmp 0x32bff
movb $0x5, %al
jmp 0x32bff
movb $0xe, %al
jmp 0x32bff
movb $0x4, %al
jmp 0x32bff
movb $0x9, %al
jmp 0x32bff
movb $0x3, %al
jmp 0x32bff
movb $0x2, %al
jmp 0x32bff
movb $0x8, %al
jmp 0x32bff
movb $0xd, %al
jmp 0x32bff
movb $0x10, %al
jmp 0x32bff
movb $0xf, %al
popq %rbp
retq
leaq 0x10343(%rip), %rdi     # 0x42f4b
leaq 0x1b561(%rip), %rsi     # 0x4e170
leaq 0x1c29c(%rip), %rcx     # 0x4eeb2
movl $0xb5, %edx
callq 0x30a0
leaq 0xd766(%rip), %rdi      # 0x4038d
leaq 0x1b542(%rip), %rsi     # 0x4e170
leaq 0x1c27d(%rip), %rcx     # 0x4eeb2
movl $0xec, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_int64
static int64_t _get_constexpr_int64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return (int64_t) BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node);	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		_A(POINTER)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x333db
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x333fa
cmpb $0x0, 0x70(%rdi)
je 0x33419
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x33438
leaq 0x1ab0c(%rip), %rcx     # 0x4de88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x333d9
movsbq 0x88(%rdi), %rax
jmp 0x333d9
cvttsd2si 0x88(%rdi), %rax
jmp 0x333d9
movl 0x88(%rdi), %eax
jmp 0x333d9
cvttss2si 0x88(%rdi), %rax
jmp 0x333d9
movzwl 0x88(%rdi), %eax
jmp 0x333d9
movswq 0x88(%rdi), %rax
jmp 0x333d9
movslq 0x88(%rdi), %rax
jmp 0x333d9
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0xfb69(%rip), %rdi      # 0x42f4b
leaq 0x1ad87(%rip), %rsi     # 0x4e170
leaq 0x1bfb4(%rip), %rcx     # 0x4f3a4
movl $0x69f, %edx            # imm = 0x69F
callq 0x30a0
leaq 0x1ba95(%rip), %rdi     # 0x4ee96
leaq 0x1ad68(%rip), %rsi     # 0x4e170
leaq 0x1bf95(%rip), %rcx     # 0x4f3a4
movl $0x6a0, %edx            # imm = 0x6A0
callq 0x30a0
leaq 0x1bfc3(%rip), %rdi     # 0x4f3e3
leaq 0x1ad49(%rip), %rsi     # 0x4e170
leaq 0x1bf76(%rip), %rcx     # 0x4f3a4
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x30a0
leaq 0xcf4e(%rip), %rdi      # 0x4038d
leaq 0x1ad2a(%rip), %rsi     # 0x4e170
leaq 0x1bf57(%rip), %rcx     # 0x4f3a4
movl $0x6b6, %edx            # imm = 0x6B6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_uint64
static uint64_t _get_constexpr_uint64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return (uint64_t) BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node);	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		_A(POINTER)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x3374c
cmpb $0x0, 0x70(%rdi)
je 0x3376b
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x3378a
leaq 0x1a854(%rip), %rcx     # 0x4df08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x3374a
movsbq 0x88(%rdi), %rax
jmp 0x3374a
movsd 0x88(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x1aa49(%rip), %xmm0    # 0x4e138
cvttsd2si %xmm0, %rax
jmp 0x3371f
movl 0x88(%rdi), %eax
jmp 0x3374a
movss 0x88(%rdi), %xmm0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x1aa26(%rip), %xmm0    # 0x4e140
cvttss2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x3374a
movzwl 0x88(%rdi), %eax
jmp 0x3374a
movswq 0x88(%rdi), %rax
jmp 0x3374a
movslq 0x88(%rdi), %rax
jmp 0x3374a
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0x1b743(%rip), %rdi     # 0x4ee96
leaq 0x1aa16(%rip), %rsi     # 0x4e170
leaq 0x1bf47(%rip), %rcx     # 0x4f6a8
movl $0x6d9, %edx            # imm = 0x6D9
callq 0x30a0
leaq 0x1bc71(%rip), %rdi     # 0x4f3e3
leaq 0x1a9f7(%rip), %rsi     # 0x4e170
leaq 0x1bf28(%rip), %rcx     # 0x4f6a8
movl $0x6da, %edx            # imm = 0x6DA
callq 0x30a0
leaq 0xcbfc(%rip), %rdi      # 0x4038d
leaq 0x1a9d8(%rip), %rsi     # 0x4e170
leaq 0x1bf09(%rip), %rcx     # 0x4f6a8
movl $0x6ef, %edx            # imm = 0x6EF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_float
static float _get_constexpr_float(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return (float) BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node);	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x33925
cmpb $0x0, 0x70(%rdi)
je 0x33944
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xa, %eax
ja 0x33963
leaq 0x1a6ef(%rip), %rcx     # 0x4df88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl 0x88(%rdi), %eax
jmp 0x338eb
cvtsi2ssq 0x88(%rdi), %xmm0
jmp 0x33923
movss 0x88(%rdi), %xmm0
jmp 0x33923
movswl 0x88(%rdi), %eax
jmp 0x338eb
cvtsi2ssl 0x88(%rdi), %xmm0
jmp 0x33923
movl 0x88(%rdi), %eax
jmp 0x33907
movzbl 0x88(%rdi), %eax
jmp 0x338eb
movzwl 0x88(%rdi), %eax
cvtsi2ss %eax, %xmm0
jmp 0x33923
cvtsd2ss 0x88(%rdi), %xmm0
jmp 0x33923
movq 0x88(%rdi), %rax
testq %rax, %rax
js 0x3390e
cvtsi2ss %rax, %xmm0
jmp 0x33923
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
popq %rbp
retq
leaq 0x1b56a(%rip), %rdi     # 0x4ee96
leaq 0x1a83d(%rip), %rsi     # 0x4e170
leaq 0x1bdff(%rip), %rcx     # 0x4f739
movl $0x712, %edx            # imm = 0x712
callq 0x30a0
leaq 0x1ba98(%rip), %rdi     # 0x4f3e3
leaq 0x1a81e(%rip), %rsi     # 0x4e170
leaq 0x1bde0(%rip), %rcx     # 0x4f739
movl $0x713, %edx            # imm = 0x713
callq 0x30a0
leaq 0xca23(%rip), %rdi      # 0x4038d
leaq 0x1a7ff(%rip), %rsi     # 0x4e170
leaq 0x1bdc1(%rip), %rcx     # 0x4f739
movl $0x727, %edx            # imm = 0x727
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: calc_pointer_type_increment_size
static size_t _calc_pointer_type_increment_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);
	assert(node_type->type == BE_NODE_TYPE_POINTER);
	assert(node_type->nchilds == 1);

	return _calc_type_size(ctx, node, node_type->childs[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdx, %rdx
je 0x33b87
cmpl $0x440, (%rdx)          # imm = 0x440
jne 0x33ba6
cmpl $0x1, 0x44(%rdx)
jne 0x33bc5
movq 0x48(%rdx), %rax
movq (%rax), %rdx
popq %rbp
jmp 0x2adb4
leaq 0x1ccb2(%rip), %rdi     # 0x50840
leaq 0x1a5db(%rip), %rsi     # 0x4e170
leaq 0x1bc67(%rip), %rcx     # 0x4f803
movl $0x545, %edx            # imm = 0x545
callq 0x30a0
leaq 0x11a66(%rip), %rdi     # 0x45613
leaq 0x1a5bc(%rip), %rsi     # 0x4e170
leaq 0x1bc48(%rip), %rcx     # 0x4f803
movl $0x546, %edx            # imm = 0x546
callq 0x30a0
leaq 0x1ab2a(%rip), %rdi     # 0x4e6f6
leaq 0x1a59d(%rip), %rsi     # 0x4e170
leaq 0x1bc29(%rip), %rcx     # 0x4f803
movl $0x547, %edx            # imm = 0x547
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_compatible_pointer_type
static bool _is_compatible_pointer_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_get_type_by_type_node(ctx, target) == BE_TYPE_POINTER
			&& _get_type_by_type_node(ctx, source) == BE_TYPE_POINTER) {
		if (same) {
			ParserASTNode *target_type = target->childs[0];
			ParserASTNode *source_type = source->childs[0];
			return _is_compatible_type(ctx, target_type, source_type, true);
		} else {
			if (_get_type_by_type_node(ctx, target->childs[0]) == BE_TYPE_VOID) {
				return true;
			} else {
				ParserASTNode *target_type = target->childs[0];
				ParserASTNode *source_type = source->childs[0];
				return _is_compatible_type(ctx, target_type, source_type, true);
			}
		}
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x32b74
cmpb $0x10, %al
jne 0x33ea1
movq %r14, %rdi
callq 0x32b74
cmpb $0x10, %al
jne 0x33ea1
movq 0x48(%r15), %rax
movq (%rax), %rsi
testb %r12b, %r12b
jne 0x33e85
movq %rsi, %rdi
callq 0x32b74
cmpb $-0x1, %al
je 0x33eac
movq 0x48(%r15), %rax
movq (%rax), %rsi
movq 0x48(%r14), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2f043
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x33ea3
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_bool
static bool _get_constexpr_bool(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node) != 0;	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		_A(POINTER)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x33f3d
cmpb $0x0, 0x70(%rdi)
je 0x33f5c
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x33f7b
leaq 0x1a13e(%rip), %rcx     # 0x4e020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, 0x88(%rdi)
jmp 0x33f0f
cmpq $0x0, 0x88(%rdi)
jmp 0x33f0f
cmpw $0x0, 0x88(%rdi)
jmp 0x33f0f
cmpl $0x0, 0x88(%rdi)
setne %al
popq %rbp
retq
xorpd %xmm0, %xmm0
cmpneqsd 0x88(%rdi), %xmm0
movq %xmm0, %rax
jmp 0x33f38
xorps %xmm0, %xmm0
cmpneqss 0x88(%rdi), %xmm0
movd %xmm0, %eax
andl $0x1, %eax
jmp 0x33f12
leaq 0x1af52(%rip), %rdi     # 0x4ee96
leaq 0x1a225(%rip), %rsi     # 0x4e170
leaq 0x1bbec(%rip), %rcx     # 0x4fb3e
movl $0x758, %edx            # imm = 0x758
callq 0x30a0
leaq 0x1b480(%rip), %rdi     # 0x4f3e3
leaq 0x1a206(%rip), %rsi     # 0x4e170
leaq 0x1bbcd(%rip), %rcx     # 0x4fb3e
movl $0x759, %edx            # imm = 0x759
callq 0x30a0
leaq 0xc40b(%rip), %rdi      # 0x4038d
leaq 0x1a1e7(%rip), %rsi     # 0x4e170
leaq 0x1bbae(%rip), %rcx     # 0x4fb3e
movl $0x76e, %edx            # imm = 0x76E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: _func_process_label
static void __func_process_label(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *current
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STATS_BLOCK);
	assert(current);

	if (current->type == BE_NODE_STAT_LABEL) {
		parser_add_symbol_to_node(
			ctx,
			node,
			BE_SYM_LABEL,
			current->childs[0]->token,
			0,
			NULL
		);
	}

	for (int i = 0; i < current->nchilds; i++) {
		ParserASTNode *child = current->childs[i];
		__func_process_label(ctx, node, child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0xb00, (%rsi)          # imm = 0xB00
jne 0x3434f
movq %rdx, %rbx
testq %rdx, %rdx
je 0x3436e
movq %rsi, %r14
movq %rdi, %r15
cmpl $0xb30, (%rbx)          # imm = 0xB30
jne 0x3431e
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6e67
cmpl $0x0, 0x44(%rbx)
jle 0x34346
xorl %r12d, %r12d
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x342d4
incq %r12
movslq 0x44(%rbx), %rax
cmpq %rax, %r12
jl 0x34327
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bc17(%rip), %rdi     # 0x4ff6d
leaq 0x19e13(%rip), %rsi     # 0x4e170
leaq 0x1bc2b(%rip), %rcx     # 0x4ff8f
movl $0x1781, %edx           # imm = 0x1781
callq 0x30a0
leaq 0x1bc67(%rip), %rdi     # 0x4ffdc
leaq 0x19df4(%rip), %rsi     # 0x4e170
leaq 0x1bc0c(%rip), %rcx     # 0x4ff8f
movl $0x1782, %edx           # imm = 0x1782
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_var_symbol_by_id_node
static ParserSymbol * _get_var_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx, node, BE_SYM_VAR, node->token
	);
	if (symbol == NULL) {
		_SYNERR_TOKEN(ctx, node->token, "invalid identifier.");
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x343e2
movq %rsi, %r14
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x34401
movq %rdi, %rbx
movq 0x10(%r14), %rcx
movq %r14, %rsi
movl $0x1, %edx
callq 0x6d79
movq %rax, %r15
testq %rax, %rax
jne 0x343d4
movq 0x10(%r14), %rsi
leaq 0x1bcf6(%rip), %rdx     # 0x500c4
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xeb62(%rip), %rdi      # 0x42f4b
leaq 0x19d80(%rip), %rsi     # 0x4e170
leaq 0x1bc82(%rip), %rcx     # 0x50079
movl $0xfbe, %edx            # imm = 0xFBE
callq 0x30a0
leaq 0xea2c(%rip), %rdi      # 0x42e34
leaq 0x19d61(%rip), %rsi     # 0x4e170
leaq 0x1bc63(%rip), %rcx     # 0x50079
movl $0xfbf, %edx            # imm = 0xFBF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_param_info
static void _get_param_info(
	ParserContext *ctx,
	ParserASTNode *node_param,
	_GetParamInfoResult *result
) {
	assert(ctx);
	assert(node_param);
	assert(result);

	ParserASTNode *node_type = NULL;
	uint8_t type = BE_TYPE_UNKNOWN;

	if (node_param->type == BE_NODE_IDENTIFIER) {
		ParserSymbol *symbol = _get_symbol_by_id_node(ctx, node_param);
		if (symbol->type == BE_SYM_VAR) {
			node_type = BE_VAR_SYMBOL_GET_TYPE_NODE(symbol);
		} else if (symbol->type == BE_SYM_FUNC) {
			node_type = BE_FUNC_SYMBOL_GET_FUNC_POINTER_TYPE_NODE(symbol);
		} else {
			_SYNERR_NODE(
				ctx,
				node_param,
				"expect variable name or function name."
			);
		}
	} else if (node_param->type == BE_NODE_EXPR) {
		_expr_wrapper(ctx, node_param);
		node_type = BE_EXPR_AST_NODE_GET_TYPE_NODE(node_param);
	} else {
		assert(0);
	}
	type = _get_type_by_type_node(ctx, node_type);

	result->node_type = node_type;
	result->type = type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rsi, %rsi
je 0x344e6
movq %rdx, %rbx
testq %rdx, %rdx
je 0x34505
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x3447c
cmpl $0x200, %eax            # imm = 0x200
jne 0x34524
movq %r15, %rdi
movq %r14, %rsi
callq 0x345e4
movl (%rax), %ecx
cmpl $0x3, %ecx
je 0x3448d
cmpl $0x1, %ecx
jne 0x34493
movq 0x38(%rax), %r14
jmp 0x344ca
movq %r15, %rdi
movq %r14, %rsi
callq 0x2e591
movq 0x68(%r14), %r14
jmp 0x344ca
movq 0x48(%rax), %r14
jmp 0x344ca
movups 0x1bd74(%rip), %xmm0    # 0x5020e
leaq -0x420(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movups 0x1bd52(%rip), %xmm0    # 0x501fe
movaps %xmm0, (%rdx)
movabsq $0x2e656d616e206e, %rax # imm = 0x2E656D616E206E
movq %rax, 0x1f(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq *0x58(%r15)
xorl %r14d, %r14d
movq %r14, %rdi
callq 0x32b74
movq %r14, (%rbx)
movb %al, 0x8(%rbx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bcff(%rip), %rdi     # 0x501ec
leaq 0x19c7c(%rip), %rsi     # 0x4e170
leaq 0x1bca3(%rip), %rcx     # 0x5019e
movl $0x105e, %edx           # imm = 0x105E
callq 0x30a0
leaq 0x1bceb(%rip), %rdi     # 0x501f7
leaq 0x19c5d(%rip), %rsi     # 0x4e170
leaq 0x1bc84(%rip), %rcx     # 0x5019e
movl $0x105f, %edx           # imm = 0x105F
callq 0x30a0
leaq 0xbe62(%rip), %rdi      # 0x4038d
leaq 0x19c3e(%rip), %rsi     # 0x4e170
leaq 0x1bc65(%rip), %rcx     # 0x5019e
movl $0x1075, %edx           # imm = 0x1075
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: check_param_combination2
static void _check_param_combination2(
	ParserContext *ctx,
	ParserASTNode *node,		// 用来报错时提供错误位置。
	ParserASTNode *node_type1,
	ParserASTNode *node_type2
) {
	assert(ctx);
	assert(node);
	assert(node_type1);
	assert(node_type2);

	if (!_is_compatible_type(ctx, node_type1, node_type2, true)) {
		_SYNERR_NODE(ctx, node, "invalid parameter combination.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
testq %rdx, %rdx
je 0x345a6
testq %rcx, %rcx
je 0x345c5
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
movl $0x1, %ecx
callq 0x2f043
testb %al, %al
jne 0x3459a
movups 0x1bd78(%rip), %xmm0    # 0x502f4
leaq -0x410(%rbp), %rdx
movups %xmm0, 0xf(%rdx)
movups 0x1bd57(%rip), %xmm0    # 0x502e5
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x58(%rbx)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1bd22(%rip), %rdi     # 0x502cf
leaq 0x19bbc(%rip), %rsi     # 0x4e170
leaq 0x1bcb1(%rip), %rcx     # 0x5026c
movl $0x1040, %edx           # imm = 0x1040
callq 0x30a0
leaq 0x1bd0e(%rip), %rdi     # 0x502da
leaq 0x19b9d(%rip), %rsi     # 0x4e170
leaq 0x1bc92(%rip), %rcx     # 0x5026c
movl $0x1041, %edx           # imm = 0x1041
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_symbol_by_id_node
static ParserSymbol * _get_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx, node, 0, node->token
	);
	if (symbol == NULL) {
		_SYNERR_TOKEN(ctx, node->token, "invalid identifier.");
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x34636
movq %rsi, %r14
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x34655
movq %rdi, %rbx
movq 0x10(%r14), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x6d79
movq %rax, %r15
testq %rax, %rax
jne 0x34628
movq 0x10(%r14), %rsi
leaq 0x1baa2(%rip), %rdx     # 0x500c4
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe90e(%rip), %rdi      # 0x42f4b
leaq 0x19b2c(%rip), %rsi     # 0x4e170
leaq 0x1bbda(%rip), %rcx     # 0x50225
movl $0xffb, %edx            # imm = 0xFFB
callq 0x30a0
leaq 0xe7d8(%rip), %rdi      # 0x42e34
leaq 0x19b0d(%rip), %rsi     # 0x4e170
leaq 0x1bbbb(%rip), %rcx     # 0x50225
movl $0xffc, %edx            # imm = 0xFFC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: check_stat_i_ci
static void _check_stat_i_ci(
	ParserContext *ctx,
	ParserASTNode *node,
	uint32_t node_type,
	_ResultCheckStat_I_CI *result
) {
	assert(ctx);
	assert(node);
	assert(node->type == node_type);
	assert(node->nchilds == 2);
	assert(result);

	ParserASTNode *node_target = node->childs[0];
	assert(node_target->type == BE_NODE_IDENTIFIER);
	ParserSymbol *symbol_target = _get_var_symbol_by_id_node(ctx, node_target);
	ParserASTNode *node_type_target = BE_VAR_SYMBOL_GET_TYPE_NODE(symbol_target);

	ParserASTNode *node_source = node->childs[1];
	_GetParamInfoResult result_source;
	_get_param_info(ctx, node_source, &result_source);

	result->node_target = node_target;
	result->node_type_target = node_type_target;
	result->type_target = _get_type_by_type_node(ctx, node_type_target);
	result->size_target = _calc_type_size(ctx, node, node_type_target);

	result->node_source = node_source;
	result->node_type_source = result_source.node_type;
	result->type_source = result_source.type;
	result->size_source = _calc_type_size(ctx, node, result_source.node_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, (%rsi)
jne 0x348ab
movq %rsi, %r14
cmpl $0x2, 0x44(%rsi)
jne 0x348ca
movq %rcx, %rbx
testq %rcx, %rcx
je 0x348e9
movq 0x48(%r14), %rax
movq (%rax), %r12
cmpl $0x200, (%r12)          # imm = 0x200
jne 0x34908
movq %rdi, %r15
movq %r12, %rsi
callq 0x3438d
movq 0x38(%rax), %r13
movq 0x48(%r14), %rax
movq 0x8(%rax), %rsi
movq %rsi, -0x30(%rbp)
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x34420
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
movq %r13, %rdi
callq 0x32b74
movb %al, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2adb4
movq %rax, 0x18(%rbx)
movq -0x30(%rbp), %rax
movq %rax, 0x20(%rbx)
leaq -0x40(%rbp), %rax
movq (%rax), %rdx
movq %rdx, 0x28(%rbx)
movb 0x8(%rax), %al
movb %al, 0x30(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2adb4
movq %rax, 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bf80(%rip), %rdi     # 0x50832
leaq 0x198b7(%rip), %rsi     # 0x4e170
leaq 0x1bf17(%rip), %rcx     # 0x507d7
movl $0x11df, %edx           # imm = 0x11DF
callq 0x30a0
leaq 0x19d34(%rip), %rdi     # 0x4e605
leaq 0x19898(%rip), %rsi     # 0x4e170
leaq 0x1bef8(%rip), %rcx     # 0x507d7
movl $0x11e0, %edx           # imm = 0x11E0
callq 0x30a0
leaq 0x1b907(%rip), %rdi     # 0x501f7
leaq 0x19879(%rip), %rsi     # 0x4e170
leaq 0x1bed9(%rip), %rcx     # 0x507d7
movl $0x11e1, %edx           # imm = 0x11E1
callq 0x30a0
leaq 0xe49d(%rip), %rdi      # 0x42dac
leaq 0x1985a(%rip), %rsi     # 0x4e170
leaq 0x1beba(%rip), %rcx     # 0x507d7
movl $0x11e4, %edx           # imm = 0x11E4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]enchive/src/enchive.c
// Function: warning
static void
warning(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "warning: ");
    vfprintf(stderr, fmt, ap);
    fputc('\n', stderr);
    va_end(ap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x23e3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x8bee(%rip), %r15      # 0xaff8
movq (%r15), %rcx
leaq 0x6498(%rip), %rdi      # 0x88ac
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x2320
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x22d0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x2190
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]enchive/src/optparse.h
// Function: optparse_permute
static void
optparse_permute(struct optparse *options, int index)
{
    char *nonoption = options->argv[index];
    int i;
    for (i = index; i < options->optind - 1; i++)
        options->argv[i] = options->argv[i + 1];
    options->argv[options->optind - 1] = nonoption;
}

// Assembly:
movq (%rdi), %rax
movslq %esi, %rdx
movq (%rax,%rdx,8), %rax
movslq 0xc(%rdi), %rcx
leal -0x1(%rcx), %esi
cmpl %edx, %esi
jle 0x2818
incq %rdx
movq (%rdi), %rsi
movq (%rsi,%rdx,8), %r8
movq %r8, -0x8(%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x2804
movq (%rdi), %rdx
movq %rax, -0x8(%rdx,%rcx,8)
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]enchive/src/optparse.h
// Function: optparse_error
static int
optparse_error(struct optparse *options, const char *msg, const char *data)
{
    unsigned p = 0;
    const char *sep = " -- '";
    while (*msg)
        options->errmsg[p++] = *msg++;
    while (*sep)
        options->errmsg[p++] = *sep++;
    while (p < sizeof(options->errmsg) - 2 && *data)
        options->errmsg[p++] = *data++;
    options->errmsg[p++] = '\'';
    options->errmsg[p++] = '\0';
    return '?';
}

// Assembly:
movb (%rsi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x283a
movl %eax, %r8d
movb %cl, 0x20(%rdi,%r8)
movb 0x1(%rsi,%rax), %cl
incq %rax
jmp 0x2825
movl %eax, %eax
movb $0x20, %sil
xorl %ecx, %ecx
leaq 0x5961(%rip), %r8       # 0x81a9
leal (%rax,%rcx), %r9d
movb %sil, 0x20(%rdi,%r9)
movb 0x1(%rcx,%r8), %sil
incq %rcx
cmpq $0x5, %rcx
jne 0x2848
addq %rcx, %rax
cmpl $0x3e, %eax
jae 0x2888
movl %eax, %ecx
movb (%rdx), %sil
testb %sil, %sil
je 0x288c
incq %rdx
leaq 0x1(%rcx), %rax
movb %sil, 0x20(%rdi,%rcx)
cmpq $0x3d, %rcx
movq %rax, %rcx
jb 0x2869
jmp 0x288f
movl %eax, %ecx
jmp 0x2892
movq %rcx, %rax
movq %rax, %rcx
incl %eax
movb $0x27, 0x20(%rdi,%rcx)
movb $0x0, 0x20(%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/skeeto[P]enchive/src/optparse.h
// Function: optparse_arg
OPTPARSE_API
char *
optparse_arg(struct optparse *options)
{
    char *option = options->argv[options->optind];
    options->subopt = 0;
    if (option != 0)
        options->optind++;
    return option;
}

// Assembly:
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x60(%rdi)
testq %rax, %rax
je 0x28bb
incl %ecx
movl %ecx, 0xc(%rdi)
retq