LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: ir_stat_label
static void _ir_stat_label(
	IRGeneratorLlvmirContext *ctx,
	ParserASTNode *node_stat_label
) {
	assert(ctx);
	assert(node_stat_label);
	assert(node_stat_label->type == FE_NODE_STAT_LABEL);
	assert(node_stat_label->nchilds == 1);

	ParserASTNode *node_id = node_stat_label->childs[0];

	ResizableString rstr_label;
	rstr_init_with_raw(&rstr_label, node_id->token->content, node_id->token->len);

	rstr_appendf(
		ctx->body,
		"br label %%%s\n%s:\n",
		RSTR_CSTR(&rstr_label),
		RSTR_CSTR(&rstr_label)
	);

	rstr_free(&rstr_label);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3bcf9
jmp 0x3bd18
leaq 0x40856(%rip), %rdi     # 0x7c556
leaq 0x3c3c9(%rip), %rsi     # 0x780d0
movl $0x766, %edx            # imm = 0x766
leaq 0x3e0d4(%rip), %rcx     # 0x79de7
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3bd21
jmp 0x3bd40
leaq 0x3ac70(%rip), %rdi     # 0x76998
leaq 0x3c3a1(%rip), %rsi     # 0x780d0
movl $0x767, %edx            # imm = 0x767
leaq 0x3e0ac(%rip), %rcx     # 0x79de7
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb90, (%rax)          # imm = 0xB90
jne 0x3bd4e
jmp 0x3bd6d
leaq 0x3ac53(%rip), %rdi     # 0x769a8
leaq 0x3c374(%rip), %rsi     # 0x780d0
movl $0x768, %edx            # imm = 0x768
leaq 0x3e07f(%rip), %rcx     # 0x79de7
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x3bd79
jmp 0x3bd98
leaq 0x3ac54(%rip), %rdi     # 0x769d4
leaq 0x3c349(%rip), %rsi     # 0x780d0
movl $0x769, %edx            # imm = 0x769
leaq 0x3e054(%rip), %rcx     # 0x79de7
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %edx
leaq -0x28(%rbp), %rdi
callq 0x8ee0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3bde7
leaq 0x3bad4(%rip), %rax     # 0x778b5
movq %rax, -0x38(%rbp)
jmp 0x3bdef
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3be0b
leaq 0x3bab0(%rip), %rax     # 0x778b5
movq %rax, -0x48(%rbp)
jmp 0x3be13
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rcx
leaq 0x3e002(%rip), %rsi     # 0x79e28
movb $0x0, %al
callq 0x94d0
leaq -0x28(%rbp), %rdi
callq 0x9310
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: ir_stat_asm
static void _ir_stat_asm(
	IRGeneratorLlvmirContext *ctx,
	ParserASTNode *node_stat_asm
) {
	assert(ctx);
	assert(node_stat_asm);
	assert(node_stat_asm->type == FE_NODE_STAT_ASM);

	_error("asm is not supported.");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3be59
jmp 0x3be78
leaq 0x406f6(%rip), %rdi     # 0x7c556
leaq 0x3c269(%rip), %rsi     # 0x780d0
movl $0x77e, %edx            # imm = 0x77E
leaq 0x3dfc8(%rip), %rcx     # 0x79e3b
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3be81
jmp 0x3bea0
leaq 0x3aba3(%rip), %rdi     # 0x76a2b
leaq 0x3c241(%rip), %rsi     # 0x780d0
movl $0x77f, %edx            # imm = 0x77F
leaq 0x3dfa0(%rip), %rcx     # 0x79e3b
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xba0, (%rax)          # imm = 0xBA0
jne 0x3beae
jmp 0x3becd
leaq 0x3ab84(%rip), %rdi     # 0x76a39
leaq 0x3c214(%rip), %rsi     # 0x780d0
movl $0x780, %edx            # imm = 0x780
leaq 0x3df73(%rip), %rcx     # 0x79e3b
callq 0x30a0
leaq 0x3be86(%rip), %rdi     # 0x77d5a
callq 0x282c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: ir_stat_va_start
static void _ir_stat_va_start(
	IRGeneratorLlvmirContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_VA_START);

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

	_ExprResult result_expr;
	_expr_result_init(&result_expr);

	_ir_expr_wrapper_ptr(ctx, ctx->body, &result_expr, node_expr);

	_TMP_LABEL_DEF(ctx, tmp)

	rstr_appendf(
		ctx->body,
		"%s = bitcast %s to i8*\n",
		_TMP_LABEL_CSTR(tmp),
		RSTR_CSTR(&(result_expr.rstr_result_ptr))
	);
	rstr_appendf(
		ctx->body,
		"call void @llvm.va_start(i8* %s)\n",
		_TMP_LABEL_CSTR(tmp)
	);

	_expr_result_free(&result_expr);

	_TMP_LABEL_FREE(tmp)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3bffc
jmp 0x3c01b
leaq 0x40553(%rip), %rdi     # 0x7c556
leaq 0x3c0c6(%rip), %rsi     # 0x780d0
movl $0x12bd, %edx           # imm = 0x12BD
leaq 0x3dea4(%rip), %rcx     # 0x79eba
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3c024
jmp 0x3c043
leaq 0x39fa8(%rip), %rdi     # 0x75fd3
leaq 0x3c09e(%rip), %rsi     # 0x780d0
movl $0x12be, %edx           # imm = 0x12BE
leaq 0x3de7c(%rip), %rcx     # 0x79eba
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd0, (%rax)          # imm = 0xBD0
jne 0x3c051
jmp 0x3c070
leaq 0x3ab8a(%rip), %rdi     # 0x76be2
leaq 0x3c071(%rip), %rsi     # 0x780d0
movl $0x12bf, %edx           # imm = 0x12BF
leaq 0x3de4f(%rip), %rcx     # 0x79eba
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2a260
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rcx
leaq -0x98(%rbp), %rdx
callq 0x3c730
leaq -0xa8(%rbp), %rdi
callq 0x8c90
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x35980
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0x3c0f4
leaq 0x3b7ca(%rip), %rax     # 0x778b5
movq %rax, -0xb8(%rbp)
jmp 0x3c102
movq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3c127
leaq 0x3b797(%rip), %rax     # 0x778b5
movq %rax, -0xc8(%rbp)
jmp 0x3c132
movq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rdx
movq -0xb0(%rbp), %rdi
movq -0xc8(%rbp), %rcx
leaq 0x3ddb0(%rip), %rsi     # 0x79efe
movb $0x0, %al
callq 0x94d0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0x3c17e
leaq 0x3b740(%rip), %rax     # 0x778b5
movq %rax, -0xd8(%rbp)
jmp 0x3c18c
movq -0xa0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rdx
leaq 0x3dd75(%rip), %rsi     # 0x79f16
movb $0x0, %al
callq 0x94d0
leaq -0x98(%rbp), %rdi
callq 0x2c6a0
leaq -0xa8(%rbp), %rdi
callq 0x9310
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/irgen_llvmir.c
// Function: ir_stat_va_end
static void _ir_stat_va_end(
	IRGeneratorLlvmirContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_VA_END);

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

	_ExprResult result_expr;
	_expr_result_init(&result_expr);

	_ir_expr_wrapper_ptr(ctx, ctx->body, &result_expr, node_expr);

	_TMP_LABEL_DEF(ctx, tmp)

	rstr_appendf(
		ctx->body,
		"%s = bitcast %s to i8*\n",
		_TMP_LABEL_CSTR(tmp),
		RSTR_CSTR(&(result_expr.rstr_result_ptr))
	);
	rstr_appendf(
		ctx->body,
		"call void @llvm.va_end(i8* %s)\n",
		_TMP_LABEL_CSTR(tmp)
	);

	_expr_result_free(&result_expr);

	_TMP_LABEL_FREE(tmp)
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c1ec
jmp 0x3c20b
leaq 0x40363(%rip), %rdi     # 0x7c556
leaq 0x3bed6(%rip), %rsi     # 0x780d0
movl $0x12df, %edx           # imm = 0x12DF
leaq 0x3dd32(%rip), %rcx     # 0x79f38
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3c214
jmp 0x3c233
leaq 0x39db8(%rip), %rdi     # 0x75fd3
leaq 0x3beae(%rip), %rsi     # 0x780d0
movl $0x12e0, %edx           # imm = 0x12E0
leaq 0x3dd0a(%rip), %rcx     # 0x79f38
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd1, (%rax)          # imm = 0xBD1
jne 0x3c241
jmp 0x3c260
leaq 0x3aa0a(%rip), %rdi     # 0x76c52
leaq 0x3be81(%rip), %rsi     # 0x780d0
movl $0x12e1, %edx           # imm = 0x12E1
leaq 0x3dcdd(%rip), %rcx     # 0x79f38
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2a260
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
movq -0x18(%rbp), %rcx
leaq -0x98(%rbp), %rdx
callq 0x3c730
leaq -0xa8(%rbp), %rdi
callq 0x8c90
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x35980
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xb0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0x3c2e4
leaq 0x3b5da(%rip), %rax     # 0x778b5
movq %rax, -0xb8(%rbp)
jmp 0x3c2f2
movq -0xa0(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0xb8(%rbp), %rax
movq %rax, -0xc0(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x3c317
leaq 0x3b5a7(%rip), %rax     # 0x778b5
movq %rax, -0xc8(%rbp)
jmp 0x3c322
movq -0x40(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rdx
movq -0xb0(%rbp), %rdi
movq -0xc8(%rbp), %rcx
leaq 0x3dbc0(%rip), %rsi     # 0x79efe
movb $0x0, %al
callq 0x94d0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xd0(%rbp)
cmpq $0x0, -0xa0(%rbp)
jne 0x3c36e
leaq 0x3b550(%rip), %rax     # 0x778b5
movq %rax, -0xd8(%rbp)
jmp 0x3c37c
movq -0xa0(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0xd0(%rbp), %rdi
movq -0xd8(%rbp), %rdx
leaq 0x3dbe9(%rip), %rsi     # 0x79f7a
movb $0x0, %al
callq 0x94d0
leaq -0x98(%rbp), %rdi
callq 0x2c6a0
leaq -0xa8(%rbp), %rdi
callq 0x9310
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_new_context
LexerContext * fe_lexer_new_context(
	const char *file,
	const char *source,
	int len
) {
	assert(file);
	assert(source);
	assert(len >= 0);

	return lexer_new_context(file, source, len, _matchers);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c79c
jmp 0x3c7bb
leaq 0x352c1(%rip), %rdi     # 0x71a64
leaq 0x3d8fa(%rip), %rsi     # 0x7a0a4
movl $0x156, %edx            # imm = 0x156
leaq 0x3d908(%rip), %rcx     # 0x7a0be
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3c7c4
jmp 0x3c7e3
leaq 0x34dc6(%rip), %rdi     # 0x71591
leaq 0x3d8d2(%rip), %rsi     # 0x7a0a4
movl $0x157, %edx            # imm = 0x157
leaq 0x3d8e0(%rip), %rcx     # 0x7a0be
callq 0x30a0
cmpl $0x0, -0x14(%rbp)
jl 0x3c7eb
jmp 0x3c80a
leaq 0x34da6(%rip), %rdi     # 0x71598
leaq 0x3d8ab(%rip), %rsi     # 0x7a0a4
movl $0x158, %edx            # imm = 0x158
leaq 0x3d8b9(%rip), %rcx     # 0x7a0be
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x50934(%rip), %rcx     # 0x8d150
callq 0x4160
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_uint32_val
uint32_t fe_lexer_get_uint32_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case FE_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint32_bin_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint32_oct_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint32_dec_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_HEX: {
			return util_get_uint32_hex_val(token->content, token->len);
		}
		default: {
			assert(0);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3c899
jmp 0x3c8b8
leaq 0x3fcb6(%rip), %rdi     # 0x7c556
leaq 0x3d7fd(%rip), %rsi     # 0x7a0a4
movl $0x167, %edx            # imm = 0x167
leaq 0x3d87a(%rip), %rcx     # 0x7a12d
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x3c8c1
jmp 0x3c8e0
leaq 0x42874(%rip), %rdi     # 0x7f13c
leaq 0x3d7d5(%rip), %rsi     # 0x7a0a4
movl $0x168, %edx            # imm = 0x168
leaq 0x3d852(%rip), %rcx     # 0x7a12d
callq 0x30a0
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0xfffff000, %eax       # imm = 0xFFFFF000
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x3c96e
movq -0x20(%rbp), %rax
leaq 0x3d783(%rip), %rcx     # 0x7a084
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xca90
movl %eax, -0x4(%rbp)
jmp 0x3c98d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xcd40
movl %eax, -0x4(%rbp)
jmp 0x3c98d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xcfd0
movl %eax, -0x4(%rbp)
jmp 0x3c98d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xd340
movl %eax, -0x4(%rbp)
jmp 0x3c98d
leaq 0x35ae6(%rip), %rdi     # 0x7245b
leaq 0x3d728(%rip), %rsi     # 0x7a0a4
movl $0x178, %edx            # imm = 0x178
leaq 0x3d7a5(%rip), %rcx     # 0x7a12d
callq 0x30a0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_uint64_val
uint64_t fe_lexer_get_uint64_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	switch (token->type) {
		case FE_TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint64_bin_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint64_oct_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint64_dec_val(token->content, token->len);
		}
		case FE_TOKEN_LITERAL_UINT_HEX: {
			return util_get_uint64_hex_val(token->content, token->len);
		}
		default: {
			assert(0);
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3c9b9
jmp 0x3c9d8
leaq 0x3fb96(%rip), %rdi     # 0x7c556
leaq 0x3d6dd(%rip), %rsi     # 0x7a0a4
movl $0x183, %edx            # imm = 0x183
leaq 0x3d799(%rip), %rcx     # 0x7a16c
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x3c9e1
jmp 0x3ca00
leaq 0x42754(%rip), %rdi     # 0x7f13c
leaq 0x3d6b5(%rip), %rsi     # 0x7a0a4
movl $0x184, %edx            # imm = 0x184
leaq 0x3d771(%rip), %rcx     # 0x7a16c
callq 0x30a0
movq -0x18(%rbp), %rax
movl (%rax), %eax
addl $0xfffff000, %eax       # imm = 0xFFFFF000
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x3, %eax
ja 0x3ca92
movq -0x20(%rbp), %rax
leaq 0x3d673(%rip), %rcx     # 0x7a094
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xc950
movq %rax, -0x8(%rbp)
jmp 0x3cab1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xcc00
movq %rax, -0x8(%rbp)
jmp 0x3cab1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xceb0
movq %rax, -0x8(%rbp)
jmp 0x3cab1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xd140
movq %rax, -0x8(%rbp)
jmp 0x3cab1
leaq 0x359c2(%rip), %rdi     # 0x7245b
leaq 0x3d604(%rip), %rsi     # 0x7a0a4
movl $0x194, %edx            # imm = 0x194
leaq 0x3d6c0(%rip), %rcx     # 0x7a16c
callq 0x30a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_float_val
float fe_lexer_get_float_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == FE_TOKEN_LITERAL_REAL) {
		return util_get_float_val(token->content, token->len);
	} else {
		assert(0);
	}
	
	return 0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cad9
jmp 0x3caf8
leaq 0x3fa76(%rip), %rdi     # 0x7c556
leaq 0x3d5bd(%rip), %rsi     # 0x7a0a4
movl $0x19f, %edx            # imm = 0x19F
leaq 0x3d6b8(%rip), %rcx     # 0x7a1ab
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3cb01
jmp 0x3cb20
leaq 0x42634(%rip), %rdi     # 0x7f13c
leaq 0x3d595(%rip), %rsi     # 0x7a0a4
movl $0x1a0, %edx            # imm = 0x1A0
leaq 0x3d690(%rip), %rcx     # 0x7a1ab
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x3cb46
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xd7a0
addq $0x10, %rsp
popq %rbp
retq
leaq 0x3590e(%rip), %rdi     # 0x7245b
leaq 0x3d550(%rip), %rsi     # 0x7a0a4
movl $0x1a5, %edx            # imm = 0x1A5
leaq 0x3d64b(%rip), %rcx     # 0x7a1ab
callq 0x30a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_double_val
double fe_lexer_get_double_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == FE_TOKEN_LITERAL_REAL) {
		return util_get_double_val(token->content, token->len);
	} else {
		assert(0);
	}
	
	return 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cb89
jmp 0x3cba8
leaq 0x3f9c6(%rip), %rdi     # 0x7c556
leaq 0x3d50d(%rip), %rsi     # 0x7a0a4
movl $0x1af, %edx            # imm = 0x1AF
leaq 0x3d643(%rip), %rcx     # 0x7a1e6
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3cbb1
jmp 0x3cbd0
leaq 0x42584(%rip), %rdi     # 0x7f13c
leaq 0x3d4e5(%rip), %rsi     # 0x7a0a4
movl $0x1b0, %edx            # imm = 0x1B0
leaq 0x3d61b(%rip), %rcx     # 0x7a1e6
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x3cbf6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xd4b0
addq $0x10, %rsp
popq %rbp
retq
leaq 0x3585e(%rip), %rdi     # 0x7245b
leaq 0x3d4a0(%rip), %rsi     # 0x7a0a4
movl $0x1b5, %edx            # imm = 0x1B5
leaq 0x3d5d6(%rip), %rcx     # 0x7a1e6
callq 0x30a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_get_char_val
char fe_lexer_get_char_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

	if (token->type == FE_TOKEN_LITERAL_CHAR) {
		return util_get_char_val(token->content, token->len);
	} else {
		assert(0);
	}

	return '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cc39
jmp 0x3cc58
leaq 0x3f916(%rip), %rdi     # 0x7c556
leaq 0x3d45d(%rip), %rsi     # 0x7a0a4
movl $0x1bf, %edx            # imm = 0x1BF
leaq 0x3d5d0(%rip), %rcx     # 0x7a223
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3cc61
jmp 0x3cc80
leaq 0x424d4(%rip), %rdi     # 0x7f13c
leaq 0x3d435(%rip), %rsi     # 0x7a0a4
movl $0x1c0, %edx            # imm = 0x1C0
leaq 0x3d5a8(%rip), %rcx     # 0x7a223
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1005, (%rax)         # imm = 0x1005
jne 0x3cca6
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0xc730
addq $0x10, %rsp
popq %rbp
retq
leaq 0x357ae(%rip), %rdi     # 0x7245b
leaq 0x3d3f0(%rip), %rsi     # 0x7a0a4
movl $0x1c5, %edx            # imm = 0x1C5
leaq 0x3d563(%rip), %rcx     # 0x7a223
callq 0x30a0
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/lexer.c
// Function: fe_lexer_has_unsigned_mark
bool fe_lexer_has_unsigned_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(
		token->type == FE_TOKEN_LITERAL_UINT_BIN
		|| token->type == FE_TOKEN_LITERAL_UINT_OCT
		|| token->type == FE_TOKEN_LITERAL_UINT_DEC
		|| token->type == FE_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 0x3cd99
jmp 0x3cdb8
leaq 0x3f7b6(%rip), %rdi     # 0x7c556
leaq 0x3d2fd(%rip), %rsi     # 0x7a0a4
movl $0x1dc, %edx            # imm = 0x1DC
leaq 0x3d500(%rip), %rcx     # 0x7a2b3
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3cdc1
jmp 0x3cde0
leaq 0x42374(%rip), %rdi     # 0x7f13c
leaq 0x3d2d5(%rip), %rsi     # 0x7a0a4
movl $0x1dd, %edx            # imm = 0x1DD
leaq 0x3d4d8(%rip), %rcx     # 0x7a2b3
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1000, (%rax)         # imm = 0x1000
je 0x3ce10
movq -0x10(%rbp), %rax
cmpl $0x1001, (%rax)         # imm = 0x1001
je 0x3ce10
movq -0x10(%rbp), %rax
cmpl $0x1002, (%rax)         # imm = 0x1002
je 0x3ce10
movq -0x10(%rbp), %rax
cmpl $0x1003, (%rax)         # imm = 0x1003
jne 0x3ce12
jmp 0x3ce31
leaq 0x3d4d9(%rip), %rdi     # 0x7a2f2
leaq 0x3d284(%rip), %rsi     # 0x7a0a4
movl $0x1e3, %edx            # imm = 0x1E3
leaq 0x3d487(%rip), %rcx     # 0x7a2b3
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/frontend/lexer.c
// Function: fe_lexer_has_float_mark
bool fe_lexer_has_float_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(token->type == FE_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 0x3ce79
jmp 0x3ce98
leaq 0x3f6d6(%rip), %rdi     # 0x7c556
leaq 0x3d21d(%rip), %rsi     # 0x7a0a4
movl $0x1ec, %edx            # imm = 0x1EC
leaq 0x3d50c(%rip), %rcx     # 0x7a39f
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x3cea1
jmp 0x3cec0
leaq 0x42294(%rip), %rdi     # 0x7f13c
leaq 0x3d1f5(%rip), %rsi     # 0x7a0a4
movl $0x1ed, %edx            # imm = 0x1ED
leaq 0x3d4e4(%rip), %rcx     # 0x7a39f
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x3cece
jmp 0x3ceed
leaq 0x3d506(%rip), %rdi     # 0x7a3db
leaq 0x3d1c8(%rip), %rsi     # 0x7a0a4
movl $0x1ee, %edx            # imm = 0x1EE
leaq 0x3d4b7(%rip), %rcx     # 0x7a39f
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/frontend/parser.c
// Function: loop_ast_node_releaser
void _loop_ast_node_releaser(struct _ParserASTNode *node) {
	assert(node);
	assert(node->type == FE_NODE_STAT_WHILE
			|| node->type == FE_NODE_STAT_DO
			|| node->type == FE_NODE_STAT_FOR);

	rstr_free(FE_LOOP_AST_NODE_GET_LABEL_REPEAT(node));
	rstr_free(FE_LOOP_AST_NODE_GET_LABEL_END(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x41f95
jmp 0x41fb4
leaq 0x34037(%rip), %rdi     # 0x75fd3
leaq 0x39e89(%rip), %rsi     # 0x7be2c
movl $0x16, %edx
leaq 0x39e98(%rip), %rcx     # 0x7be47
callq 0x30a0
movq -0x8(%rbp), %rax
cmpl $0xb20, (%rax)          # imm = 0xB20
je 0x41fd8
movq -0x8(%rbp), %rax
cmpl $0xb30, (%rax)          # imm = 0xB30
je 0x41fd8
movq -0x8(%rbp), %rax
cmpl $0xb40, (%rax)          # imm = 0xB40
jne 0x41fda
jmp 0x41ff9
leaq 0x39e9c(%rip), %rdi     # 0x7be7d
leaq 0x39e44(%rip), %rsi     # 0x7be2c
movl $0x19, %edx
leaq 0x39e53(%rip), %rcx     # 0x7be47
callq 0x30a0
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
callq 0x9310
movq -0x8(%rbp), %rdi
addq $0x60, %rdi
addq $0x10, %rdi
callq 0x9310
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_new_context
_RULE_END




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

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

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

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

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4232f
jmp 0x4234e
leaq 0x2f72e(%rip), %rdi     # 0x71a64
leaq 0x39aef(%rip), %rsi     # 0x7be2c
movl $0x8aa, %edx            # imm = 0x8AA
leaq 0x39b98(%rip), %rcx     # 0x7bee1
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x42357
jmp 0x42376
leaq 0x2f233(%rip), %rdi     # 0x71591
leaq 0x39ac7(%rip), %rsi     # 0x7be2c
movl $0x8ab, %edx            # imm = 0x8AB
leaq 0x39b70(%rip), %rcx     # 0x7bee1
callq 0x30a0
cmpl $0x0, -0x14(%rbp)
jl 0x4237e
jmp 0x4239d
leaq 0x2f213(%rip), %rdi     # 0x71598
leaq 0x39aa0(%rip), %rsi     # 0x7be2c
movl $0x8ac, %edx            # imm = 0x8AC
leaq 0x39b49(%rip), %rcx     # 0x7bee1
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x3c780
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/frontend/parser.c
// Function: rule_module
_RULE_END
_RULE(module)
	_RULE_NODE(FE_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 0x424e5
jmp 0x42504
leaq 0x3a068(%rip), %rdi     # 0x7c554
leaq 0x39939(%rip), %rsi     # 0x7be2c
movl $0x891, %edx            # imm = 0x891
leaq 0x3a05b(%rip), %rcx     # 0x7c55a
callq 0x30a0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x42510
jmp 0x4252f
leaq 0x3a070(%rip), %rdi     # 0x7c587
leaq 0x3990e(%rip), %rsi     # 0x7be2c
movl $0x891, %edx            # imm = 0x891
leaq 0x3a030(%rip), %rcx     # 0x7c55a
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 0x31fdb(%rip), %rdx     # 0x74536
xorl %eax, %eax
movl %eax, %ecx
callq 0x42060
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 0x43490
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x425bb
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 0x425d9
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x425d7
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0x425db
jmp 0x42584
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/frontend/parser.c
// Function: fe_parser_print_ast
void fe_parser_print_ast(ParserContext * ctx, FILE *file) {
	assert(ctx);
	assert(ctx->ast);
	assert(file);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42619
jmp 0x42638
leaq 0x39f36(%rip), %rdi     # 0x7c556
leaq 0x39805(%rip), %rsi     # 0x7be2c
movl $0x8eb, %edx            # imm = 0x8EB
leaq 0x3995d(%rip), %rcx     # 0x7bf90
callq 0x30a0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x42645
jmp 0x42664
leaq 0x31da3(%rip), %rdi     # 0x743ef
leaq 0x397d9(%rip), %rsi     # 0x7be2c
movl $0x8ec, %edx            # imm = 0x8EC
leaq 0x39931(%rip), %rcx     # 0x7bf90
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x4266d
jmp 0x4268c
leaq 0x2f3f0(%rip), %rdi     # 0x71a64
leaq 0x397b1(%rip), %rsi     # 0x7be2c
movl $0x8ed, %edx            # imm = 0x8ED
leaq 0x39909(%rip), %rcx     # 0x7bf90
callq 0x30a0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movl $0x9, %ecx
callq 0x426b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint32_val
uint32_t fe_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x428a9
jmp 0x428c8
leaq 0x39ca6(%rip), %rdi     # 0x7c556
leaq 0x39575(%rip), %rsi     # 0x7be2c
movl $0x8f6, %edx            # imm = 0x8F6
leaq 0x396ff(%rip), %rcx     # 0x7bfc2
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x428d1
jmp 0x428f0
leaq 0x336fb(%rip), %rdi     # 0x75fd3
leaq 0x3954d(%rip), %rsi     # 0x7be2c
movl $0x8f7, %edx            # imm = 0x8F7
leaq 0x396d7(%rip), %rcx     # 0x7bfc2
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x428fe
jmp 0x4291d
leaq 0x39701(%rip), %rdi     # 0x7c006
leaq 0x39520(%rip), %rsi     # 0x7be2c
movl $0x8f8, %edx            # imm = 0x8F8
leaq 0x396aa(%rip), %rcx     # 0x7bfc2
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3c880
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/parser.c
// Function: fe_parser_get_uint64_val
uint64_t fe_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42959
jmp 0x42978
leaq 0x39bf6(%rip), %rdi     # 0x7c556
leaq 0x394c5(%rip), %rsi     # 0x7be2c
movl $0x901, %edx            # imm = 0x901
leaq 0x396b6(%rip), %rcx     # 0x7c029
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x42981
jmp 0x429a0
leaq 0x3364b(%rip), %rdi     # 0x75fd3
leaq 0x3949d(%rip), %rsi     # 0x7be2c
movl $0x902, %edx            # imm = 0x902
leaq 0x3968e(%rip), %rcx     # 0x7c029
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x429ae
jmp 0x429cd
leaq 0x39651(%rip), %rdi     # 0x7c006
leaq 0x39470(%rip), %rsi     # 0x7be2c
movl $0x903, %edx            # imm = 0x903
leaq 0x39661(%rip), %rcx     # 0x7c029
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3c9a0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x42a09
jmp 0x42a28
leaq 0x39b46(%rip), %rdi     # 0x7c556
leaq 0x39415(%rip), %rsi     # 0x7be2c
movl $0x90c, %edx            # imm = 0x90C
leaq 0x3964a(%rip), %rcx     # 0x7c06d
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x42a31
jmp 0x42a50
leaq 0x3359b(%rip), %rdi     # 0x75fd3
leaq 0x393ed(%rip), %rsi     # 0x7be2c
movl $0x90d, %edx            # imm = 0x90D
leaq 0x39622(%rip), %rcx     # 0x7c06d
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x42a5e
jmp 0x42a7d
leaq 0x395a1(%rip), %rdi     # 0x7c006
leaq 0x393c0(%rip), %rsi     # 0x7be2c
movl $0x90e, %edx            # imm = 0x90E
leaq 0x395f5(%rip), %rcx     # 0x7c06d
callq 0x30a0
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jne 0x42aa2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42890
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x42ada
cmpl $0x2, -0x1c(%rbp)
jne 0x42abb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x42940
movq %rax, -0x8(%rbp)
jmp 0x42ada
leaq 0x2f999(%rip), %rdi     # 0x7245b
leaq 0x39363(%rip), %rsi     # 0x7be2c
movl $0x916, %edx            # imm = 0x916
leaq 0x39598(%rip), %rcx     # 0x7c06d
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/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42b09
jmp 0x42b28
leaq 0x39a46(%rip), %rdi     # 0x7c556
leaq 0x39315(%rip), %rsi     # 0x7be2c
movl $0x91e, %edx            # imm = 0x91E
leaq 0x3958c(%rip), %rcx     # 0x7c0af
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x42b31
jmp 0x42b50
leaq 0x3349b(%rip), %rdi     # 0x75fd3
leaq 0x392ed(%rip), %rsi     # 0x7be2c
movl $0x91f, %edx            # imm = 0x91F
leaq 0x39564(%rip), %rcx     # 0x7c0af
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x42b5e
jmp 0x42b7d
leaq 0x3958a(%rip), %rdi     # 0x7c0ef
leaq 0x392c0(%rip), %rsi     # 0x7be2c
movl $0x920, %edx            # imm = 0x920
leaq 0x39537(%rip), %rcx     # 0x7c0af
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3cac0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42bb9
jmp 0x42bd8
leaq 0x39996(%rip), %rdi     # 0x7c556
leaq 0x39265(%rip), %rsi     # 0x7be2c
movl $0x929, %edx            # imm = 0x929
leaq 0x3953f(%rip), %rcx     # 0x7c112
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x42be1
jmp 0x42c00
leaq 0x333eb(%rip), %rdi     # 0x75fd3
leaq 0x3923d(%rip), %rsi     # 0x7be2c
movl $0x92a, %edx            # imm = 0x92A
leaq 0x39517(%rip), %rcx     # 0x7c112
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x42c0e
jmp 0x42c2d
leaq 0x394da(%rip), %rdi     # 0x7c0ef
leaq 0x39210(%rip), %rsi     # 0x7be2c
movl $0x92b, %edx            # imm = 0x92B
leaq 0x394ea(%rip), %rcx     # 0x7c112
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3cb70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42c69
jmp 0x42c88
leaq 0x398e6(%rip), %rdi     # 0x7c556
leaq 0x391b5(%rip), %rsi     # 0x7be2c
movl $0x934, %edx            # imm = 0x934
leaq 0x394d1(%rip), %rcx     # 0x7c154
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x42c91
jmp 0x42cb0
leaq 0x3333b(%rip), %rdi     # 0x75fd3
leaq 0x3918d(%rip), %rsi     # 0x7be2c
movl $0x935, %edx            # imm = 0x935
leaq 0x394a9(%rip), %rcx     # 0x7c154
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x302, (%rax)          # imm = 0x302
jne 0x42cbe
jmp 0x42cdd
leaq 0x394cd(%rip), %rdi     # 0x7c192
leaq 0x39160(%rip), %rsi     # 0x7be2c
movl $0x936, %edx            # imm = 0x936
leaq 0x3947c(%rip), %rcx     # 0x7c154
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3cc20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x70, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42d86
jmp 0x42da5
leaq 0x397c9(%rip), %rdi     # 0x7c556
leaq 0x39098(%rip), %rsi     # 0x7be2c
movl $0x94d, %edx            # imm = 0x94D
leaq 0x3943f(%rip), %rcx     # 0x7c1df
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x42dae
jmp 0x42dcd
leaq 0x3321e(%rip), %rdi     # 0x75fd3
leaq 0x39070(%rip), %rsi     # 0x7be2c
movl $0x94e, %edx            # imm = 0x94E
leaq 0x39417(%rip), %rcx     # 0x7c1df
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x42dd6
jmp 0x42df5
leaq 0x3c35f(%rip), %rdi     # 0x7f13c
leaq 0x39048(%rip), %rsi     # 0x7be2c
movl $0x94f, %edx            # imm = 0x94F
leaq 0x393ef(%rip), %rcx     # 0x7c1df
callq 0x30a0
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jle 0x42e00
jmp 0x42e1f
leaq 0x39451(%rip), %rdi     # 0x7c258
leaq 0x3901e(%rip), %rsi     # 0x7be2c
movl $0x950, %edx            # imm = 0x950
leaq 0x393c5(%rip), %rcx     # 0x7c1df
callq 0x30a0
cmpq $0x0, -0x28(%rbp)
je 0x42e28
jmp 0x42e47
leaq 0x39436(%rip), %rdi     # 0x7c265
leaq 0x38ff6(%rip), %rsi     # 0x7be2c
movl $0x951, %edx            # imm = 0x951
leaq 0x3939d(%rip), %rcx     # 0x7c1df
callq 0x30a0
movb -0x19(%rbp), %al
movb %al, -0x60(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
movb $0x0, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x1, %edx
movl $0x38, %r8d
leaq -0x60(%rbp), %r9
callq 0x83f0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
leaq -0x190(%rip), %rcx      # 0x42d00
movq %rcx, 0x20(%rax)
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x42ec6
jmp 0x42ee5
leaq 0x39689(%rip), %rdi     # 0x7c556
leaq 0x38f58(%rip), %rsi     # 0x7be2c
movl $0x96d, %edx            # imm = 0x96D
leaq 0x39393(%rip), %rcx     # 0x7c273
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x42eee
jmp 0x42f0d
leaq 0x33283(%rip), %rdi     # 0x76178
leaq 0x38f30(%rip), %rsi     # 0x7be2c
movl $0x96e, %edx            # imm = 0x96E
leaq 0x3936b(%rip), %rcx     # 0x7c273
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x42f16
jmp 0x42f35
leaq 0x3c21f(%rip), %rdi     # 0x7f13c
leaq 0x38f08(%rip), %rsi     # 0x7be2c
movl $0x96f, %edx            # imm = 0x96F
leaq 0x39343(%rip), %rcx     # 0x7c273
callq 0x30a0
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
jle 0x42f40
jmp 0x42f5f
leaq 0x39311(%rip), %rdi     # 0x7c258
leaq 0x38ede(%rip), %rsi     # 0x7be2c
movl $0x970, %edx            # imm = 0x970
leaq 0x39319(%rip), %rcx     # 0x7c273
callq 0x30a0
cmpq $0x0, -0x28(%rbp)
je 0x42f68
jmp 0x42f87
leaq 0x392f6(%rip), %rdi     # 0x7c265
leaq 0x38eb6(%rip), %rsi     # 0x7be2c
movl $0x971, %edx            # imm = 0x971
leaq 0x392f1(%rip), %rcx     # 0x7c273
callq 0x30a0
movb -0x19(%rbp), %al
movb %al, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movl $0x5, %edx
movl $0x10, %r8d
leaq -0x38(%rbp), %r9
callq 0x8890
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $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 0x42fe9
jmp 0x43008
leaq 0x39566(%rip), %rdi     # 0x7c556
leaq 0x38e35(%rip), %rsi     # 0x7be2c
movl $0x988, %edx            # imm = 0x988
leaq 0x392f8(%rip), %rcx     # 0x7c2fb
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x43011
jmp 0x43030
leaq 0x3c124(%rip), %rdi     # 0x7f13c
leaq 0x38e0d(%rip), %rsi     # 0x7be2c
movl $0x989, %edx            # imm = 0x989
leaq 0x392d0(%rip), %rcx     # 0x7c2fb
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x43039
jmp 0x43058
leaq 0x3b733(%rip), %rdi     # 0x7e773
leaq 0x38de5(%rip), %rsi     # 0x7be2c
movl $0x98a, %edx            # imm = 0x98A
leaq 0x392a8(%rip), %rcx     # 0x7c2fb
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/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 $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 0x430c9
jmp 0x430e8
leaq 0x39486(%rip), %rdi     # 0x7c556
leaq 0x38d55(%rip), %rsi     # 0x7be2c
movl $0x9a1, %edx            # imm = 0x9A1
leaq 0x3928a(%rip), %rcx     # 0x7c36d
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x430f1
jmp 0x43110
leaq 0x32edb(%rip), %rdi     # 0x75fd3
leaq 0x38d2d(%rip), %rsi     # 0x7be2c
movl $0x9a2, %edx            # imm = 0x9A2
leaq 0x39262(%rip), %rcx     # 0x7c36d
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x43119
jmp 0x43138
leaq 0x3c01c(%rip), %rdi     # 0x7f13c
leaq 0x38d05(%rip), %rsi     # 0x7be2c
movl $0x9a3, %edx            # imm = 0x9A3
leaq 0x3923a(%rip), %rcx     # 0x7c36d
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x43141
jmp 0x43160
leaq 0x3b62b(%rip), %rdi     # 0x7e773
leaq 0x38cdd(%rip), %rsi     # 0x7be2c
movl $0x9a4, %edx            # imm = 0x9A4
leaq 0x39212(%rip), %rcx     # 0x7c36d
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/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x43349
jmp 0x43368
leaq 0x39206(%rip), %rdi     # 0x7c556
leaq 0x38ad5(%rip), %rsi     # 0x7be2c
movl $0x9e2, %edx            # imm = 0x9E2
leaq 0x39119(%rip), %rcx     # 0x7c47c
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x43371
jmp 0x43390
leaq 0x32c5b(%rip), %rdi     # 0x75fd3
leaq 0x38aad(%rip), %rsi     # 0x7be2c
movl $0x9e3, %edx            # imm = 0x9E3
leaq 0x390f1(%rip), %rcx     # 0x7c47c
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x4339e
jmp 0x433bd
leaq 0x38c61(%rip), %rdi     # 0x7c006
leaq 0x38a80(%rip), %rsi     # 0x7be2c
movl $0x9e4, %edx            # imm = 0x9E4
leaq 0x390c4(%rip), %rcx     # 0x7c47c
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3cd80
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x433f9
jmp 0x43418
leaq 0x39156(%rip), %rdi     # 0x7c556
leaq 0x38a25(%rip), %rsi     # 0x7be2c
movl $0x9ed, %edx            # imm = 0x9ED
leaq 0x390ad(%rip), %rcx     # 0x7c4c0
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x43421
jmp 0x43440
leaq 0x32bab(%rip), %rdi     # 0x75fd3
leaq 0x389fd(%rip), %rsi     # 0x7be2c
movl $0x9ee, %edx            # imm = 0x9EE
leaq 0x39085(%rip), %rcx     # 0x7c4c0
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x4344e
jmp 0x4346d
leaq 0x38c9a(%rip), %rdi     # 0x7c0ef
leaq 0x389d0(%rip), %rsi     # 0x7be2c
movl $0x9ef, %edx            # imm = 0x9EF
leaq 0x39058(%rip), %rcx     # 0x7c4c0
callq 0x30a0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x3ce60
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)