LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint_val
uint64_t fe_parser_get_uint_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24f1a
testq %rsi, %rsi
je 0x24f39
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x24f58
movl 0x30(%rdi), %eax
cmpl $0x2, %eax
je 0x24f14
cmpl $0x1, %eax
jne 0x24f77
callq 0x24de8
movl %eax, %eax
popq %rbp
retq
popq %rbp
jmp 0x24e68
leaq 0x29a45(%rip), %rdi     # 0x4e966
leaq 0x243f4(%rip), %rsi     # 0x4931c
leaq 0x2462e(%rip), %rcx     # 0x4955d
movl $0x90c, %edx            # imm = 0x90C
callq 0x30a0
leaq 0x1ee56(%rip), %rdi     # 0x43d96
leaq 0x243d5(%rip), %rsi     # 0x4931c
leaq 0x2460f(%rip), %rcx     # 0x4955d
movl $0x90d, %edx            # imm = 0x90D
callq 0x30a0
leaq 0x24597(%rip), %rdi     # 0x494f6
leaq 0x243b6(%rip), %rsi     # 0x4931c
leaq 0x245f0(%rip), %rcx     # 0x4955d
movl $0x90e, %edx            # imm = 0x90E
callq 0x30a0
leaq 0x1b406(%rip), %rdi     # 0x40384
leaq 0x24397(%rip), %rsi     # 0x4931c
leaq 0x245d1(%rip), %rcx     # 0x4955d
movl $0x916, %edx            # imm = 0x916
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_float_val
float fe_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x24fb9
testq %rsi, %rsi
je 0x24fd8
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x24ff7
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x2193e
leaq 0x299a6(%rip), %rdi     # 0x4e966
leaq 0x24355(%rip), %rsi     # 0x4931c
leaq 0x245d1(%rip), %rcx     # 0x4959f
movl $0x91e, %edx            # imm = 0x91E
callq 0x30a0
leaq 0x1edb7(%rip), %rdi     # 0x43d96
leaq 0x24336(%rip), %rsi     # 0x4931c
leaq 0x245b2(%rip), %rcx     # 0x4959f
movl $0x91f, %edx            # imm = 0x91F
callq 0x30a0
leaq 0x245e1(%rip), %rdi     # 0x495df
leaq 0x24317(%rip), %rsi     # 0x4931c
leaq 0x24593(%rip), %rcx     # 0x4959f
movl $0x920, %edx            # imm = 0x920
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_double_val
double fe_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x25039
testq %rsi, %rsi
je 0x25058
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x25077
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x219be
leaq 0x29926(%rip), %rdi     # 0x4e966
leaq 0x242d5(%rip), %rsi     # 0x4931c
leaq 0x245b4(%rip), %rcx     # 0x49602
movl $0x929, %edx            # imm = 0x929
callq 0x30a0
leaq 0x1ed37(%rip), %rdi     # 0x43d96
leaq 0x242b6(%rip), %rsi     # 0x4931c
leaq 0x24595(%rip), %rcx     # 0x49602
movl $0x92a, %edx            # imm = 0x92A
callq 0x30a0
leaq 0x24561(%rip), %rdi     # 0x495df
leaq 0x24297(%rip), %rsi     # 0x4931c
leaq 0x24576(%rip), %rcx     # 0x49602
movl $0x92b, %edx            # imm = 0x92B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_char_val
char fe_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_CHAR);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x250b9
testq %rsi, %rsi
je 0x250d8
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x250f7
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x21a3e
leaq 0x298a6(%rip), %rdi     # 0x4e966
leaq 0x24255(%rip), %rsi     # 0x4931c
leaq 0x24576(%rip), %rcx     # 0x49644
movl $0x934, %edx            # imm = 0x934
callq 0x30a0
leaq 0x1ecb7(%rip), %rdi     # 0x43d96
leaq 0x24236(%rip), %rsi     # 0x4931c
leaq 0x24557(%rip), %rcx     # 0x49644
movl $0x935, %edx            # imm = 0x935
callq 0x30a0
leaq 0x24584(%rip), %rdi     # 0x49682
leaq 0x24217(%rip), %rsi     # 0x4931c
leaq 0x24538(%rip), %rcx     # 0x49644
movl $0x936, %edx            # imm = 0x936
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_var_symbol_to_node
ParserSymbol * fe_parser_add_var_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

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

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
testq %rdi, %rdi
je 0x251b9
testq %rsi, %rsi
je 0x251d8
movq %rdx, %rax
testq %rdx, %rdx
je 0x251f7
testb %cl, %cl
je 0x25216
testq %r8, %r8
je 0x25235
leaq -0x38(%rbp), %r9
movb %cl, (%r9)
movq %r8, 0x8(%r9)
movq $0x0, 0x10(%r9)
movb $0x0, 0x18(%r9)
movl $0x38, %r8d
movl $0x1, %edx
movq %rax, %rcx
callq 0x6ea7
leaq -0x99(%rip), %rcx       # 0x25116
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
leaq 0x297a6(%rip), %rdi     # 0x4e966
leaq 0x24155(%rip), %rsi     # 0x4931c
leaq 0x24501(%rip), %rcx     # 0x496cf
movl $0x94d, %edx            # imm = 0x94D
callq 0x30a0
leaq 0x1ebb7(%rip), %rdi     # 0x43d96
leaq 0x24136(%rip), %rsi     # 0x4931c
leaq 0x244e2(%rip), %rcx     # 0x496cf
movl $0x94e, %edx            # imm = 0x94E
callq 0x30a0
leaq 0x2753e(%rip), %rdi     # 0x4c73c
leaq 0x24117(%rip), %rsi     # 0x4931c
leaq 0x244c3(%rip), %rcx     # 0x496cf
movl $0x94f, %edx            # imm = 0x94F
callq 0x30a0
leaq 0x2452b(%rip), %rdi     # 0x49748
leaq 0x240f8(%rip), %rsi     # 0x4931c
leaq 0x244a4(%rip), %rcx     # 0x496cf
movl $0x950, %edx            # imm = 0x950
callq 0x30a0
leaq 0x24519(%rip), %rdi     # 0x49755
leaq 0x240d9(%rip), %rsi     # 0x4931c
leaq 0x24485(%rip), %rcx     # 0x496cf
movl $0x951, %edx            # imm = 0x951
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_struct_member_var_symbol_to_symbol
ParserSymbol * fe_parser_add_struct_member_var_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node
) {
	assert(ctx);
	assert(symbol);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testq %rdi, %rdi
je 0x252a3
testq %rsi, %rsi
je 0x252c2
movq %rdx, %rax
testq %rdx, %rdx
je 0x252e1
testb %cl, %cl
je 0x25300
testq %r8, %r8
je 0x2531f
leaq -0x10(%rbp), %r9
movb %cl, (%r9)
movq %r8, 0x8(%r9)
movl $0x10, %r8d
movl $0x5, %edx
movq %rax, %rcx
callq 0x71de
addq $0x10, %rsp
popq %rbp
retq
leaq 0x296bc(%rip), %rdi     # 0x4e966
leaq 0x2406b(%rip), %rsi     # 0x4931c
leaq 0x244ab(%rip), %rcx     # 0x49763
movl $0x96d, %edx            # imm = 0x96D
callq 0x30a0
leaq 0x1ec57(%rip), %rdi     # 0x43f20
leaq 0x2404c(%rip), %rsi     # 0x4931c
leaq 0x2448c(%rip), %rcx     # 0x49763
movl $0x96e, %edx            # imm = 0x96E
callq 0x30a0
leaq 0x27454(%rip), %rdi     # 0x4c73c
leaq 0x2402d(%rip), %rsi     # 0x4931c
leaq 0x2446d(%rip), %rcx     # 0x49763
movl $0x96f, %edx            # imm = 0x96F
callq 0x30a0
leaq 0x24441(%rip), %rdi     # 0x49748
leaq 0x2400e(%rip), %rsi     # 0x4931c
leaq 0x2444e(%rip), %rcx     # 0x49763
movl $0x970, %edx            # imm = 0x970
callq 0x30a0
leaq 0x2442f(%rip), %rdi     # 0x49755
leaq 0x23fef(%rip), %rsi     # 0x4931c
leaq 0x2442f(%rip), %rcx     # 0x49763
movl $0x971, %edx            # imm = 0x971
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_new_struct_symbol
ParserSymbol * fe_parser_new_struct_symbol(
	ParserContext *ctx,
	LexerToken *token,
	ParserASTNode *struct_node,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(token);
	assert(body_node);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x25382
movq %rsi, %rax
testq %rsi, %rsi
je 0x253a1
testq %rcx, %rcx
je 0x253c0
leaq -0x18(%rbp), %r9
movq %rdx, (%r9)
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %ecx
movl $0x2, %esi
movq %rax, %rdx
movq %r9, %r8
callq 0x6b2b
addq $0x20, %rsp
popq %rbp
retq
leaq 0x295dd(%rip), %rdi     # 0x4e966
leaq 0x23f8c(%rip), %rsi     # 0x4931c
leaq 0x24454(%rip), %rcx     # 0x497eb
movl $0x988, %edx            # imm = 0x988
callq 0x30a0
leaq 0x27394(%rip), %rdi     # 0x4c73c
leaq 0x23f6d(%rip), %rsi     # 0x4931c
leaq 0x24435(%rip), %rcx     # 0x497eb
movl $0x989, %edx            # imm = 0x989
callq 0x30a0
leaq 0x2698d(%rip), %rdi     # 0x4bd54
leaq 0x23f4e(%rip), %rsi     # 0x4931c
leaq 0x24416(%rip), %rcx     # 0x497eb
movl $0x98a, %edx            # imm = 0x98A
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_add_struct_symbol_to_node
ParserSymbol * fe_parser_add_struct_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(body_node);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
testq %rdi, %rdi
je 0x25427
testq %rsi, %rsi
je 0x25446
movq %rdx, %rax
testq %rdx, %rdx
je 0x25465
testq %rcx, %rcx
je 0x25484
leaq -0x18(%rbp), %r9
movq %rcx, 0x8(%r9)
movb %r8b, 0x10(%r9)
movl $0x18, %r8d
movl $0x2, %edx
movq %rax, %rcx
callq 0x6ea7
addq $0x20, %rsp
popq %rbp
retq
leaq 0x29538(%rip), %rdi     # 0x4e966
leaq 0x23ee7(%rip), %rsi     # 0x4931c
leaq 0x24421(%rip), %rcx     # 0x4985d
movl $0x9a1, %edx            # imm = 0x9A1
callq 0x30a0
leaq 0x1e949(%rip), %rdi     # 0x43d96
leaq 0x23ec8(%rip), %rsi     # 0x4931c
leaq 0x24402(%rip), %rcx     # 0x4985d
movl $0x9a2, %edx            # imm = 0x9A2
callq 0x30a0
leaq 0x272d0(%rip), %rdi     # 0x4c73c
leaq 0x23ea9(%rip), %rsi     # 0x4931c
leaq 0x243e3(%rip), %rcx     # 0x4985d
movl $0x9a3, %edx            # imm = 0x9A3
callq 0x30a0
leaq 0x268c9(%rip), %rdi     # 0x4bd54
leaq 0x23e8a(%rip), %rsi     # 0x4931c
leaq 0x243c4(%rip), %rcx     # 0x4985d
movl $0x9a4, %edx            # imm = 0x9A4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2559f
movq %rsi, %r14
testq %rsi, %rsi
je 0x255be
testq %rdx, %rdx
je 0x255dd
movq %rcx, %r13
movq %rdx, -0x30(%rbp)
testq %rcx, %rcx
je 0x255fc
movq %r8, %r12
movq %rdi, %r15
movq %r13, -0x58(%rbp)
movq %r8, -0x50(%rbp)
movb %r9b, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
leaq 0x1dadb(%rip), %rdx     # 0x42fdd
movl $0x430, %esi            # imm = 0x430
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6721
movq %rax, %rbx
movq %r15, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x69ff
testq %r12, %r12
je 0x25538
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x69ff
leaq -0x58(%rbp), %r12
movq %rbx, 0x10(%r12)
leaq 0x1d98a(%rip), %rdx     # 0x42ed2
movq %r15, %rdi
movl $0x440, %esi            # imm = 0x440
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6721
movq %rax, %r13
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x69ff
movq %r13, 0x18(%r12)
movl $0x28, %r8d
movq %r15, %rdi
movq %r14, %rsi
movl $0x3, %edx
movq -0x30(%rbp), %rcx
movq %r12, %r9
callq 0x6ea7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x293c0(%rip), %rdi     # 0x4e966
leaq 0x23d6f(%rip), %rsi     # 0x4931c
leaq 0x24323(%rip), %rcx     # 0x498d7
movl $0x9bc, %edx            # imm = 0x9BC
callq 0x30a0
leaq 0x1e7d1(%rip), %rdi     # 0x43d96
leaq 0x23d50(%rip), %rsi     # 0x4931c
leaq 0x24304(%rip), %rcx     # 0x498d7
movl $0x9bd, %edx            # imm = 0x9BD
callq 0x30a0
leaq 0x27158(%rip), %rdi     # 0x4c73c
leaq 0x23d31(%rip), %rsi     # 0x4931c
leaq 0x242e5(%rip), %rcx     # 0x498d7
movl $0x9be, %edx            # imm = 0x9BE
callq 0x30a0
leaq 0x2435d(%rip), %rdi     # 0x49960
leaq 0x23d12(%rip), %rsi     # 0x4931c
leaq 0x242c6(%rip), %rcx     # 0x498d7
movl $0x9bf, %edx            # imm = 0x9BF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2563e
testq %rsi, %rsi
je 0x2565d
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x2567c
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x21b3d
leaq 0x29321(%rip), %rdi     # 0x4e966
leaq 0x23cd0(%rip), %rsi     # 0x4931c
leaq 0x24319(%rip), %rcx     # 0x4996c
movl $0x9e2, %edx            # imm = 0x9E2
callq 0x30a0
leaq 0x1e732(%rip), %rdi     # 0x43d96
leaq 0x23cb1(%rip), %rsi     # 0x4931c
leaq 0x242fa(%rip), %rcx     # 0x4996c
movl $0x9e3, %edx            # imm = 0x9E3
callq 0x30a0
leaq 0x23e73(%rip), %rdi     # 0x494f6
leaq 0x23c92(%rip), %rsi     # 0x4931c
leaq 0x242db(%rip), %rcx     # 0x4996c
movl $0x9e4, %edx            # imm = 0x9E4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x256be
testq %rsi, %rsi
je 0x256dd
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x256fc
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x21bc6
leaq 0x292a1(%rip), %rdi     # 0x4e966
leaq 0x23c50(%rip), %rsi     # 0x4931c
leaq 0x242dd(%rip), %rcx     # 0x499b0
movl $0x9ed, %edx            # imm = 0x9ED
callq 0x30a0
leaq 0x1e6b2(%rip), %rdi     # 0x43d96
leaq 0x23c31(%rip), %rsi     # 0x4931c
leaq 0x242be(%rip), %rcx     # 0x499b0
movl $0x9ee, %edx            # imm = 0x9EE
callq 0x30a0
leaq 0x23edc(%rip), %rdi     # 0x495df
leaq 0x23c12(%rip), %rsi     # 0x4931c
leaq 0x2429f(%rip), %rcx     # 0x499b0
movl $0x9ef, %edx            # imm = 0x9EF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2ac35
testq %rsi, %rsi
je 0x2ac54
movq %rdx, %r15
testq %rdx, %rdx
je 0x2ac73
movq %rcx, %rbx
testq %rcx, %rcx
je 0x2ac92
movq %rdi, %r14
movl $0x2, %edx
movq %r15, %rcx
callq 0x6db9
movq %rax, %r12
testq %rax, %rax
jne 0x2abfc
leaq 0x21001(%rip), %rdx     # 0x4bbf3
movq %r14, %rdi
movq %r15, %rsi
callq *0x50(%r14)
movq %r14, %rdi
movq %r12, %rsi
movl $0x5, %edx
movq %rbx, %rcx
callq 0x735e
movq %rax, %r15
testq %rax, %rax
jne 0x2ac28
leaq 0x2389a(%rip), %rdx     # 0x4e4b8
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 0x23d2a(%rip), %rdi     # 0x4e966
leaq 0x20c17(%rip), %rsi     # 0x4b85a
leaq 0x23887(%rip), %rcx     # 0x4e4d1
movl $0xca0, %edx            # imm = 0xCA0
callq 0x30a0
leaq 0x1913b(%rip), %rdi     # 0x43d96
leaq 0x20bf8(%rip), %rsi     # 0x4b85a
leaq 0x23868(%rip), %rcx     # 0x4e4d1
movl $0xca1, %edx            # imm = 0xCA1
callq 0x30a0
leaq 0x23828(%rip), %rdi     # 0x4e4a2
leaq 0x20bd9(%rip), %rsi     # 0x4b85a
leaq 0x23849(%rip), %rcx     # 0x4e4d1
movl $0xca2, %edx            # imm = 0xCA2
callq 0x30a0
leaq 0x23816(%rip), %rdi     # 0x4e4af
leaq 0x20bba(%rip), %rsi     # 0x4b85a
leaq 0x2382a(%rip), %rcx     # 0x4e4d1
movl $0xca3, %edx            # imm = 0xCA3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b0e0
testq %rsi, %rsi
je 0x2b0ff
movl (%rsi), %eax
cmpl $0x42f, %eax            # imm = 0x42F
jg 0x2b08b
addl $0xfffffc00, %eax       # imm = 0xFFFFFC00
cmpl $0x20, %eax
ja 0x2b11e
leaq 0x1fce2(%rip), %rcx     # 0x4ad60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
jmp 0x2b0de
cmpl $0x430, %eax            # imm = 0x430
je 0x2b0dc
cmpl $0x440, %eax            # imm = 0x440
je 0x2b0d8
cmpl $0x4ff, %eax            # imm = 0x4FF
jne 0x2b11e
movb $-0x1, %al
jmp 0x2b0de
movb $0xa, %al
jmp 0x2b0de
movb $0xc, %al
jmp 0x2b0de
movb $0xb, %al
jmp 0x2b0de
movb $0x7, %al
jmp 0x2b0de
movb $0x6, %al
jmp 0x2b0de
movb $0x5, %al
jmp 0x2b0de
movb $0xe, %al
jmp 0x2b0de
movb $0x4, %al
jmp 0x2b0de
movb $0x9, %al
jmp 0x2b0de
movb $0x3, %al
jmp 0x2b0de
movb $0x2, %al
jmp 0x2b0de
movb $0x8, %al
jmp 0x2b0de
movb $0xd, %al
jmp 0x2b0de
movb $0x10, %al
jmp 0x2b0de
movb $0xf, %al
popq %rbp
retq
leaq 0x2387f(%rip), %rdi     # 0x4e966
leaq 0x2076c(%rip), %rsi     # 0x4b85a
leaq 0x2355f(%rip), %rcx     # 0x4e654
movl $0xb4, %edx
callq 0x30a0
leaq 0x18c90(%rip), %rdi     # 0x43d96
leaq 0x2074d(%rip), %rsi     # 0x4b85a
leaq 0x23540(%rip), %rcx     # 0x4e654
movl $0xb5, %edx
callq 0x30a0
leaq 0x1525f(%rip), %rdi     # 0x40384
leaq 0x2072e(%rip), %rsi     # 0x4b85a
leaq 0x23521(%rip), %rcx     # 0x4e654
movl $0xec, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b195
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 0x2b1cc
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 0x2b1eb
addq $0xd0, %rsp
popq %rbp
retq
leaq 0x18bc3(%rip), %rdi     # 0x43d96
leaq 0x20680(%rip), %rsi     # 0x4b85a
leaq 0x206bc(%rip), %rcx     # 0x4b89d
movl $0x15ea, %edx           # imm = 0x15EA
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b2bf
movl (%rsi), %eax
xorl %ecx, %ecx
cmpl $0x28, %eax
ja 0x2b215
movl %eax, %edx
addq 0x10(%rsi), %rdx
addl $0x8, %eax
movl %eax, (%rsi)
jmp 0x2b221
movq 0x8(%rsi), %rdx
leaq 0x8(%rdx), %r8
movq %r8, 0x8(%rsi)
movl (%rdx), %edx
testl %edx, %edx
je 0x2b234
cmpq $0x20, %rcx
jae 0x2b2a0
movl %edx, -0x80(%rbp,%rcx,4)
incq %rcx
testl %edx, %edx
jne 0x2b203
testq %rdi, %rdi
je 0x2b295
testq %rcx, %rcx
setne %dl
movl -0x80(%rbp), %esi
testq %rcx, %rcx
je 0x2b27e
movl (%rdi), %r9d
movl %edx, %r10d
movq %rdi, %rax
cmpl %esi, %r9d
je 0x2b284
movl $0x1, %r10d
movq %r10, %rax
cmpq %r10, %rcx
je 0x2b275
leaq 0x1(%rax), %r10
cmpl -0x80(%rbp,%rax,4), %r9d
jne 0x2b25f
movq %rdi, %r8
cmpq %rax, %rcx
seta %r10b
jmp 0x2b281
movl %edx, %r10d
movq %r8, %rax
testb %r10b, %r10b
jne 0x2b297
movq 0x30(%rdi), %rdi
movq %rax, %r8
testq %rdi, %rdi
jne 0x2b246
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
leaq 0x150dd(%rip), %rdi     # 0x40384
leaq 0x205ac(%rip), %rsi     # 0x4b85a
leaq 0x233e0(%rip), %rcx     # 0x4e695
movl $0x56d, %edx            # imm = 0x56D
callq 0x30a0
leaq 0x23422(%rip), %rdi     # 0x4e6e8
leaq 0x2058d(%rip), %rsi     # 0x4b85a
leaq 0x233c1(%rip), %rcx     # 0x4e695
movl $0x562, %edx            # imm = 0x562
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b32e
testq %rsi, %rsi
je 0x2b34d
movq 0x30(%rsi), %rsi
testq %rsi, %rsi
je 0x2b30f
cmpl $0xa00, (%rsi)          # imm = 0xA00
jne 0x2b2f3
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x2b36c
popq %rbp
retq
leaq 0x1506e(%rip), %rdi     # 0x40384
leaq 0x2053d(%rip), %rsi     # 0x4b85a
leaq 0x233cc(%rip), %rcx     # 0x4e6f0
movl $0x66c, %edx            # imm = 0x66C
callq 0x30a0
leaq 0x23631(%rip), %rdi     # 0x4e966
leaq 0x2051e(%rip), %rsi     # 0x4b85a
leaq 0x233ad(%rip), %rcx     # 0x4e6f0
movl $0x65f, %edx            # imm = 0x65F
callq 0x30a0
leaq 0x18a42(%rip), %rdi     # 0x43d96
leaq 0x204ff(%rip), %rsi     # 0x4b85a
leaq 0x2338e(%rip), %rcx     # 0x4e6f0
movl $0x660, %edx            # imm = 0x660
callq 0x30a0
leaq 0x18bad(%rip), %rdi     # 0x43f20
leaq 0x204e0(%rip), %rsi     # 0x4b85a
leaq 0x2336f(%rip), %rcx     # 0x4e6f0
movl $0x666, %edx            # imm = 0x666
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b560
movl %edx, %ebx
testl %edx, %edx
js 0x2b57f
movq %rsi, %r14
movq %rdi, %r15
je 0x2b43f
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2b42d
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x1f906(%rip), %rdx     # 0x4ad53
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x1f8e7(%rip), %rsi     # 0x4ad46
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30e0
cmpq $0x0, 0x10(%r15)
je 0x2b4c1
movl $0x28, %edi
movq %r14, %rsi
callq 0x30c0
movq 0x10(%r15), %rax
cmpl $0x0, 0x4(%rax)
jle 0x2b4ae
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 0x2b48d
movl (%rax), %edx
leaq 0x1f8a0(%rip), %rsi     # 0x4ad57
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 0x2b52d
testl %ebx, %ebx
je 0x2b500
cmpl $0x2, %ebx
movl $0x1, %r12d
cmovgel %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2b4ee
leaq 0x23232(%rip), %rdi     # 0x4e739
movq %r14, %rsi
callq 0x30b0
movq 0x68(%r15), %rdi
testq %rdi, %rdi
je 0x2b520
movq %r14, %rsi
callq 0x34ec6
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
cmpl $0x0, 0x44(%r15)
jle 0x2b557
incl %ebx
xorl %r12d, %r12d
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2b404
incq %r12
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jl 0x2b539
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1882f(%rip), %rdi     # 0x43d96
leaq 0x202ec(%rip), %rsi     # 0x4b85a
leaq 0x1f792(%rip), %rcx     # 0x4ad07
movl $0x16af, %edx           # imm = 0x16AF
callq 0x30a0
leaq 0x1f7b5(%rip), %rdi     # 0x4ad3b
leaq 0x202cd(%rip), %rsi     # 0x4b85a
leaq 0x1f773(%rip), %rcx     # 0x4ad07
movl $0x16b1, %edx           # imm = 0x16B1
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b5bc
cmpl $0x0, 0x44(%rsi)
jle 0x2b5db
movq 0x30(%rsi), %rdx
testq %rdx, %rdx
je 0x2b5fa
popq %rbp
jmp 0x2b619
leaq 0x207f4(%rip), %rdi     # 0x4bdb7
leaq 0x20290(%rip), %rsi     # 0x4b85a
leaq 0x2037b(%rip), %rcx     # 0x4b94c
movl $0x4b9, %edx            # imm = 0x4B9
callq 0x30a0
leaq 0x16f57(%rip), %rdi     # 0x42539
leaq 0x20271(%rip), %rsi     # 0x4b85a
leaq 0x2035c(%rip), %rcx     # 0x4b94c
movl $0x4ba, %edx            # imm = 0x4BA
callq 0x30a0
leaq 0x20377(%rip), %rdi     # 0x4b978
leaq 0x20252(%rip), %rsi     # 0x4b85a
leaq 0x2033d(%rip), %rcx     # 0x4b94c
movl $0x4bd, %edx            # imm = 0x4BD
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2c7b8
movq %rsi, %rbx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x2c7d7
movq 0x48(%rbx), %rax
movq (%rax), %r14
movq %r14, %rsi
callq 0x2c01f
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 0x175d7(%rip), %rdi     # 0x43d96
leaq 0x1f094(%rip), %rsi     # 0x4b85a
leaq 0x20f07(%rip), %rcx     # 0x4d6d4
movl $0x13d2, %edx           # imm = 0x13D2
callq 0x30a0
leaq 0x1643b(%rip), %rdi     # 0x42c19
leaq 0x1f075(%rip), %rsi     # 0x4b85a
leaq 0x20ee8(%rip), %rcx     # 0x4d6d4
movl $0x13d3, %edx           # imm = 0x13D3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2c86c
movq %rdx, %rbx
testq %rdx, %rdx
je 0x2c88b
movq %rsi, %r14
movq %rdi, %r15
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x33669
testb %al, %al
jne 0x2c845
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x336d1
testb %al, %al
jne 0x2c845
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3372e
testb %al, %al
je 0x2c852
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 0x338a0
leaq 0x1c319(%rip), %rdi     # 0x48b8c
leaq 0x1efe0(%rip), %rsi     # 0x4b85a
leaq 0x20e88(%rip), %rcx     # 0x4d709
movl $0x32a, %edx            # imm = 0x32A
callq 0x30a0
leaq 0x12ca4(%rip), %rdi     # 0x3f536
leaq 0x1efc1(%rip), %rsi     # 0x4b85a
leaq 0x20e69(%rip), %rcx     # 0x4d709
movl $0x32b, %edx            # imm = 0x32B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_is_lvalue
static int _expr_is_lvalue(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	if (node->type == FE_NODE_EXPR_ATOM
			&& node->childs[0]->type == FE_NODE_IDENTIFIER) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_MEMBER) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_PMEMBER) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_ARRAY_INDEX) {
		return 1;
	}

	if (node->type == FE_NODE_EXPR_DEREF) {
		return 1;
	}

	return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x2cfb4
movl (%rdi), %ecx
movl $0x1, %eax
leal -0xed0(%rcx), %edx
cmpl $0x3, %edx
jb 0x2cfb0
cmpl $0xeca, %ecx            # imm = 0xECA
je 0x2cfb0
cmpl $0xee0, %ecx            # imm = 0xEE0
jne 0x2cfb1
movq 0x48(%rdi), %rdx
movq (%rdx), %rdx
cmpl $0x200, (%rdx)          # imm = 0x200
je 0x2cfb0
addl $0xfffff136, %ecx       # imm = 0xFFFFF136
cmpl $0x9, %ecx
jae 0x2cfb1
movl %ecx, %eax
leaq 0x1e83b(%rip), %rcx     # 0x4b7e8
movl (%rcx,%rax,4), %eax
retq
xorl %eax, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x16dd7(%rip), %rdi     # 0x43d96
leaq 0x1e894(%rip), %rsi     # 0x4b85a
leaq 0x1eee0(%rip), %rcx     # 0x4bead
movl $0x6d7, %edx            # imm = 0x6D7
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
testq %rdx, %rdx
je 0x2d988
movq %rcx, %r14
testq %rcx, %rcx
je 0x2d9a7
testq %r8, %r8
je 0x2d9c6
movq %rdx, %r15
movzbl 0x1(%rdx), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2d969
movl %r9d, %r12d
movq %rsi, %rbx
movb 0x60(%r15), %al
decb %al
cmpb $0xa, %al
ja 0x2d8d7
movzbl 0x1(%r14), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2d969
movb 0x60(%r14), %al
decb %al
cmpb $0xb, %al
jb 0x2d912
movups 0x1fb1c(%rip), %xmm0    # 0x4d3fa
leaq -0x420(%rbp), %rdx
movaps %xmm0, 0x20(%rdx)
movups 0x1fafa(%rip), %xmm0    # 0x4d3ea
movaps %xmm0, 0x10(%rdx)
movups 0x1fadf(%rip), %xmm0    # 0x4d3da
movaps %xmm0, (%rdx)
movabsq $0x2e646e61726570, %rax # imm = 0x2E646E61726570
movq %rax, 0x2e(%rdx)
movq %rbx, %rsi
callq *0x58(%rdi)
testb %r12b, %r12b
je 0x2d959
addq $0x60, %r15
movzbl (%r15), %edi
callq 0x2acb8
movl %eax, %r12d
movzbl 0x60(%r14), %edi
addq $0x60, %r14
callq 0x2acb8
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 $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1f087(%rip), %rdi     # 0x4c9f7
leaq 0x1dee3(%rip), %rsi     # 0x4b85a
leaq 0x1f03c(%rip), %rcx     # 0x4c9ba
movl $0x1ee, %edx            # imm = 0x1EE
callq 0x30a0
leaq 0x1f889(%rip), %rdi     # 0x4d218
leaq 0x1dec4(%rip), %rsi     # 0x4b85a
leaq 0x1f9c6(%rip), %rcx     # 0x4d363
movl $0xf42, %edx            # imm = 0xF42
callq 0x30a0
leaq 0x1f875(%rip), %rdi     # 0x4d223
leaq 0x1dea5(%rip), %rsi     # 0x4b85a
leaq 0x1f9a7(%rip), %rcx     # 0x4d363
movl $0xf43, %edx            # imm = 0xF43
callq 0x30a0
leaq 0x1f861(%rip), %rdi     # 0x4d22e
leaq 0x1de86(%rip), %rsi     # 0x4b85a
leaq 0x1f988(%rip), %rcx     # 0x4d363
movl $0xf44, %edx            # imm = 0xF44
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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
movq %rsi, -0x30(%rbp)
testq %rdx, %rdx
je 0x2dafc
movq %rcx, %r14
testq %rcx, %rcx
je 0x2db1b
movq %rdx, %r15
movzbl 0x1(%rdx), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2dadd
movl %r8d, %ebx
movq %rdi, %r13
movb 0x60(%r15), %al
decb %al
cmpb $0x8, %al
ja 0x2da54
movzbl 0x1(%r14), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2dadd
movb 0x60(%r14), %al
decb %al
cmpb $0x9, %al
jb 0x2da81
leaq 0x1fa2c(%rip), %rsi     # 0x4d487
leaq 0x180b3(%rip), %rdx     # 0x45b15
leaq -0x430(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x3150
movq %r13, %rdi
movq -0x30(%rbp), %rsi
movq %r12, %rdx
callq *0x58(%r13)
testb %bl, %bl
je 0x2dacb
addq $0x60, %r15
movzbl (%r15), %edi
callq 0x2acb8
movl %eax, %r12d
movzbl 0x60(%r14), %edi
addq $0x60, %r14
callq 0x2acb8
cmpl %eax, %r12d
cmovaq %r15, %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movq -0x30(%rbp), %rax
movups %xmm0, 0x60(%rax)
movups %xmm1, 0x70(%rax)
movups %xmm2, 0x80(%rax)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ef13(%rip), %rdi     # 0x4c9f7
leaq 0x1dd6f(%rip), %rsi     # 0x4b85a
leaq 0x1f4ae(%rip), %rcx     # 0x4cfa0
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
leaq 0x1f715(%rip), %rdi     # 0x4d218
leaq 0x1dd50(%rip), %rsi     # 0x4b85a
leaq 0x1f8ff(%rip), %rcx     # 0x4d410
movl $0xf62, %edx            # imm = 0xF62
callq 0x30a0
leaq 0x1f701(%rip), %rdi     # 0x4d223
leaq 0x1dd31(%rip), %rsi     # 0x4b85a
leaq 0x1f8e0(%rip), %rcx     # 0x4d410
movl $0xf63, %edx            # imm = 0xF63
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
testq %rdx, %rdx
je 0x2dc5d
movq %rcx, %r15
testq %rcx, %rcx
je 0x2dc7c
testq %r8, %r8
je 0x2dc9b
movq %rdx, %r14
movzbl 0x1(%rdx), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2dc3e
movq %rsi, %rbx
movq %rdi, %r12
movb 0x60(%r14), %al
leal -0x1(%rax), %ecx
cmpb $0x8, %cl
ja 0x2dbea
movzbl 0x1(%r15), %ecx
shll $0x8, %ecx
cmpl $0xe00, %ecx            # imm = 0xE00
jne 0x2dc3e
movb 0x60(%r15), %cl
decb %cl
cmpb $0x8, %cl
ja 0x2dbea
testb %r9b, %r9b
je 0x2dc13
addq $0x60, %r15
movzbl %al, %edi
callq 0x2acb8
movl %eax, %r12d
movzbl (%r15), %edi
callq 0x2acb8
addq $0x60, %rbx
cmpl %eax, %r12d
jbe 0x2dc23
addq $0x60, %r14
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
jmp 0x2dc31
leaq 0x1f646(%rip), %rsi     # 0x4d237
leaq -0x420(%rbp), %r14
movq %r14, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x3150
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq *0x58(%r12)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
jmp 0x2dc13
leaq 0x1edb2(%rip), %rdi     # 0x4c9f7
leaq 0x1dc0e(%rip), %rsi     # 0x4b85a
leaq 0x1f34d(%rip), %rcx     # 0x4cfa0
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
leaq 0x1f5b4(%rip), %rdi     # 0x4d218
leaq 0x1dbef(%rip), %rsi     # 0x4b85a
leaq 0x1f844(%rip), %rcx     # 0x4d4b6
movl $0x113c, %edx           # imm = 0x113C
callq 0x30a0
leaq 0x1f5a0(%rip), %rdi     # 0x4d223
leaq 0x1dbd0(%rip), %rsi     # 0x4b85a
leaq 0x1f825(%rip), %rcx     # 0x4d4b6
movl $0x113d, %edx           # imm = 0x113D
callq 0x30a0
leaq 0x1f58c(%rip), %rdi     # 0x4d22e
leaq 0x1dbb1(%rip), %rsi     # 0x4b85a
leaq 0x1f806(%rip), %rcx     # 0x4d4b6
movl $0x113e, %edx           # imm = 0x113E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rdx, %rdx
je 0x2e097
testq %rcx, %rcx
je 0x2e0b6
testq %r8, %r8
je 0x2e0d5
movzbl 0x1(%rdx), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e078
movq %rsi, %rbx
movq %rdi, %r14
movb 0x60(%rdx), %al
decb %al
cmpb $0x8, %al
ja 0x2e042
movzbl 0x1(%rcx), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e078
movb 0x60(%rcx), %al
decb %al
cmpb $0x8, %al
ja 0x2e042
testb %r9b, %r9b
je 0x2e06a
addq $0x60, %rdx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups 0x20(%rdx), %xmm2
movups %xmm2, 0x80(%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
jmp 0x2e06a
leaq 0x1f1ee(%rip), %rsi     # 0x4d237
leaq -0x420(%rbp), %r15
movq %r15, %rdi
movq %r8, %rdx
xorl %eax, %eax
callq 0x3150
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq *0x58(%r14)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e978(%rip), %rdi     # 0x4c9f7
leaq 0x1d7d4(%rip), %rsi     # 0x4b85a
leaq 0x1ef13(%rip), %rcx     # 0x4cfa0
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
leaq 0x1f17a(%rip), %rdi     # 0x4d218
leaq 0x1d7b5(%rip), %rsi     # 0x4b85a
leaq 0x1f571(%rip), %rcx     # 0x4d61d
movl $0x104f, %edx           # imm = 0x104F
callq 0x30a0
leaq 0x1f166(%rip), %rdi     # 0x4d223
leaq 0x1d796(%rip), %rsi     # 0x4b85a
leaq 0x1f552(%rip), %rcx     # 0x4d61d
movl $0x1050, %edx           # imm = 0x1050
callq 0x30a0
leaq 0x1f152(%rip), %rdi     # 0x4d22e
leaq 0x1d777(%rip), %rsi     # 0x4b85a
leaq 0x1f533(%rip), %rcx     # 0x4d61d
movl $0x1051, %edx           # imm = 0x1051
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2e2b2
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e2d1
movb 0x60(%rdi), %al
decb %al
cmpb $0x9, %al
setb %al
popq %rbp
retq
leaq 0x15add(%rip), %rdi     # 0x43d96
leaq 0x1d59a(%rip), %rsi     # 0x4b85a
leaq 0x1ecd9(%rip), %rcx     # 0x4cfa0
movl $0x1b2, %edx            # imm = 0x1B2
callq 0x30a0
leaq 0x1e71f(%rip), %rdi     # 0x4c9f7
leaq 0x1d57b(%rip), %rsi     # 0x4b85a
leaq 0x1ecba(%rip), %rcx     # 0x4cfa0
movl $0x1b3, %edx            # imm = 0x1B3
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2e310
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e32f
cmpb $0x10, 0x60(%rdi)
sete %al
popq %rbp
retq
leaq 0x15a7f(%rip), %rdi     # 0x43d96
leaq 0x1d53c(%rip), %rsi     # 0x4b85a
leaq 0x1ecb9(%rip), %rcx     # 0x4cfde
movl $0x1fe, %edx            # imm = 0x1FE
callq 0x30a0
leaq 0x1e6c1(%rip), %rdi     # 0x4c9f7
leaq 0x1d51d(%rip), %rsi     # 0x4b85a
leaq 0x1ec9a(%rip), %rcx     # 0x4cfde
movl $0x1ff, %edx            # imm = 0x1FF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/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 0x2e371
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e390
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0x15a1e(%rip), %rdi     # 0x43d96
leaq 0x1d4db(%rip), %rsi     # 0x4b85a
leaq 0x1ec96(%rip), %rcx     # 0x4d01c
movl $0x220, %edx            # imm = 0x220
callq 0x30a0
leaq 0x1e660(%rip), %rdi     # 0x4c9f7
leaq 0x1d4bc(%rip), %rsi     # 0x4b85a
leaq 0x1ec77(%rip), %rcx     # 0x4d01c
movl $0x221, %edx            # imm = 0x221
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/frontend/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(
		FE_EXPR_AST_NODE_GET_TYPE(node)
	);
}

// Assembly:
testq %rdi, %rdi
je 0x2e3bd
movzbl 0x60(%rdi), %edi
jmp 0x2acb8
pushq %rbp
movq %rsp, %rbp
leaq 0x159ce(%rip), %rdi     # 0x43d96
leaq 0x1d48b(%rip), %rsi     # 0x4b85a
leaq 0x1ec86(%rip), %rcx     # 0x4d05c
movl $0x15a, %edx            # imm = 0x15A
callq 0x30a0