LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x25195
movq %rsi, %r14
testq %rsi, %rsi
je 0x251b4
testq %rdx, %rdx
je 0x251d3
movq %rcx, %r13
movq %rdx, -0x30(%rbp)
testq %rcx, %rcx
je 0x251f2
movq %r8, %r12
movq %rdi, %r15
movq %r13, -0x58(%rbp)
movq %r8, -0x50(%rbp)
movb %r9b, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
leaq 0x1cf31(%rip), %rdx     # 0x42029
movl $0x430, %esi            # imm = 0x430
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x65f1
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x68cf
testq %r12, %r12
je 0x2512e
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x68cf
leaq -0x58(%rbp), %r12
movq %rbx, 0x10(%r12)
leaq 0x1cde0(%rip), %rdx     # 0x41f1e
movq %r15, %rdi
movl $0x440, %esi            # imm = 0x440
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x65f1
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x68cf
movq %r13, 0x18(%r12)
movl $0x28, %r8d
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
movq -0x30(%rbp), %rcx
movq %r12, %r9
callq 0x6d30
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bc18(%rip), %rdi     # 0x40db4
leaq 0x23249(%rip), %rsi     # 0x483ec
leaq 0x237fd(%rip), %rcx     # 0x489a7
movl $0x9bc, %edx            # imm = 0x9BC
callq 0x30a0
leaq 0x1dc27(%rip), %rdi     # 0x42de2
leaq 0x2322a(%rip), %rsi     # 0x483ec
leaq 0x237de(%rip), %rcx     # 0x489a7
movl $0x9bd, %edx            # imm = 0x9BD
callq 0x30a0
leaq 0x26602(%rip), %rdi     # 0x4b7dc
leaq 0x2320b(%rip), %rsi     # 0x483ec
leaq 0x237bf(%rip), %rcx     # 0x489a7
movl $0x9be, %edx            # imm = 0x9BE
callq 0x30a0
leaq 0x23837(%rip), %rdi     # 0x48a30
leaq 0x231ec(%rip), %rsi     # 0x483ec
leaq 0x237a0(%rip), %rcx     # 0x489a7
movl $0x9bf, %edx            # imm = 0x9BF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x25234
testq %rsi, %rsi
je 0x25253
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x25272
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x217b1
leaq 0x1bb79(%rip), %rdi     # 0x40db4
leaq 0x231aa(%rip), %rsi     # 0x483ec
leaq 0x237f3(%rip), %rcx     # 0x48a3c
movl $0x9e2, %edx            # imm = 0x9E2
callq 0x30a0
leaq 0x1db88(%rip), %rdi     # 0x42de2
leaq 0x2318b(%rip), %rsi     # 0x483ec
leaq 0x237d4(%rip), %rcx     # 0x48a3c
movl $0x9e3, %edx            # imm = 0x9E3
callq 0x30a0
leaq 0x2334d(%rip), %rdi     # 0x485c6
leaq 0x2316c(%rip), %rsi     # 0x483ec
leaq 0x237b5(%rip), %rcx     # 0x48a3c
movl $0x9e4, %edx            # imm = 0x9E4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x252b4
testq %rsi, %rsi
je 0x252d3
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x252f2
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x2183a
leaq 0x1baf9(%rip), %rdi     # 0x40db4
leaq 0x2312a(%rip), %rsi     # 0x483ec
leaq 0x237b7(%rip), %rcx     # 0x48a80
movl $0x9ed, %edx            # imm = 0x9ED
callq 0x30a0
leaq 0x1db08(%rip), %rdi     # 0x42de2
leaq 0x2310b(%rip), %rsi     # 0x483ec
leaq 0x23798(%rip), %rcx     # 0x48a80
movl $0x9ee, %edx            # imm = 0x9EE
callq 0x30a0
leaq 0x233b6(%rip), %rdi     # 0x486af
leaq 0x230ec(%rip), %rsi     # 0x483ec
leaq 0x23779(%rip), %rcx     # 0x48a80
movl $0x9ef, %edx            # imm = 0x9EF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2a34a
testq %rsi, %rsi
je 0x2a369
movq %rdx, %r15
testq %rdx, %rdx
je 0x2a388
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2a3a7
movq %rdi, %r14
movl $0x2, %edx
movq %r15, %rcx
callq 0x6c89
movq %rax, %r12
testq %rax, %rax
jne 0x2a311
leaq 0x2098c(%rip), %rdx     # 0x4ac93
movq %r14, %rdi
movq %r15, %rsi
callq *0x50(%r14)
movq %r14, %rdi
movq %r12, %rsi
movl $0x5, %edx
movq %rbx, %rcx
callq 0x71d8
movq %rax, %r15
testq %rax, %rax
jne 0x2a33d
leaq 0x231ce(%rip), %rdx     # 0x4d501
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 0x16a63(%rip), %rdi     # 0x40db4
leaq 0x205a2(%rip), %rsi     # 0x4a8fa
leaq 0x231bb(%rip), %rcx     # 0x4d51a
movl $0xca0, %edx            # imm = 0xCA0
callq 0x30a0
leaq 0x18a72(%rip), %rdi     # 0x42de2
leaq 0x20583(%rip), %rsi     # 0x4a8fa
leaq 0x2319c(%rip), %rcx     # 0x4d51a
movl $0xca1, %edx            # imm = 0xCA1
callq 0x30a0
leaq 0x2315c(%rip), %rdi     # 0x4d4eb
leaq 0x20564(%rip), %rsi     # 0x4a8fa
leaq 0x2317d(%rip), %rcx     # 0x4d51a
movl $0xca2, %edx            # imm = 0xCA2
callq 0x30a0
leaq 0x2314a(%rip), %rdi     # 0x4d4f8
leaq 0x20545(%rip), %rsi     # 0x4a8fa
leaq 0x2315e(%rip), %rcx     # 0x4d51a
movl $0xca3, %edx            # imm = 0xCA3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2a7a8
testq %rsi, %rsi
je 0x2a7c7
movl (%rsi), %eax
cmpl $0x42f, %eax            # imm = 0x42F
jg 0x2a753
addl $0xfffffc00, %eax       # imm = 0xFFFFFC00
cmpl $0x20, %eax
ja 0x2a7e6
leaq 0x1f6ea(%rip), %rcx     # 0x49e30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
jmp 0x2a7a6
cmpl $0x430, %eax            # imm = 0x430
je 0x2a7a4
cmpl $0x440, %eax            # imm = 0x440
je 0x2a7a0
cmpl $0x4ff, %eax            # imm = 0x4FF
jne 0x2a7e6
movb $-0x1, %al
jmp 0x2a7a6
movb $0xa, %al
jmp 0x2a7a6
movb $0xc, %al
jmp 0x2a7a6
movb $0xb, %al
jmp 0x2a7a6
movb $0x7, %al
jmp 0x2a7a6
movb $0x6, %al
jmp 0x2a7a6
movb $0x5, %al
jmp 0x2a7a6
movb $0xe, %al
jmp 0x2a7a6
movb $0x4, %al
jmp 0x2a7a6
movb $0x9, %al
jmp 0x2a7a6
movb $0x3, %al
jmp 0x2a7a6
movb $0x2, %al
jmp 0x2a7a6
movb $0x8, %al
jmp 0x2a7a6
movb $0xd, %al
jmp 0x2a7a6
movb $0x10, %al
jmp 0x2a7a6
movb $0xf, %al
popq %rbp
retq
leaq 0x16605(%rip), %rdi     # 0x40db4
leaq 0x20144(%rip), %rsi     # 0x4a8fa
leaq 0x22ee0(%rip), %rcx     # 0x4d69d
movl $0xb4, %edx
callq 0x30a0
leaq 0x18614(%rip), %rdi     # 0x42de2
leaq 0x20125(%rip), %rsi     # 0x4a8fa
leaq 0x22ec1(%rip), %rcx     # 0x4d69d
movl $0xb5, %edx
callq 0x30a0
leaq 0x14b73(%rip), %rdi     # 0x3f360
leaq 0x20106(%rip), %rsi     # 0x4a8fa
leaq 0x22ea2(%rip), %rcx     # 0x4d69d
movl $0xec, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2a85d
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 0x2a894
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 0x2a8b3
addq $0xd0, %rsp
popq %rbp
retq
leaq 0x18547(%rip), %rdi     # 0x42de2
leaq 0x20058(%rip), %rsi     # 0x4a8fa
leaq 0x20094(%rip), %rcx     # 0x4a93d
movl $0x15ea, %edx           # imm = 0x15EA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2a94b
movl (%rsi), %ecx
xorl %eax, %eax
cmpl $0x28, %ecx
ja 0x2a8dd
movl %ecx, %edx
addq 0x10(%rsi), %rdx
addl $0x8, %ecx
movl %ecx, (%rsi)
jmp 0x2a8e9
movq 0x8(%rsi), %rdx
leaq 0x8(%rdx), %r8
movq %r8, 0x8(%rsi)
movl (%rdx), %edx
testl %edx, %edx
je 0x2a919
cmpq $0x20, %rax
jae 0x2a92c
movl %edx, -0x80(%rbp,%rax,4)
incq %rax
jmp 0x2a8cb
testq %rax, %rax
je 0x2a915
movl (%rdi), %ecx
xorl %edx, %edx
cmpl -0x80(%rbp,%rdx,4), %ecx
je 0x2a920
incq %rdx
cmpq %rdx, %rax
jne 0x2a907
movq 0x30(%rdi), %rdi
testq %rdi, %rdi
jne 0x2a8fe
xorl %edi, %edi
movq %rdi, %rax
addq $0x80, %rsp
popq %rbp
retq
leaq 0x14a2d(%rip), %rdi     # 0x3f360
leaq 0x1ffc0(%rip), %rsi     # 0x4a8fa
leaq 0x22d9d(%rip), %rcx     # 0x4d6de
movl $0x56d, %edx            # imm = 0x56D
callq 0x30a0
leaq 0x22ddf(%rip), %rdi     # 0x4d731
leaq 0x1ffa1(%rip), %rsi     # 0x4a8fa
leaq 0x22d7e(%rip), %rcx     # 0x4d6de
movl $0x562, %edx            # imm = 0x562
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2a9ba
testq %rsi, %rsi
je 0x2a9d9
movq 0x30(%rsi), %rsi
testq %rsi, %rsi
je 0x2a99b
cmpl $0xa00, (%rsi)          # imm = 0xA00
jne 0x2a97f
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x2a9f8
popq %rbp
retq
leaq 0x149be(%rip), %rdi     # 0x3f360
leaq 0x1ff51(%rip), %rsi     # 0x4a8fa
leaq 0x22d89(%rip), %rcx     # 0x4d739
movl $0x66c, %edx            # imm = 0x66C
callq 0x30a0
leaq 0x163f3(%rip), %rdi     # 0x40db4
leaq 0x1ff32(%rip), %rsi     # 0x4a8fa
leaq 0x22d6a(%rip), %rcx     # 0x4d739
movl $0x65f, %edx            # imm = 0x65F
callq 0x30a0
leaq 0x18402(%rip), %rdi     # 0x42de2
leaq 0x1ff13(%rip), %rsi     # 0x4a8fa
leaq 0x22d4b(%rip), %rcx     # 0x4d739
movl $0x660, %edx            # imm = 0x660
callq 0x30a0
leaq 0x1856d(%rip), %rdi     # 0x42f6c
leaq 0x1fef4(%rip), %rsi     # 0x4a8fa
leaq 0x22d2c(%rip), %rcx     # 0x4d739
movl $0x666, %edx            # imm = 0x666
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x2abe2
movl %edx, %ebx
testl %edx, %edx
js 0x2ac01
movq %rsi, %r14
movq %rdi, %r15
je 0x2aacb
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2aab9
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x1f34a(%rip), %rdx     # 0x49e23
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x1f32b(%rip), %rsi     # 0x49e16
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30f0
cmpq $0x0, 0x10(%r15)
je 0x2ab4d
movl $0x28, %edi
movq %r14, %rsi
callq 0x30c0
movq 0x10(%r15), %rax
cmpl $0x0, 0x4(%rax)
jle 0x2ab3a
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 0x2ab19
movl (%rax), %edx
leaq 0x1f2e4(%rip), %rsi     # 0x49e27
movq %r14, %rdi
xorl %eax, %eax
callq 0x30f0
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
movzbl 0x1(%r15), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2abaf
testl %ebx, %ebx
je 0x2ab82
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2ab70
leaq 0x22bf9(%rip), %rdi     # 0x4d782
movq %r14, %rsi
callq 0x30b0
movq 0x68(%r15), %rdi
testq %rdi, %rdi
je 0x2aba2
movq %r14, %rsi
callq 0x340a9
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
cmpl $0x0, 0x44(%r15)
jle 0x2abd9
incl %ebx
xorl %r12d, %r12d
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2aa90
incq %r12
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jl 0x2abbb
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x181f9(%rip), %rdi     # 0x42de2
leaq 0x1fd0a(%rip), %rsi     # 0x4a8fa
leaq 0x1f1e0(%rip), %rcx     # 0x49dd7
movl $0x16af, %edx           # imm = 0x16AF
callq 0x30a0
leaq 0x1f203(%rip), %rdi     # 0x49e0b
leaq 0x1fceb(%rip), %rsi     # 0x4a8fa
leaq 0x1f1c1(%rip), %rcx     # 0x49dd7
movl $0x16b1, %edx           # imm = 0x16B1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2ac3e
cmpl $0x0, 0x44(%rsi)
jle 0x2ac5d
movq 0x30(%rsi), %rdx
testq %rdx, %rdx
je 0x2ac7c
popq %rbp
jmp 0x2ac9b
leaq 0x20212(%rip), %rdi     # 0x4ae57
leaq 0x1fcae(%rip), %rsi     # 0x4a8fa
leaq 0x1fd99(%rip), %rcx     # 0x4a9ec
movl $0x4b9, %edx            # imm = 0x4B9
callq 0x30a0
leaq 0x16921(%rip), %rdi     # 0x41585
leaq 0x1fc8f(%rip), %rsi     # 0x4a8fa
leaq 0x1fd7a(%rip), %rcx     # 0x4a9ec
movl $0x4ba, %edx            # imm = 0x4BA
callq 0x30a0
leaq 0x1fd95(%rip), %rdi     # 0x4aa18
leaq 0x1fc70(%rip), %rsi     # 0x4a8fa
leaq 0x1fd5b(%rip), %rcx     # 0x4a9ec
movl $0x4bd, %edx            # imm = 0x4BD
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2bddd
movq %rsi, %rbx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x2bdfc
movq 0x48(%rbx), %rax
movq (%rax), %r14
movq %r14, %rsi
callq 0x2b6a7
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 0x16ffe(%rip), %rdi     # 0x42de2
leaq 0x1eb0f(%rip), %rsi     # 0x4a8fa
leaq 0x2092b(%rip), %rcx     # 0x4c71d
movl $0x13d2, %edx           # imm = 0x13D2
callq 0x30a0
leaq 0x15e62(%rip), %rdi     # 0x41c65
leaq 0x1eaf0(%rip), %rsi     # 0x4a8fa
leaq 0x2090c(%rip), %rcx     # 0x4c71d
movl $0x13d3, %edx           # imm = 0x13D3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2be91
movq %rdx, %rbx
testq %rdx, %rdx
je 0x2beb0
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x3286a
testb %al, %al
jne 0x2be6a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x328d2
testb %al, %al
jne 0x2be6a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3292f
testb %al, %al
je 0x2be77
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 0x32a92
leaq 0x1bdc4(%rip), %rdi     # 0x47c5c
leaq 0x1ea5b(%rip), %rsi     # 0x4a8fa
leaq 0x208ac(%rip), %rcx     # 0x4c752
movl $0x32a, %edx            # imm = 0x32A
callq 0x30a0
leaq 0x1266f(%rip), %rdi     # 0x3e526
leaq 0x1ea3c(%rip), %rsi     # 0x4a8fa
leaq 0x2088d(%rip), %rcx     # 0x4c752
movl $0x32b, %edx            # imm = 0x32B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2ce72
movq %rcx, %r14
testq %rcx, %rcx
je 0x2ce91
testq %r8, %r8
je 0x2ceb0
movl %r9d, %r12d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rdi
callq 0x30769
testb %al, %al
je 0x2cdd9
movq %r14, %rdi
callq 0x30769
testb %al, %al
jne 0x2ce18
movups 0x1f663(%rip), %xmm0    # 0x4c443
leaq -0x430(%rbp), %rdx
movaps %xmm0, 0x20(%rdx)
movups 0x1f641(%rip), %xmm0    # 0x4c433
movaps %xmm0, 0x10(%rdx)
movups 0x1f626(%rip), %xmm0    # 0x4c423
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 0x2ce60
movzbl 0x60(%r15), %edi
addq $0x60, %r15
callq 0x2a3cd
movl %eax, %r12d
movzbl 0x60(%r14), %edi
addq $0x60, %r14
callq 0x2a3cd
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 0x1f3e8(%rip), %rdi     # 0x4c261
leaq 0x1da7a(%rip), %rsi     # 0x4a8fa
leaq 0x1f525(%rip), %rcx     # 0x4c3ac
movl $0xf42, %edx            # imm = 0xF42
callq 0x30a0
leaq 0x1f3d4(%rip), %rdi     # 0x4c26c
leaq 0x1da5b(%rip), %rsi     # 0x4a8fa
leaq 0x1f506(%rip), %rcx     # 0x4c3ac
movl $0xf43, %edx            # imm = 0xF43
callq 0x30a0
leaq 0x1f3c0(%rip), %rdi     # 0x4c277
leaq 0x1da3c(%rip), %rsi     # 0x4a8fa
leaq 0x1f4e7(%rip), %rcx     # 0x4c3ac
movl $0xf44, %edx            # imm = 0xF44
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/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 0x2cfa3
movq %rcx, %r14
testq %rcx, %rcx
je 0x2cfc2
movl %r8d, %r12d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rdi
callq 0x2d683
testb %al, %al
je 0x2cf1c
movq %r14, %rdi
callq 0x2d683
testb %al, %al
jne 0x2cf49
leaq 0x1f5ad(%rip), %rsi     # 0x4c4d0
leaq 0x17cbb(%rip), %rdx     # 0x44be5
leaq -0x430(%rbp), %rdi
xorl %eax, %eax
callq 0x3160
movq %r13, %rdi
movq %rbx, %rsi
leaq -0x430(%rbp), %rdx
callq *0x58(%r13)
testb %r12b, %r12b
je 0x2cf91
movzbl 0x60(%r15), %edi
addq $0x60, %r15
callq 0x2a3cd
movl %eax, %r12d
movzbl 0x60(%r14), %edi
addq $0x60, %r14
callq 0x2a3cd
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 0x1f2b7(%rip), %rdi     # 0x4c261
leaq 0x1d949(%rip), %rsi     # 0x4a8fa
leaq 0x1f4a1(%rip), %rcx     # 0x4c459
movl $0xf62, %edx            # imm = 0xF62
callq 0x30a0
leaq 0x1f2a3(%rip), %rdi     # 0x4c26c
leaq 0x1d92a(%rip), %rsi     # 0x4a8fa
leaq 0x1f482(%rip), %rcx     # 0x4c459
movl $0xf63, %edx            # imm = 0xF63
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: check_expr_band_operands
static void _check_expr_band_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)) {
		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 0x2d0d2
movq %rcx, %r14
testq %rcx, %rcx
je 0x2d0f1
movq %r8, %r13
movq %rsi, -0x30(%rbp)
testq %r8, %r8
je 0x2d110
movq %rdx, %r15
movq %rdi, %r12
movl %r9d, %ebx
movq %rdx, %rdi
callq 0x2d683
testb %al, %al
je 0x2d077
movq %r14, %rdi
callq 0x2d683
testb %al, %al
je 0x2d077
testb %bl, %bl
je 0x2d0a1
movzbl 0x60(%r15), %edi
callq 0x2a3cd
movl %eax, %r12d
movzbl 0x60(%r14), %edi
callq 0x2a3cd
movq -0x30(%rbp), %rcx
addq $0x60, %rcx
cmpl %eax, %r12d
jbe 0x2d0b3
addq $0x60, %r15
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
jmp 0x2d0c5
leaq 0x1f202(%rip), %rsi     # 0x4c280
leaq -0x430(%rbp), %r14
movq %r14, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x3160
movq %r12, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
callq *0x58(%r12)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x60, %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
jmp 0x2d0a1
leaq 0x1f188(%rip), %rdi     # 0x4c261
leaq 0x1d81a(%rip), %rsi     # 0x4a8fa
leaq 0x1f418(%rip), %rcx     # 0x4c4ff
movl $0x113c, %edx           # imm = 0x113C
callq 0x30a0
leaq 0x1f174(%rip), %rdi     # 0x4c26c
leaq 0x1d7fb(%rip), %rsi     # 0x4a8fa
leaq 0x1f3f9(%rip), %rcx     # 0x4c4ff
movl $0x113d, %edx           # imm = 0x113D
callq 0x30a0
leaq 0x1f160(%rip), %rdi     # 0x4c277
leaq 0x1d7dc(%rip), %rsi     # 0x4a8fa
leaq 0x1f3da(%rip), %rcx     # 0x4c4ff
movl $0x113e, %edx           # imm = 0x113E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: check_expr_shift_operands
static void _check_expr_shift_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)) {
		if (set_type) {
			FE_EXPR_AST_NODE_COPY(node, node_oprd1);
		}
	} 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 0x2d48b
movq %rcx, %r13
testq %rcx, %rcx
je 0x2d4aa
movq %r8, %r15
movl %r9d, -0x2c(%rbp)
testq %r8, %r8
je 0x2d4c9
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rdi
callq 0x2d683
testb %al, %al
je 0x2d451
movq %r13, %rdi
callq 0x2d683
testb %al, %al
je 0x2d451
cmpb $0x0, -0x2c(%rbp)
je 0x2d479
movups 0x60(%r12), %xmm0
movups 0x70(%r12), %xmm1
movups 0x80(%r12), %xmm2
movups %xmm2, 0x80(%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
jmp 0x2d479
leaq 0x1ee28(%rip), %rsi     # 0x4c280
leaq -0x430(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3160
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x58(%r14)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1edcf(%rip), %rdi     # 0x4c261
leaq 0x1d461(%rip), %rsi     # 0x4a8fa
leaq 0x1f1c6(%rip), %rcx     # 0x4c666
movl $0x104f, %edx           # imm = 0x104F
callq 0x30a0
leaq 0x1edbb(%rip), %rdi     # 0x4c26c
leaq 0x1d442(%rip), %rsi     # 0x4a8fa
leaq 0x1f1a7(%rip), %rcx     # 0x4c666
movl $0x1050, %edx           # imm = 0x1050
callq 0x30a0
leaq 0x1eda7(%rip), %rdi     # 0x4c277
leaq 0x1d423(%rip), %rsi     # 0x4a8fa
leaq 0x1f188(%rip), %rcx     # 0x4c666
movl $0x1051, %edx           # imm = 0x1051
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_integer_type_node
static bool _is_integer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_integer_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2d6a6
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2d6c5
movb 0x60(%rdi), %al
decb %al
cmpb $0x9, %al
setb %al
popq %rbp
retq
leaq 0x15735(%rip), %rdi     # 0x42de2
leaq 0x1d246(%rip), %rsi     # 0x4a8fa
leaq 0x1e985(%rip), %rcx     # 0x4c040
movl $0x1b2, %edx            # imm = 0x1B2
callq 0x30a0
leaq 0x1e3cb(%rip), %rdi     # 0x4ba97
leaq 0x1d227(%rip), %rsi     # 0x4a8fa
leaq 0x1e966(%rip), %rcx     # 0x4c040
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_pointer_type_node
static bool _is_pointer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_pointer_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2d704
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2d723
cmpb $0x10, 0x60(%rdi)
sete %al
popq %rbp
retq
leaq 0x156d7(%rip), %rdi     # 0x42de2
leaq 0x1d1e8(%rip), %rsi     # 0x4a8fa
leaq 0x1e965(%rip), %rcx     # 0x4c07e
movl $0x1fe, %edx            # imm = 0x1FE
callq 0x30a0
leaq 0x1e36d(%rip), %rdi     # 0x4ba97
leaq 0x1d1c9(%rip), %rsi     # 0x4a8fa
leaq 0x1e946(%rip), %rcx     # 0x4c07e
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_primitive_type_node
static bool _is_primitive_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_primitive_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2d765
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2d784
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0x15676(%rip), %rdi     # 0x42de2
leaq 0x1d187(%rip), %rsi     # 0x4a8fa
leaq 0x1e942(%rip), %rcx     # 0x4c0bc
movl $0x220, %edx            # imm = 0x220
callq 0x30a0
leaq 0x1e30c(%rip), %rdi     # 0x4ba97
leaq 0x1d168(%rip), %rsi     # 0x4a8fa
leaq 0x1e923(%rip), %rcx     # 0x4c0bc
movl $0x221, %edx            # imm = 0x221
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_bor
static void _expr_bor(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	#define	_CHECK	\
	{	\
		assert(node->nchilds == 2);	\
	}

	uint32_t node_type = node->type;

	switch (node_type) {
		case FE_NODE_EXPR_BOR: {
			_CHECK
			ParserASTNode *node_oprd1 = node->childs[0];
			ParserASTNode *node_oprd2 = node->childs[1];
			_expr_bxor(ctx, node_oprd1);
			_expr_bxor(ctx, node_oprd2);

			const char *operator = "|";

			_check_expr_bor_operands(
				ctx, node, node_oprd1, node_oprd2, operator, true
			);

			FE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (FE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_bxor(ctx, node);
			break;
		}
	}

	#undef	_CHECK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x2ea3a
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xe40, (%rsi)          # imm = 0xE40
jne 0x2ea1d
cmpl $0x2, 0x44(%rbx)
jne 0x2ea59
movq 0x48(%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ea78
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ea78
leaq 0x1c777(%rip), %r8      # 0x4b14c
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r9d
callq 0x2d12f
cmpb $0x1, 0x70(%r15)
jne 0x2ea2d
movb 0x70(%r12), %al
movb %al, 0x70(%rbx)
cmpb $0x1, %al
jne 0x2ea31
movq %r14, %rdi
movl $0xe40, %esi            # imm = 0xE40
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d93b
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ea78
movb $0x0, 0x70(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x143a1(%rip), %rdi     # 0x42de2
leaq 0x1beb2(%rip), %rsi     # 0x4a8fa
leaq 0x1c6cc(%rip), %rcx     # 0x4b11b
movl $0x11f5, %edx           # imm = 0x11F5
callq 0x30a0
leaq 0x1c295(%rip), %rdi     # 0x4acf5
leaq 0x1be93(%rip), %rsi     # 0x4a8fa
leaq 0x1c6ad(%rip), %rcx     # 0x4b11b
movl $0x1200, %edx           # imm = 0x1200
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_bxor
static void _expr_bxor(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	#define	_CHECK	\
	{	\
		assert(node->nchilds == 2);	\
	}

	uint32_t node_type = node->type;

	switch (node_type) {
		case FE_NODE_EXPR_BXOR: {
			_CHECK
			ParserASTNode *node_oprd1 = node->childs[0];
			ParserASTNode *node_oprd2 = node->childs[1];
			_expr_band(ctx, node_oprd1);
			_expr_band(ctx, node_oprd2);

			const char *operator = "^";

			_check_expr_bxor_operands(
				ctx, node, node_oprd1, node_oprd2, operator, true
			);

			FE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (FE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_band(ctx, node);
			break;
		}
	}

	#undef	_CHECK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x2eb31
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xe50, (%rsi)          # imm = 0xE50
jne 0x2eb14
cmpl $0x2, 0x44(%rbx)
jne 0x2eb50
movq 0x48(%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2eb6f
movq %r14, %rdi
movq %r12, %rsi
callq 0x2eb6f
leaq 0x1c6b4(%rip), %r8      # 0x4b180
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r9d
callq 0x2d27d
cmpb $0x1, 0x70(%r15)
jne 0x2eb24
movb 0x70(%r12), %al
movb %al, 0x70(%rbx)
cmpb $0x1, %al
jne 0x2eb28
movq %r14, %rdi
movl $0xe50, %esi            # imm = 0xE50
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d93b
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2eb6f
movb $0x0, 0x70(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x142aa(%rip), %rdi     # 0x42de2
leaq 0x1bdbb(%rip), %rsi     # 0x4a8fa
leaq 0x1c608(%rip), %rcx     # 0x4b14e
movl $0x11a7, %edx           # imm = 0x11A7
callq 0x30a0
leaq 0x1c19e(%rip), %rdi     # 0x4acf5
leaq 0x1bd9c(%rip), %rsi     # 0x4a8fa
leaq 0x1c5e9(%rip), %rcx     # 0x4b14e
movl $0x11b2, %edx           # imm = 0x11B2
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_band
static void _expr_band(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	#define	_CHECK	\
	{	\
		assert(node->nchilds == 2);	\
	}

	uint32_t node_type = node->type;

	switch (node_type) {
		case FE_NODE_EXPR_BAND: {
			_CHECK
			ParserASTNode *node_oprd1 = node->childs[0];
			ParserASTNode *node_oprd2 = node->childs[1];
			_expr_eq(ctx, node_oprd1);
			_expr_eq(ctx, node_oprd2);

			const char *operator = "&";

			_check_expr_band_operands(
				ctx, node, node_oprd1, node_oprd2, operator, true
			);

			FE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (FE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_eq(ctx, node);
			break;
		}
	}

	#undef	_CHECK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rsi, %rsi
je 0x2ec28
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0xe60, (%rsi)          # imm = 0xE60
jne 0x2ec0b
cmpl $0x2, 0x44(%rbx)
jne 0x2ec47
movq 0x48(%rbx), %rax
movq (%rax), %r15
movq 0x8(%rax), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2ec66
movq %r14, %rdi
movq %r12, %rsi
callq 0x2ec66
leaq 0x152c8(%rip), %r8      # 0x43e8b
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movl $0x1, %r9d
callq 0x2cfe1
cmpb $0x1, 0x70(%r15)
jne 0x2ec1b
movb 0x70(%r12), %al
movb %al, 0x70(%rbx)
cmpb $0x1, %al
jne 0x2ec1f
movq %r14, %rdi
movl $0xe60, %esi            # imm = 0xE60
movq %rbx, %rdx
movq %r15, %rcx
movq %r12, %r8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2d93b
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ec66
movb $0x0, 0x70(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x141b3(%rip), %rdi     # 0x42de2
leaq 0x1bcc4(%rip), %rsi     # 0x4a8fa
leaq 0x1c545(%rip), %rcx     # 0x4b182
movl $0x1159, %edx           # imm = 0x1159
callq 0x30a0
leaq 0x1c0a7(%rip), %rdi     # 0x4acf5
leaq 0x1bca5(%rip), %rsi     # 0x4a8fa
leaq 0x1c526(%rip), %rcx     # 0x4b182
movl $0x1164, %edx           # imm = 0x1164
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_number_type_node
static bool _is_number_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_number_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x3078c
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x307ab
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0x1264f(%rip), %rdi     # 0x42de2
leaq 0x1a160(%rip), %rsi     # 0x4a8fa
leaq 0x1b2b9(%rip), %rcx     # 0x4ba5a
movl $0x1ed, %edx            # imm = 0x1ED
callq 0x30a0
leaq 0x1b2e5(%rip), %rdi     # 0x4ba97
leaq 0x1a141(%rip), %rsi     # 0x4a8fa
leaq 0x1b29a(%rip), %rcx     # 0x4ba5a
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_constexpr_int64
static int64_t _get_constexpr_int64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));
	assert(FE_EXPR_AST_NODE_GET_CONSTANT(node));

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

	switch (FE_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 0x31f99
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x31fb8
cmpb $0x0, 0x70(%rdi)
je 0x31fd7
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x31ff6
leaq 0x186de(%rip), %rcx     # 0x4a618
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x31f97
movsbq 0x88(%rdi), %rax
jmp 0x31f97
cvttsd2si 0x88(%rdi), %rax
jmp 0x31f97
movl 0x88(%rdi), %eax
jmp 0x31f97
cvttss2si 0x88(%rdi), %rax
jmp 0x31f97
movzwl 0x88(%rdi), %eax
jmp 0x31f97
movswq 0x88(%rdi), %rax
jmp 0x31f97
movslq 0x88(%rdi), %rax
jmp 0x31f97
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0x10e42(%rip), %rdi     # 0x42de2
leaq 0x18953(%rip), %rsi     # 0x4a8fa
leaq 0x19d6a(%rip), %rcx     # 0x4bd18
movl $0x987, %edx            # imm = 0x987
callq 0x30a0
leaq 0x19ad8(%rip), %rdi     # 0x4ba97
leaq 0x18934(%rip), %rsi     # 0x4a8fa
leaq 0x19d4b(%rip), %rcx     # 0x4bd18
movl $0x988, %edx            # imm = 0x988
callq 0x30a0
leaq 0x19d79(%rip), %rdi     # 0x4bd57
leaq 0x18915(%rip), %rsi     # 0x4a8fa
leaq 0x19d2c(%rip), %rcx     # 0x4bd18
movl $0x989, %edx            # imm = 0x989
callq 0x30a0
leaq 0xd363(%rip), %rdi      # 0x3f360
leaq 0x188f6(%rip), %rsi     # 0x4a8fa
leaq 0x19d0d(%rip), %rcx     # 0x4bd18
movl $0x99e, %edx            # imm = 0x99E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_constexpr_uint64
static uint64_t _get_constexpr_uint64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));
	assert(FE_EXPR_AST_NODE_GET_CONSTANT(node));

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

	switch (FE_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 0x322e8
cmpb $0x0, 0x70(%rdi)
je 0x32307
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x32326
leaq 0x18448(%rip), %rcx     # 0x4a698
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x322e6
movsbq 0x88(%rdi), %rax
jmp 0x322e6
movsd 0x88(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x18635(%rip), %xmm0    # 0x4a8c0
cvttsd2si %xmm0, %rax
jmp 0x322bb
movl 0x88(%rdi), %eax
jmp 0x322e6
movss 0x88(%rdi), %xmm0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x18612(%rip), %xmm0    # 0x4a8c8
cvttss2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x322e6
movzwl 0x88(%rdi), %eax
jmp 0x322e6
movswq 0x88(%rdi), %rax
jmp 0x322e6
movslq 0x88(%rdi), %rax
jmp 0x322e6
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0x197a8(%rip), %rdi     # 0x4ba97
leaq 0x18604(%rip), %rsi     # 0x4a8fa
leaq 0x19b8c(%rip), %rcx     # 0x4be89
movl $0x9c1, %edx            # imm = 0x9C1
callq 0x30a0
leaq 0x19a49(%rip), %rdi     # 0x4bd57
leaq 0x185e5(%rip), %rsi     # 0x4a8fa
leaq 0x19b6d(%rip), %rcx     # 0x4be89
movl $0x9c2, %edx            # imm = 0x9C2
callq 0x30a0
leaq 0xd033(%rip), %rdi      # 0x3f360
leaq 0x185c6(%rip), %rsi     # 0x4a8fa
leaq 0x19b4e(%rip), %rcx     # 0x4be89
movl $0x9d7, %edx            # imm = 0x9D7
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: set_constexpr_uint64
static void _set_constexpr_uint64(
	ParserContext *ctx,
	ParserASTNode *node,
	uint8_t target_type,
	uint64_t value
) {
	assert(ctx);
	assert(node);

	#define	_A(type)	\
		case FE_TYPE_##type: {	\
			FE_EXPR_AST_NODE_SET_CONSTEXPR_RESULT_##type##_VAL(node, value);	\
			break;	\
		}

	switch (target_type) {
		_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);
		}
	}

	#undef	_A
}

// Assembly:
leal -0x1(%rsi), %eax
cmpl $0xf, %eax
ja 0x323dc
leaq 0x18380(%rip), %rcx     # 0x4a6d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb %dl, 0x88(%rdi)
jmp 0x323d7
movq %rdx, 0x88(%rdi)
jmp 0x323d7
movw %dx, 0x88(%rdi)
jmp 0x323d7
movl %edx, 0x88(%rdi)
jmp 0x323d7
movq %rdx, %xmm0
punpckldq 0x18540(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x18548(%rip), %xmm0    # 0x4a8e0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd %xmm1, 0x88(%rdi)
jmp 0x323d7
testq %rdx, %rdx
js 0x323ba
cvtsi2ss %rdx, %xmm0
jmp 0x323cf
movq %rdx, %rax
shrq %rax
andl $0x1, %edx
orq %rax, %rdx
cvtsi2ss %rdx, %xmm0
addss %xmm0, %xmm0
movss %xmm0, 0x88(%rdi)
movb %sil, 0x71(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xcf79(%rip), %rdi      # 0x3f360
leaq 0x1850c(%rip), %rsi     # 0x4a8fa
leaq 0x19ad5(%rip), %rcx     # 0x4beca
movl $0x942, %edx            # imm = 0x942
callq 0x30a0