LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_has_unsigned_mark
bool be_lexer_has_unsigned_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(
		token->type == BE_TOKEN_LITERAL_UINT_BIN
		|| token->type == BE_TOKEN_LITERAL_UINT_OCT
		|| token->type == BE_TOKEN_LITERAL_UINT_DEC
		|| token->type == BE_TOKEN_LITERAL_UINT_HEX
	);

	return token->content[token->len - 1] == 'u';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x396a9
jmp 0x396c8
leaq 0x46ab1(%rip), %rdi     # 0x80161
leaq 0x44835(%rip), %rsi     # 0x7deec
movl $0x1f8, %edx            # imm = 0x1F8
leaq 0x44a37(%rip), %rcx     # 0x7e0fa
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x396d1
jmp 0x396f0
leaq 0x38e5e(%rip), %rdi     # 0x72536
leaq 0x4480d(%rip), %rsi     # 0x7deec
movl $0x1f9, %edx            # imm = 0x1F9
leaq 0x44a0f(%rip), %rcx     # 0x7e0fa
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1000, (%rax)         # imm = 0x1000
je 0x39720
movq -0x10(%rbp), %rax
cmpl $0x1001, (%rax)         # imm = 0x1001
je 0x39720
movq -0x10(%rbp), %rax
cmpl $0x1002, (%rax)         # imm = 0x1002
je 0x39720
movq -0x10(%rbp), %rax
cmpl $0x1003, (%rax)         # imm = 0x1003
jne 0x39722
jmp 0x39741
leaq 0x44a10(%rip), %rdi     # 0x7e139
leaq 0x447bc(%rip), %rsi     # 0x7deec
movl $0x1ff, %edx            # imm = 0x1FF
leaq 0x449be(%rip), %rcx     # 0x7e0fa
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x75, %eax
sete %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/lexer.c
// Function: be_lexer_has_float_mark
bool be_lexer_has_float_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(token->type == BE_TOKEN_LITERAL_REAL);

	return token->content[token->len - 1] == 'f';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x39789
jmp 0x397a8
leaq 0x469d1(%rip), %rdi     # 0x80161
leaq 0x44755(%rip), %rsi     # 0x7deec
movl $0x208, %edx            # imm = 0x208
leaq 0x44a43(%rip), %rcx     # 0x7e1e6
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x397b1
jmp 0x397d0
leaq 0x38d7e(%rip), %rdi     # 0x72536
leaq 0x4472d(%rip), %rsi     # 0x7deec
movl $0x209, %edx            # imm = 0x209
leaq 0x44a1b(%rip), %rcx     # 0x7e1e6
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x397de
jmp 0x397fd
leaq 0x44a3d(%rip), %rdi     # 0x7e222
leaq 0x44700(%rip), %rsi     # 0x7deec
movl $0x20a, %edx            # imm = 0x20A
leaq 0x449ee(%rip), %rcx     # 0x7e1e6
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x66, %eax
sete %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_new_context
_RULE_END




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

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

	BeParserContextData data;
	data.align_node = NULL;
	data.packed_node = NULL;

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

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3dbcf
jmp 0x3dbee
leaq 0x34e8d(%rip), %rdi     # 0x72a63
leaq 0x41ed3(%rip), %rsi     # 0x7fab0
movl $0x92a, %edx            # imm = 0x92A
leaq 0x41ee1(%rip), %rcx     # 0x7faca
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3dbf7
jmp 0x3dc16
leaq 0x3e636(%rip), %rdi     # 0x7c234
leaq 0x41eab(%rip), %rsi     # 0x7fab0
movl $0x92b, %edx            # imm = 0x92B
leaq 0x41eb9(%rip), %rcx     # 0x7faca
callq 0x30a0
cmpl $0x0, -0x14(%rbp)
jl 0x3dc1e
jmp 0x3dc3d
leaq 0x34972(%rip), %rdi     # 0x72597
leaq 0x41e84(%rip), %rsi     # 0x7fab0
movl $0x92c, %edx            # imm = 0x92C
leaq 0x41e92(%rip), %rcx     # 0x7faca
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x39090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4e60
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movl $0x10, %esi
leaq -0x30(%rbp), %rdx
callq 0x7310
movq %rax, -0x38(%rbp)
movl -0x18(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: rule_module
_RULE_END
_RULE(module)
	_RULE_NODE(BE_NODE_MODULE, NULL)

	for (;;) {
		ParserASTNode *node_module_item = _RULE_NAME(module_item)(_RULE_PARSER_CTX);
		if (node_module_item != NULL) {
			_RULE_ADD_CHILD(node_module_item)
		} else {
			if (_RULE_LEXER_CTX->current != NULL) {
				_RULE_PARSER_CTX->syntax_error(_RULE_PARSER_CTX);
			}
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3dd85
jmp 0x3dda4
leaq 0x423d3(%rip), %rdi     # 0x8015f
leaq 0x41d1d(%rip), %rsi     # 0x7fab0
movl $0x911, %edx            # imm = 0x911
leaq 0x423c6(%rip), %rcx     # 0x80165
callq 0x30a0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3ddb0
jmp 0x3ddcf
leaq 0x423db(%rip), %rdi     # 0x80192
leaq 0x41cf2(%rip), %rsi     # 0x7fab0
movl $0x911, %edx            # imm = 0x911
leaq 0x4239b(%rip), %rcx     # 0x80165
callq 0x30a0
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4cc0
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq 0x37d54(%rip), %rdx     # 0x75b4f
xorl %eax, %eax
movl %eax, %ecx
callq 0x3d980
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x3ed70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x3de5b
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7e20
movq %rax, -0x18(%rbp)
jmp 0x3de79
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x3de77
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0x3de7b
jmp 0x3de24
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4de0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint32_val
uint32_t be_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e149
jmp 0x3e168
leaq 0x42011(%rip), %rdi     # 0x80161
leaq 0x41959(%rip), %rsi     # 0x7fab0
movl $0x976, %edx            # imm = 0x976
leaq 0x41a48(%rip), %rcx     # 0x7fbab
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e171
jmp 0x3e190
leaq 0x383e4(%rip), %rdi     # 0x7655c
leaq 0x41931(%rip), %rsi     # 0x7fab0
movl $0x977, %edx            # imm = 0x977
leaq 0x41a20(%rip), %rcx     # 0x7fbab
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x3e19e
jmp 0x3e1bd
leaq 0x41a4a(%rip), %rdi     # 0x7fbef
leaq 0x41904(%rip), %rsi     # 0x7fab0
movl $0x978, %edx            # imm = 0x978
leaq 0x419f3(%rip), %rcx     # 0x7fbab
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x39190
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint64_val
uint64_t be_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e1f9
jmp 0x3e218
leaq 0x41f61(%rip), %rdi     # 0x80161
leaq 0x418a9(%rip), %rsi     # 0x7fab0
movl $0x981, %edx            # imm = 0x981
leaq 0x419ff(%rip), %rcx     # 0x7fc12
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e221
jmp 0x3e240
leaq 0x38334(%rip), %rdi     # 0x7655c
leaq 0x41881(%rip), %rsi     # 0x7fab0
movl $0x982, %edx            # imm = 0x982
leaq 0x419d7(%rip), %rcx     # 0x7fc12
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x3e24e
jmp 0x3e26d
leaq 0x4199a(%rip), %rdi     # 0x7fbef
leaq 0x41854(%rip), %rsi     # 0x7fab0
movl $0x983, %edx            # imm = 0x983
leaq 0x419aa(%rip), %rcx     # 0x7fc12
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x392b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_uint_val
uint64_t be_parser_get_uint_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

	int arch = ctx->arch;
	if (arch == BE_ARCH_32) {
		return be_parser_get_uint32_val(ctx, node);
	} else if (arch == BE_ARCH_64) {
		return be_parser_get_uint64_val(ctx, node);
	} else {
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3e2a9
jmp 0x3e2c8
leaq 0x41eb1(%rip), %rdi     # 0x80161
leaq 0x417f9(%rip), %rsi     # 0x7fab0
movl $0x98c, %edx            # imm = 0x98C
leaq 0x41993(%rip), %rcx     # 0x7fc56
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x3e2d1
jmp 0x3e2f0
leaq 0x38284(%rip), %rdi     # 0x7655c
leaq 0x417d1(%rip), %rsi     # 0x7fab0
movl $0x98d, %edx            # imm = 0x98D
leaq 0x4196b(%rip), %rcx     # 0x7fc56
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x3e2fe
jmp 0x3e31d
leaq 0x418ea(%rip), %rdi     # 0x7fbef
leaq 0x417a4(%rip), %rsi     # 0x7fab0
movl $0x98e, %edx            # imm = 0x98E
leaq 0x4193e(%rip), %rcx     # 0x7fc56
callq 0x30a0
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x3e342
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e130
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x3e37a
cmpl $0x2, -0x1c(%rbp)
jne 0x3e35b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3e1e0
movq %rax, -0x8(%rbp)
jmp 0x3e37a
leaq 0x350f8(%rip), %rdi     # 0x7345a
leaq 0x41747(%rip), %rsi     # 0x7fab0
movl $0x996, %edx            # imm = 0x996
leaq 0x418e1(%rip), %rcx     # 0x7fc56
callq 0x30a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_float_val
float be_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e3a9
jmp 0x3e3c8
leaq 0x41db1(%rip), %rdi     # 0x80161
leaq 0x416f9(%rip), %rsi     # 0x7fab0
movl $0x99e, %edx            # imm = 0x99E
leaq 0x418d5(%rip), %rcx     # 0x7fc98
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e3d1
jmp 0x3e3f0
leaq 0x38184(%rip), %rdi     # 0x7655c
leaq 0x416d1(%rip), %rsi     # 0x7fab0
movl $0x99f, %edx            # imm = 0x99F
leaq 0x418ad(%rip), %rcx     # 0x7fc98
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x3e3fe
jmp 0x3e41d
leaq 0x418d3(%rip), %rdi     # 0x7fcd8
leaq 0x416a4(%rip), %rsi     # 0x7fab0
movl $0x9a0, %edx            # imm = 0x9A0
leaq 0x41880(%rip), %rcx     # 0x7fc98
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x393d0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_double_val
double be_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e459
jmp 0x3e478
leaq 0x41d01(%rip), %rdi     # 0x80161
leaq 0x41649(%rip), %rsi     # 0x7fab0
movl $0x9a9, %edx            # imm = 0x9A9
leaq 0x41888(%rip), %rcx     # 0x7fcfb
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e481
jmp 0x3e4a0
leaq 0x380d4(%rip), %rdi     # 0x7655c
leaq 0x41621(%rip), %rsi     # 0x7fab0
movl $0x9aa, %edx            # imm = 0x9AA
leaq 0x41860(%rip), %rcx     # 0x7fcfb
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x3e4ae
jmp 0x3e4cd
leaq 0x41823(%rip), %rdi     # 0x7fcd8
leaq 0x415f4(%rip), %rsi     # 0x7fab0
movl $0x9ab, %edx            # imm = 0x9AB
leaq 0x41833(%rip), %rcx     # 0x7fcfb
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x39480
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_get_char_val
char be_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_CHAR);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e509
jmp 0x3e528
leaq 0x41c51(%rip), %rdi     # 0x80161
leaq 0x41599(%rip), %rsi     # 0x7fab0
movl $0x9b4, %edx            # imm = 0x9B4
leaq 0x4181a(%rip), %rcx     # 0x7fd3d
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e531
jmp 0x3e550
leaq 0x38024(%rip), %rdi     # 0x7655c
leaq 0x41571(%rip), %rsi     # 0x7fab0
movl $0x9b5, %edx            # imm = 0x9B5
leaq 0x417f2(%rip), %rcx     # 0x7fd3d
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x302, (%rax)          # imm = 0x302
jne 0x3e55e
jmp 0x3e57d
leaq 0x41816(%rip), %rdi     # 0x7fd7b
leaq 0x41544(%rip), %rsi     # 0x7fab0
movl $0x9b6, %edx            # imm = 0x9B6
leaq 0x417c5(%rip), %rcx     # 0x7fd3d
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x39530
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_var_symbol_to_node
ParserSymbol * be_parser_add_var_symbol_to_node(
	ParserContext *ctx,
	ParserASTNode *node,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node,
	size_t type_size
) {
	assert(ctx);
	assert(node);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

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

	data.align = 1;
	data.address = SIZE_MAX;
	data.type_size = type_size;

	data.scope_type = BE_VAR_TYPE_UNKNOWN;

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e62d
jmp 0x3e64c
leaq 0x41b2d(%rip), %rdi     # 0x80161
leaq 0x41475(%rip), %rsi     # 0x7fab0
movl $0x9ce, %edx            # imm = 0x9CE
leaq 0x41781(%rip), %rcx     # 0x7fdc8
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e655
jmp 0x3e674
leaq 0x37f00(%rip), %rdi     # 0x7655c
leaq 0x4144d(%rip), %rsi     # 0x7fab0
movl $0x9cf, %edx            # imm = 0x9CF
leaq 0x41759(%rip), %rcx     # 0x7fdc8
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x3e67d
jmp 0x3e69c
leaq 0x33eb2(%rip), %rdi     # 0x72536
leaq 0x41425(%rip), %rsi     # 0x7fab0
movl $0x9d0, %edx            # imm = 0x9D0
leaq 0x41731(%rip), %rcx     # 0x7fdc8
callq 0x30a0
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jle 0x3e6a7
jmp 0x3e6c6
leaq 0x4179b(%rip), %rdi     # 0x7fe49
leaq 0x413fb(%rip), %rsi     # 0x7fab0
movl $0x9d1, %edx            # imm = 0x9D1
leaq 0x41707(%rip), %rcx     # 0x7fdc8
callq 0x30a0
cmpq $0x0, -0x28(%rbp)
je 0x3e6cf
jmp 0x3e6ee
leaq 0x41780(%rip), %rdi     # 0x7fe56
leaq 0x413d3(%rip), %rsi     # 0x7fab0
movl $0x9d2, %edx            # imm = 0x9D2
leaq 0x416df(%rip), %rcx     # 0x7fdc8
callq 0x30a0
movb -0x19(%rbp), %al
movb %al, -0x80(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x0, -0x70(%rbp)
movb $0x0, -0x68(%rbp)
movl $0x1, -0x50(%rbp)
movq $-0x1, -0x48(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
movl $0x50, %r8d
leaq -0x80(%rbp), %r9
callq 0x83f0
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
leaq -0x1b8(%rip), %rcx      # 0x3e5a0
movq %rcx, 0x20(%rax)
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_struct_member_var_symbol_to_symbol
ParserSymbol * be_parser_add_struct_member_var_symbol_to_symbol(
	ParserContext *ctx,
	ParserSymbol *symbol,
	LexerToken *token,
	uint8_t var_type,
	ParserASTNode *var_type_node,
	size_t offset
) {
	assert(ctx);
	assert(symbol);
	assert(token);
	assert(var_type > 0);
	assert(var_type_node);

	BeParserStructMemberVarSymbolData data;
	data.type = var_type;
	data.type_node = var_type_node;
	data.offset = offset;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e79a
jmp 0x3e7b9
leaq 0x419c0(%rip), %rdi     # 0x80161
leaq 0x41308(%rip), %rsi     # 0x7fab0
movl $0x9f5, %edx            # imm = 0x9F5
leaq 0x416b0(%rip), %rcx     # 0x7fe64
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e7c2
jmp 0x3e7e1
leaq 0x378df(%rip), %rdi     # 0x760a8
leaq 0x412e0(%rip), %rsi     # 0x7fab0
movl $0x9f6, %edx            # imm = 0x9F6
leaq 0x41688(%rip), %rcx     # 0x7fe64
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x3e7ea
jmp 0x3e809
leaq 0x33d45(%rip), %rdi     # 0x72536
leaq 0x412b8(%rip), %rsi     # 0x7fab0
movl $0x9f7, %edx            # imm = 0x9F7
leaq 0x41660(%rip), %rcx     # 0x7fe64
callq 0x30a0
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jle 0x3e814
jmp 0x3e833
leaq 0x4162e(%rip), %rdi     # 0x7fe49
leaq 0x4128e(%rip), %rsi     # 0x7fab0
movl $0x9f8, %edx            # imm = 0x9F8
leaq 0x41636(%rip), %rcx     # 0x7fe64
callq 0x30a0
cmpq $0x0, -0x28(%rbp)
je 0x3e83c
jmp 0x3e85b
leaq 0x41613(%rip), %rdi     # 0x7fe56
leaq 0x41266(%rip), %rsi     # 0x7fab0
movl $0x9f9, %edx            # imm = 0x9F9
leaq 0x4160e(%rip), %rcx     # 0x7fe64
callq 0x30a0
movb -0x19(%rbp), %al
movb %al, -0x48(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x5, %edx
movl $0x18, %r8d
leaq -0x48(%rbp), %r9
callq 0x8890
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_new_struct_symbol
ParserSymbol * be_parser_new_struct_symbol(
	ParserContext *ctx,
	LexerToken *token,
	ParserASTNode *struct_node,
	ParserASTNode *body_node,
	bool dummy
) {
	assert(ctx);
	assert(token);
	assert(body_node);

	BeParserStructSymbolData data;
	data.struct_node = struct_node;
	data.body_node = body_node;
	data.dummy = dummy;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e8c9
jmp 0x3e8e8
leaq 0x41891(%rip), %rdi     # 0x80161
leaq 0x411d9(%rip), %rsi     # 0x7fab0
movl $0xa11, %edx            # imm = 0xA11
leaq 0x41611(%rip), %rcx     # 0x7fef4
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e8f1
jmp 0x3e910
leaq 0x33c3e(%rip), %rdi     # 0x72536
leaq 0x411b1(%rip), %rsi     # 0x7fab0
movl $0xa12, %edx            # imm = 0xA12
leaq 0x415e9(%rip), %rcx     # 0x7fef4
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x3e919
jmp 0x3e938
leaq 0x4458b(%rip), %rdi     # 0x82eab
leaq 0x41189(%rip), %rsi     # 0x7fab0
movl $0xa13, %edx            # imm = 0xA13
leaq 0x415c1(%rip), %rcx     # 0x7fef4
callq 0x30a0
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rdx
movl $0x2, %esi
movl $0x18, %ecx
leaq -0x40(%rbp), %r8
callq 0x7fd0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_add_struct_symbol_to_node
ParserSymbol * be_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);

	BeParserStructSymbolData data;
	data.body_node = body_node;
	data.dummy = dummy;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3e9a9
jmp 0x3e9c8
leaq 0x417b1(%rip), %rdi     # 0x80161
leaq 0x410f9(%rip), %rsi     # 0x7fab0
movl $0xa2a, %edx            # imm = 0xA2A
leaq 0x415a3(%rip), %rcx     # 0x7ff66
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3e9d1
jmp 0x3e9f0
leaq 0x37b84(%rip), %rdi     # 0x7655c
leaq 0x410d1(%rip), %rsi     # 0x7fab0
movl $0xa2b, %edx            # imm = 0xA2B
leaq 0x4157b(%rip), %rcx     # 0x7ff66
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x3e9f9
jmp 0x3ea18
leaq 0x33b36(%rip), %rdi     # 0x72536
leaq 0x410a9(%rip), %rsi     # 0x7fab0
movl $0xa2c, %edx            # imm = 0xA2C
leaq 0x41553(%rip), %rcx     # 0x7ff66
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x3ea21
jmp 0x3ea40
leaq 0x44483(%rip), %rdi     # 0x82eab
leaq 0x41081(%rip), %rsi     # 0x7fab0
movl $0xa2d, %edx            # imm = 0xA2D
leaq 0x4152b(%rip), %rcx     # 0x7ff66
callq 0x30a0
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x2, %edx
movl $0x18, %r8d
leaq -0x40(%rbp), %r9
callq 0x83f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_unsigned_mark
bool be_parser_has_unsigned_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ec29
jmp 0x3ec48
leaq 0x41531(%rip), %rdi     # 0x80161
leaq 0x40e79(%rip), %rsi     # 0x7fab0
movl $0xa6b, %edx            # imm = 0xA6B
leaq 0x41444(%rip), %rcx     # 0x80087
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3ec51
jmp 0x3ec70
leaq 0x37904(%rip), %rdi     # 0x7655c
leaq 0x40e51(%rip), %rsi     # 0x7fab0
movl $0xa6c, %edx            # imm = 0xA6C
leaq 0x4141c(%rip), %rcx     # 0x80087
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x3ec7e
jmp 0x3ec9d
leaq 0x40f6a(%rip), %rdi     # 0x7fbef
leaq 0x40e24(%rip), %rsi     # 0x7fab0
movl $0xa6d, %edx            # imm = 0xA6D
leaq 0x413ef(%rip), %rcx     # 0x80087
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x39690
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_float_mark
bool be_parser_has_float_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ecd9
jmp 0x3ecf8
leaq 0x41481(%rip), %rdi     # 0x80161
leaq 0x40dc9(%rip), %rsi     # 0x7fab0
movl $0xa76, %edx            # imm = 0xA76
leaq 0x413d8(%rip), %rcx     # 0x800cb
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3ed01
jmp 0x3ed20
leaq 0x37854(%rip), %rdi     # 0x7655c
leaq 0x40da1(%rip), %rsi     # 0x7fab0
movl $0xa77, %edx            # imm = 0xA77
leaq 0x413b0(%rip), %rcx     # 0x800cb
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x3ed2e
jmp 0x3ed4d
leaq 0x40fa3(%rip), %rdi     # 0x7fcd8
leaq 0x40d74(%rip), %rsi     # 0x7fab0
movl $0xa78, %edx            # imm = 0xA78
leaq 0x41383(%rip), %rcx     # 0x800cb
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x39770
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: rule_stats_block
_RULE_NOT_MATCHED
	}

	_RULE_NODE(BE_NODE_STATS_BLOCK, NULL)

	for (;;) {
		ParserASTNode *node_stat = _RULE_NAME(stat)(_RULE_PARSER_CTX);
		if (node_stat != NULL) {
			_RULE_ADD_CHILD(node_stat)
		} else {
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x44f25
jmp 0x44f44
leaq 0x3b233(%rip), %rdi     # 0x8015f
leaq 0x3ab7d(%rip), %rsi     # 0x7fab0
movl $0x8e7, %edx            # imm = 0x8E7
leaq 0x3bfa8(%rip), %rcx     # 0x80ee7
callq 0x30a0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x44f50
jmp 0x44f6f
leaq 0x3b23b(%rip), %rdi     # 0x80192
leaq 0x3ab52(%rip), %rsi     # 0x7fab0
movl $0x8e7, %edx            # imm = 0x8E7
leaq 0x3bf7d(%rip), %rcx     # 0x80ee7
callq 0x30a0
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4cc0
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4940
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x44fb8
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x2c(%rbp)
jmp 0x44fc1
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl $0x4004, %eax           # imm = 0x4004
je 0x44fd0
jmp 0x450a8
movq -0x10(%rbp), %rdi
movl $0xb00, %esi            # imm = 0xB00
leaq 0x3f936(%rip), %rdx     # 0x84916
xorl %eax, %eax
movl %eax, %ecx
callq 0x3d980
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
callq 0x450d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x45040
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x7e20
movq %rax, -0x18(%rbp)
jmp 0x45042
jmp 0x45044
jmp 0x45009
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4940
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x45071
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x30(%rbp)
jmp 0x4507a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl $0x4005, %eax           # imm = 0x4005
je 0x45092
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4de0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x450bc
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x4d50
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: be_sem_calc_type_size
size_t be_sem_calc_type_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);

	return _calc_type_size(ctx, node, node_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4d50d
jmp 0x4d52c
leaq 0x32c4d(%rip), %rdi     # 0x80161
leaq 0x35365(%rip), %rsi     # 0x82880
movl $0x1955, %edx           # imm = 0x1955
leaq 0x353d1(%rip), %rcx     # 0x828f8
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4d535
jmp 0x4d554
leaq 0x29020(%rip), %rdi     # 0x7655c
leaq 0x3533d(%rip), %rsi     # 0x82880
movl $0x1956, %edx           # imm = 0x1956
leaq 0x353a9(%rip), %rcx     # 0x828f8
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4d55d
jmp 0x4d57c
leaq 0x37cda(%rip), %rdi     # 0x8523e
leaq 0x35315(%rip), %rsi     # 0x82880
movl $0x1957, %edx           # imm = 0x1957
leaq 0x35381(%rip), %rcx     # 0x828f8
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4d5a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_signed_type
static bool _is_signed_type(
	uint8_t type
) {
	switch (type) {
		case BE_TYPE_CHAR:
		case BE_TYPE_INT8:
		case BE_TYPE_INT16:
		case BE_TYPE_INT32:
		case BE_TYPE_INT64: {
			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
decl %eax
subl $0x4, %eax
ja 0x4da1d
jmp 0x4da17
movb $0x1, -0x1(%rbp)
jmp 0x4da21
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_unsigned_type
static bool _is_unsigned_type(
	uint8_t type
) {
	switch (type) {
		case BE_TYPE_UINT8:
		case BE_TYPE_UINT16:
		case BE_TYPE_UINT32:
		case BE_TYPE_UINT64: {
			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
addl $-0x6, %eax
subl $0x3, %eax
ja 0x4da6e
jmp 0x4da68
movb $0x1, -0x1(%rbp)
jmp 0x4da72
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_float_type
static bool _is_float_type(
	uint8_t type
) {
	switch (type) {
		case BE_TYPE_FLOAT:
		case BE_TYPE_DOUBLE: {
			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
addl $-0xa, %eax
subl $0x1, %eax
ja 0x4db0e
jmp 0x4db08
movb $0x1, -0x1(%rbp)
jmp 0x4db12
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_primitive_type_size
static size_t _get_primitive_type_size(
	uint8_t type
) {
	switch (type) {
		case BE_TYPE_CHAR: {
			return 1;
		}
		case BE_TYPE_INT8: {
			return 1;
		}
		case BE_TYPE_UINT8: {
			return 1;
		}
		case BE_TYPE_INT16: {
			return 2;
		}
		case BE_TYPE_UINT16: {
			return 2;
		}
		case BE_TYPE_INT32: {
			return 4;
		}
		case BE_TYPE_UINT32: {
			return 4;
		}
		case BE_TYPE_INT64: {
			return 8;
		}
		case BE_TYPE_UINT64: {
			return 8;
		}
		case BE_TYPE_FLOAT: {
			return 4;
		}
		case BE_TYPE_DOUBLE: {
			return 8;
		}
		default: {
			assert(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0xa, %eax
ja 0x4dcc8
movq -0x18(%rbp), %rax
leaq 0x33e22(%rip), %rcx     # 0x81a70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq $0x1, -0x8(%rbp)
jmp 0x4dce7
movq $0x1, -0x8(%rbp)
jmp 0x4dce7
movq $0x1, -0x8(%rbp)
jmp 0x4dce7
movq $0x2, -0x8(%rbp)
jmp 0x4dce7
movq $0x2, -0x8(%rbp)
jmp 0x4dce7
movq $0x4, -0x8(%rbp)
jmp 0x4dce7
movq $0x4, -0x8(%rbp)
jmp 0x4dce7
movq $0x8, -0x8(%rbp)
jmp 0x4dce7
movq $0x8, -0x8(%rbp)
jmp 0x4dce7
movq $0x4, -0x8(%rbp)
jmp 0x4dce7
movq $0x8, -0x8(%rbp)
jmp 0x4dce7
leaq 0x2578b(%rip), %rdi     # 0x7345a
leaq 0x34baa(%rip), %rsi     # 0x82880
movl $0x119, %edx            # imm = 0x119
leaq 0x37dc9(%rip), %rcx     # 0x85aab
callq 0x30a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_struct_member_symbol
static ParserSymbol * _get_struct_member_symbol(
	ParserContext *ctx,
	ParserASTNode *node_struct_id,
	ParserASTNode *node_struct_member_id
) {
	assert(ctx);
	assert(node_struct_id);
	assert(node_struct_id->type == BE_NODE_IDENTIFIER);
	assert(node_struct_member_id);
	assert(node_struct_member_id->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol_struct = _get_struct_symbol_by_id_node(
		ctx, node_struct_id
	);

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

	return symbol_struct_member;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4dd4d
jmp 0x4dd6c
leaq 0x3240d(%rip), %rdi     # 0x80161
leaq 0x34b25(%rip), %rsi     # 0x82880
movl $0xfe2, %edx            # imm = 0xFE2
leaq 0x37d6d(%rip), %rcx     # 0x85ad4
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4dd75
jmp 0x4dd94
leaq 0x37db3(%rip), %rdi     # 0x85b2f
leaq 0x34afd(%rip), %rsi     # 0x82880
movl $0xfe3, %edx            # imm = 0xFE3
leaq 0x37d45(%rip), %rcx     # 0x85ad4
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x4dda2
jmp 0x4ddc1
leaq 0x37d95(%rip), %rdi     # 0x85b3e
leaq 0x34ad0(%rip), %rsi     # 0x82880
movl $0xfe4, %edx            # imm = 0xFE4
leaq 0x37d18(%rip), %rcx     # 0x85ad4
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4ddca
jmp 0x4dde9
leaq 0x37d98(%rip), %rdi     # 0x85b69
leaq 0x34aa8(%rip), %rsi     # 0x82880
movl $0xfe5, %edx            # imm = 0xFE5
leaq 0x37cf0(%rip), %rcx     # 0x85ad4
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x4ddf7
jmp 0x4de16
leaq 0x37d81(%rip), %rdi     # 0x85b7f
leaq 0x34a7b(%rip), %rsi     # 0x82880
movl $0xfe6, %edx            # imm = 0xFE6
leaq 0x37cc3(%rip), %rcx     # 0x85ad4
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x61260
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x5, %edx
callq 0x8a10
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x4de69
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq 0x36c29(%rip), %rdx     # 0x84a90
callq *%rax
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: module_item
static void _module_item(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	switch (node->type) {
		case BE_NODE_VAR: {
			_var(ctx, node);
			break;
		}
		case BE_NODE_STRUCT: {
			_struct(ctx, node);
			break;
		}
		case BE_NODE_FUNC: {
			_func(ctx, node);
			break;
		}
		default: {
			assert(0);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4de99
jmp 0x4deb8
leaq 0x322c1(%rip), %rdi     # 0x80161
leaq 0x349d9(%rip), %rsi     # 0x82880
movl $0x1837, %edx           # imm = 0x1837
leaq 0x34ac4(%rip), %rcx     # 0x82977
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4dec1
jmp 0x4dee0
leaq 0x28694(%rip), %rdi     # 0x7655c
leaq 0x349b1(%rip), %rsi     # 0x82880
movl $0x1838, %edx           # imm = 0x1838
leaq 0x34a9c(%rip), %rcx     # 0x82977
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0xa00, %eax            # imm = 0xA00
je 0x4df28
jmp 0x4def2
movl -0x14(%rbp), %eax
subl $0xc00, %eax            # imm = 0xC00
je 0x4df0a
jmp 0x4defe
movl -0x14(%rbp), %eax
subl $0xd00, %eax            # imm = 0xD00
je 0x4df19
jmp 0x4df37
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4df60
jmp 0x4df56
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4e070
jmp 0x4df56
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4e2d0
jmp 0x4df56
leaq 0x2551c(%rip), %rdi     # 0x7345a
leaq 0x3493b(%rip), %rsi     # 0x82880
movl $0x1848, %edx           # imm = 0x1848
leaq 0x34a26(%rip), %rcx     # 0x82977
callq 0x30a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: var
static void _var(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4df79
jmp 0x4df98
leaq 0x321e1(%rip), %rdi     # 0x80161
leaq 0x348f9(%rip), %rsi     # 0x82880
movl $0xf25, %edx            # imm = 0xF25
leaq 0x34a18(%rip), %rcx     # 0x829ab
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4dfa1
jmp 0x4dfc0
leaq 0x285b4(%rip), %rdi     # 0x7655c
leaq 0x348d1(%rip), %rsi     # 0x82880
movl $0xf26, %edx            # imm = 0xF26
leaq 0x349f0(%rip), %rcx     # 0x829ab
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xc00, (%rax)          # imm = 0xC00
jne 0x4dfce
jmp 0x4dfed
leaq 0x34f39(%rip), %rdi     # 0x82f0e
leaq 0x348a4(%rip), %rsi     # 0x82880
movl $0xf27, %edx            # imm = 0xF27
leaq 0x349c3(%rip), %rcx     # 0x829ab
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jle 0x4dff9
jmp 0x4e018
leaq 0x27bdc(%rip), %rdi     # 0x75bdc
leaq 0x34879(%rip), %rsi     # 0x82880
movl $0xf28, %edx            # imm = 0xF28
leaq 0x34998(%rip), %rcx     # 0x829ab
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4e02d
jmp 0x4e04c
leaq 0x349a3(%rip), %rdi     # 0x829d7
leaq 0x34845(%rip), %rsi     # 0x82880
movl $0xf2b, %edx            # imm = 0xF2B
leaq 0x34964(%rip), %rcx     # 0x829ab
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x4e8e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_node_catagory
static int _get_node_catagory(
	int32_t node_type
) {
	if (BE_IS_TYPE_NODE(node_type)) {
		return BE_SEM_NODE_CATEGORY_TYPE;
	} else if (BE_IS_EXPR_NODE(node_type)) {
		return BE_SEM_NODE_CATAGORY_EXPR;
	} else {
		return BE_SEM_NODE_CATEGORY_UNKNOWN;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0x400, %eax            # imm = 0x400
jne 0x4efef
movl $0x1, -0x4(%rbp)
jmp 0x4f00e
movl -0x8(%rbp), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x4f007
movl $0x2, -0x4(%rbp)
jmp 0x4f00e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_var_scope_type
static uint8_t _get_var_scope_type(
	ParserASTNode *node,
	ParserSymbol **symbol_func
) {
	assert(node);
	assert(node->type == BE_NODE_VAR);

	if (symbol_func != NULL) {
		*symbol_func = NULL;
	}

	ParserASTNode *parent = node->parent;
	while (parent != NULL) {
		switch (parent->type) {
			case BE_NODE_MODULE: {
				return BE_VAR_TYPE_GLOBAL;
			}
			case BE_NODE_FUNC: {
				if (symbol_func != NULL) {
					*symbol_func = BE_FUNC_AST_NODE_GET_SYMBOL(parent);
				}
				return BE_VAR_TYPE_LOCAL;
			}
			case BE_NODE_STRUCT: {
				return BE_VAR_TYPE_STRUCT_MEMBER;
			}
		}
		parent = parent->parent;
	}

	assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4f4c9
jmp 0x4f4e8
leaq 0x2708c(%rip), %rdi     # 0x7655c
leaq 0x333a9(%rip), %rsi     # 0x82880
movl $0xe74, %edx            # imm = 0xE74
leaq 0x35032(%rip), %rcx     # 0x84515
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xc00, (%rax)          # imm = 0xC00
jne 0x4f4f6
jmp 0x4f515
leaq 0x33a11(%rip), %rdi     # 0x82f0e
leaq 0x3337c(%rip), %rsi     # 0x82880
movl $0xe75, %edx            # imm = 0xE75
leaq 0x35005(%rip), %rcx     # 0x84515
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x4f527
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4f59a
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x100, %eax            # imm = 0x100
je 0x4f564
jmp 0x4f54c
movl -0x24(%rbp), %eax
subl $0xa00, %eax            # imm = 0xA00
je 0x4f56a
jmp 0x4f558
movl -0x24(%rbp), %eax
subl $0xd00, %eax            # imm = 0xD00
je 0x4f586
jmp 0x4f58c
movb $0x1, -0x1(%rbp)
jmp 0x4f5b9
cmpq $0x0, -0x18(%rbp)
je 0x4f580
movq -0x20(%rbp), %rax
movq 0x60(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movb $0x2, -0x1(%rbp)
jmp 0x4f5b9
movb $0x4, -0x1(%rbp)
jmp 0x4f5b9
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4f533
leaq 0x23eb9(%rip), %rdi     # 0x7345a
leaq 0x332d8(%rip), %rsi     # 0x82880
movl $0xe8e, %edx            # imm = 0xE8E
leaq 0x34f61(%rip), %rcx     # 0x84515
callq 0x30a0
movb -0x1(%rbp), %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: expr_wrapper
static void _expr_wrapper(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_EXPR);

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

	_expr(ctx, child);

	BE_EXPR_AST_NODE_COPY(node, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4f5e9
jmp 0x4f608
leaq 0x30b71(%rip), %rdi     # 0x80161
leaq 0x33289(%rip), %rsi     # 0x82880
movl $0xe63, %edx            # imm = 0xE63
leaq 0x34f50(%rip), %rcx     # 0x84553
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4f611
jmp 0x4f630
leaq 0x26f44(%rip), %rdi     # 0x7655c
leaq 0x33261(%rip), %rsi     # 0x82880
movl $0xe64, %edx            # imm = 0xE64
leaq 0x34f28(%rip), %rcx     # 0x84553
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x4f63e
jmp 0x4f65d
leaq 0x34f43(%rip), %rdi     # 0x84588
leaq 0x33234(%rip), %rsi     # 0x82880
movl $0xe65, %edx            # imm = 0xE65
leaq 0x34efb(%rip), %rcx     # 0x84553
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f400
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
movl $0x30, %edx
callq 0x3110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_integer_type_node
static bool _is_integer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_integer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x50a99
jmp 0x50ab8
leaq 0x2f6c1(%rip), %rdi     # 0x80161
leaq 0x31dd9(%rip), %rsi     # 0x82880
movl $0x1bb, %edx            # imm = 0x1BB
leaq 0x33523(%rip), %rcx     # 0x83fd6
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x50ac1
jmp 0x50ae0
leaq 0x25a94(%rip), %rdi     # 0x7655c
leaq 0x31db1(%rip), %rsi     # 0x82880
movl $0x1bc, %edx            # imm = 0x1BC
leaq 0x334fb(%rip), %rcx     # 0x83fd6
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x50af4
jmp 0x50b13
leaq 0x32b13(%rip), %rdi     # 0x8360e
leaq 0x31d7e(%rip), %rsi     # 0x82880
movl $0x1bd, %edx            # imm = 0x1BD
leaq 0x334c8(%rip), %rcx     # 0x83fd6
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4daa0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_pointer_type_node
static bool _is_pointer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_pointer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x50b49
jmp 0x50b68
leaq 0x2f611(%rip), %rdi     # 0x80161
leaq 0x31d29(%rip), %rsi     # 0x82880
movl $0x207, %edx            # imm = 0x207
leaq 0x334b1(%rip), %rcx     # 0x84014
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x50b71
jmp 0x50b90
leaq 0x259e4(%rip), %rdi     # 0x7655c
leaq 0x31d01(%rip), %rsi     # 0x82880
movl $0x208, %edx            # imm = 0x208
leaq 0x33489(%rip), %rcx     # 0x84014
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x50ba4
jmp 0x50bc3
leaq 0x32a63(%rip), %rdi     # 0x8360e
leaq 0x31cce(%rip), %rsi     # 0x82880
movl $0x209, %edx            # imm = 0x209
leaq 0x33456(%rip), %rcx     # 0x84014
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4db90
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_primitive_type_node
static bool _is_primitive_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_primitive_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x50bf9
jmp 0x50c18
leaq 0x2f561(%rip), %rdi     # 0x80161
leaq 0x31c79(%rip), %rsi     # 0x82880
movl $0x229, %edx            # imm = 0x229
leaq 0x3343f(%rip), %rcx     # 0x84052
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x50c21
jmp 0x50c40
leaq 0x25934(%rip), %rdi     # 0x7655c
leaq 0x31c51(%rip), %rsi     # 0x82880
movl $0x22a, %edx            # imm = 0x22A
leaq 0x33417(%rip), %rcx     # 0x84052
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x50c54
jmp 0x50c73
leaq 0x329b3(%rip), %rdi     # 0x8360e
leaq 0x31c1e(%rip), %rsi     # 0x82880
movl $0x22b, %edx            # imm = 0x22B
leaq 0x333e4(%rip), %rcx     # 0x84052
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4db40
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)