LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_get_char_val
char asm_lexer_get_char_val(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);

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

	return '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1c98d
testq %rsi, %rsi
je 0x1c9ac
cmpl $0x1005, (%rsi)         # imm = 0x1005
jne 0x1c9cb
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
popq %rbp
jmp 0x10f6e
leaq 0x19dc2(%rip), %rdi     # 0x36756
leaq 0x17659(%rip), %rsi     # 0x33ff4
leaq 0x177d8(%rip), %rcx     # 0x3417a
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xa0b0
leaq 0x11b17(%rip), %rdi     # 0x2e4ca
leaq 0x1763a(%rip), %rsi     # 0x33ff4
leaq 0x177b9(%rip), %rcx     # 0x3417a
movl $0x1b1, %edx            # imm = 0x1B1
callq 0xa0b0
leaq 0x129c2(%rip), %rdi     # 0x2f394
leaq 0x1761b(%rip), %rsi     # 0x33ff4
leaq 0x1779a(%rip), %rcx     # 0x3417a
movl $0x1b6, %edx            # imm = 0x1B6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_unescape_string
void asm_lexer_unescape_string(
	LexerContext *ctx,
	ResizableString *target,
	const char *source,
	size_t source_len
) {
	assert(ctx);
	assert(target);
	assert(source);

	util_unescape_string(target, source, source_len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1ca0c
testq %rsi, %rsi
je 0x1ca2b
testq %rdx, %rdx
je 0x1ca4a
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
popq %rbp
jmp 0x11022
leaq 0x19d43(%rip), %rdi     # 0x36756
leaq 0x175da(%rip), %rsi     # 0x33ff4
leaq 0x17793(%rip), %rcx     # 0x341b4
movl $0x1c2, %edx            # imm = 0x1C2
callq 0xa0b0
leaq 0x186a4(%rip), %rdi     # 0x350d6
leaq 0x175bb(%rip), %rsi     # 0x33ff4
leaq 0x17774(%rip), %rcx     # 0x341b4
movl $0x1c3, %edx            # imm = 0x1C3
callq 0xa0b0
leaq 0x11af5(%rip), %rdi     # 0x2e546
leaq 0x1759c(%rip), %rsi     # 0x33ff4
leaq 0x17755(%rip), %rcx     # 0x341b4
movl $0x1c4, %edx            # imm = 0x1C4
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_has_unsigned_mark
bool asm_lexer_has_unsigned_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(
		token->type == ASM_TOKEN_LITERAL_UINT_BIN
		|| token->type == ASM_TOKEN_LITERAL_UINT_OCT
		|| token->type == ASM_TOKEN_LITERAL_UINT_DEC
		|| token->type == ASM_TOKEN_LITERAL_UINT_HEX
	);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1ca95
testq %rsi, %rsi
je 0x1cab4
movl (%rsi), %eax
andl $-0x4, %eax
cmpl $0x1000, %eax           # imm = 0x1000
jne 0x1cad3
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x75, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x19cba(%rip), %rdi     # 0x36756
leaq 0x17551(%rip), %rsi     # 0x33ff4
leaq 0x17762(%rip), %rcx     # 0x3420c
movl $0x1cd, %edx            # imm = 0x1CD
callq 0xa0b0
leaq 0x11a0f(%rip), %rdi     # 0x2e4ca
leaq 0x17532(%rip), %rsi     # 0x33ff4
leaq 0x17743(%rip), %rcx     # 0x3420c
movl $0x1ce, %edx            # imm = 0x1CE
callq 0xa0b0
leaq 0x17772(%rip), %rdi     # 0x3424c
leaq 0x17513(%rip), %rsi     # 0x33ff4
leaq 0x17724(%rip), %rcx     # 0x3420c
movl $0x1d4, %edx            # imm = 0x1D4
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/lexer.c
// Function: asm_lexer_has_float_mark
bool asm_lexer_has_float_mark(
	LexerContext *ctx,
	LexerToken *token
) {
	assert(ctx);
	assert(token);
	assert(token->type == ASM_TOKEN_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1cb1a
testq %rsi, %rsi
je 0x1cb39
cmpl $0x1004, (%rsi)         # imm = 0x1004
jne 0x1cb58
movq 0x8(%rsi), %rax
movslq 0x4(%rsi), %rcx
cmpb $0x66, -0x1(%rax,%rcx)
sete %al
popq %rbp
retq
leaq 0x19c35(%rip), %rdi     # 0x36756
leaq 0x174cc(%rip), %rsi     # 0x33ff4
leaq 0x177ce(%rip), %rcx     # 0x342fd
movl $0x1dd, %edx            # imm = 0x1DD
callq 0xa0b0
leaq 0x1198a(%rip), %rdi     # 0x2e4ca
leaq 0x174ad(%rip), %rsi     # 0x33ff4
leaq 0x177af(%rip), %rcx     # 0x342fd
movl $0x1de, %edx            # imm = 0x1DE
callq 0xa0b0
leaq 0x177db(%rip), %rdi     # 0x3433a
leaq 0x1748e(%rip), %rsi     # 0x33ff4
leaq 0x17790(%rip), %rcx     # 0x342fd
movl $0x1df, %edx            # imm = 0x1DF
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/main.c
// Function: error
static void _error(
	const char *fmt,
	...
) {
	va_list argptr;
    va_start(argptr, fmt);

	fputs("ERROR: ", stderr);
	vfprintf(stderr, fmt, argptr);
	fputc('\n', stderr);

	va_end(argptr);

	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x1e722
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
leaq -0x30(%rbp), %r14
movq %rdi, 0x10(%r14)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x218b2(%rip), %r15     # 0x3fff8
movq (%r15), %rsi
leaq 0x16b8d(%rip), %rdi     # 0x352dd
callq 0xa0c0
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa150
movq (%r15), %rsi
movl $0xa, %edi
callq 0xa0d0
movl $0x1, %edi
callq 0xa160
nop
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_new_context
_RULE_END

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

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

	AsmParserContextData data;
	map_init(
		&data.symtable,
		map_rstr_comparer, NULL,
		(MapReleaser) rstr_delete, (MapReleaser) map_primitive_box_free
	);
	data.arch = ASM_ARCH_BIT16;
	data.out = NULL;
	data.address_counter = 0;
	data.step = ASM_STEP_SCAN;

	data.mem_without_oprd_size = false;

	data.default_oprd_size = false;

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

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
testq %rdi, %rdi
je 0x1e805
testq %rsi, %rsi
je 0x1e824
testl %edx, %edx
js 0x1e843
callq 0x1c644
movq %rax, %rbx
movq %rax, %rdi
callq 0xb6e0
leaq -0x11a5c(%rip), %rsi    # 0xcd58
leaq -0xfe1b(%rip), %rcx     # 0xe9a0
leaq -0x11a84(%rip), %r8     # 0xcd3e
leaq -0x78(%rbp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0xc4ec
movl $0x1, %eax
movl %eax, 0x48(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movl %eax, 0x60(%r14)
movw $0x0, 0x64(%r14)
movl $0x68, %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd13c
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1020d(%rip), %rdi     # 0x2ea19
leaq 0x16cb1(%rip), %rsi     # 0x354c4
leaq 0x16cc6(%rip), %rcx     # 0x354e0
movl $0x987, %edx            # imm = 0x987
callq 0xa0b0
leaq 0xfd1b(%rip), %rdi      # 0x2e546
leaq 0x16c92(%rip), %rsi     # 0x354c4
leaq 0x16ca7(%rip), %rcx     # 0x354e0
movl $0x988, %edx            # imm = 0x988
callq 0xa0b0
leaq 0xfd03(%rip), %rdi      # 0x2e54d
leaq 0x16c73(%rip), %rsi     # 0x354c4
leaq 0x16c88(%rip), %rcx     # 0x354e0
movl $0x989, %edx            # imm = 0x989
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_print_ast
void asm_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
testq %rdi, %rdi
je 0x1ec90
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1ecaf
testq %rsi, %rsi
je 0x1ecce
xorl %edx, %edx
popq %rbp
jmp 0x1eced
leaq 0x17abf(%rip), %rdi     # 0x36756
leaq 0x16826(%rip), %rsi     # 0x354c4
leaq 0x168e8(%rip), %rcx     # 0x3558d
movl $0xa20, %edx            # imm = 0xA20
callq 0xa0b0
leaq 0x17d29(%rip), %rdi     # 0x369df
leaq 0x16807(%rip), %rsi     # 0x354c4
leaq 0x168c9(%rip), %rcx     # 0x3558d
movl $0xa21, %edx            # imm = 0xA21
callq 0xa0b0
leaq 0xfd44(%rip), %rdi      # 0x2ea19
leaq 0x167e8(%rip), %rsi     # 0x354c4
leaq 0x168aa(%rip), %rcx     # 0x3558d
movl $0xa22, %edx            # imm = 0xA22
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_set_symbol_by_rstr_key
void asm_parser_set_symbol_by_rstr_key(
	ParserContext *ctx,
	ResizableString *key,
	uint64_t value
) {
	assert(ctx);
	assert(key);

	Map *symtable = &ASM_PARSER_CONTEXT_DATA_GET_SYMTABLE(ctx);

	MapPrimitiveBox *box = map_primitive_box_uint64(value);

	map_set(symtable, key, box, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1ef76
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1ef95
movq %rdi, %r14
addq $0x68, %r14
movq %rdx, %rdi
callq 0xcb4e
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
movl $0x1, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0xc658
leaq 0x177d9(%rip), %rdi     # 0x36756
leaq 0x16540(%rip), %rsi     # 0x354c4
leaq 0x16635(%rip), %rcx     # 0x355c0
movl $0xa2c, %edx            # imm = 0xA2C
callq 0xa0b0
leaq 0xfe49(%rip), %rdi      # 0x2ede5
leaq 0x16521(%rip), %rsi     # 0x354c4
leaq 0x16616(%rip), %rcx     # 0x355c0
movl $0xa2d, %edx            # imm = 0xA2D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_set_symbol_by_token_key
void asm_parser_set_symbol_by_token_key(
	ParserContext *ctx,
	LexerToken *key,
	uint64_t value
) {
	assert(ctx);
	assert(key);

	ResizableString *rstr_key = rstr_new_with_raw(key->content, key->len);
	asm_parser_set_symbol_by_rstr_key(ctx, rstr_key, value);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1efe9
testq %rsi, %rsi
je 0x1f008
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
movl 0x4(%rsi), %esi
callq 0xe901
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x1ef3c
leaq 0x17766(%rip), %rdi     # 0x36756
leaq 0x164cd(%rip), %rsi     # 0x354c4
leaq 0x16617(%rip), %rcx     # 0x35615
movl $0xa3b, %edx            # imm = 0xA3B
callq 0xa0b0
leaq 0xfdd6(%rip), %rdi      # 0x2ede5
leaq 0x164ae(%rip), %rsi     # 0x354c4
leaq 0x165f8(%rip), %rcx     # 0x35615
movl $0xa3c, %edx            # imm = 0xA3C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_symbol_by_rstr_key
uint64_t asm_parser_get_symbol_by_rstr_key(
	ParserContext *ctx,
	ResizableString *key
) {
	assert(ctx);
	assert(key);

	Map *symtable = &ASM_PARSER_CONTEXT_DATA_GET_SYMTABLE(ctx);

	MapPrimitiveBox *box = (MapPrimitiveBox *) map_get(symtable, key);
	if (box != NULL) {
		assert(box->type == MAP_PRIMITIVE_BOX_TYPE_UINT64);
		return box->value.u64;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f052
testq %rsi, %rsi
je 0x1f071
addq $0x68, %rdi
callq 0xc7de
testq %rax, %rax
je 0x1f04e
cmpb $0x5, (%rax)
jne 0x1f090
movq 0x8(%rax), %rax
jmp 0x1f050
xorl %eax, %eax
popq %rbp
retq
leaq 0x176fd(%rip), %rdi     # 0x36756
leaq 0x16464(%rip), %rsi     # 0x354c4
leaq 0x165ff(%rip), %rcx     # 0x35666
movl $0xa46, %edx            # imm = 0xA46
callq 0xa0b0
leaq 0xfd6d(%rip), %rdi      # 0x2ede5
leaq 0x16445(%rip), %rsi     # 0x354c4
leaq 0x165e0(%rip), %rcx     # 0x35666
movl $0xa47, %edx            # imm = 0xA47
callq 0xa0b0
leaq 0x1661e(%rip), %rdi     # 0x356b5
leaq 0x16426(%rip), %rsi     # 0x354c4
leaq 0x165c1(%rip), %rcx     # 0x35666
movl $0xa4d, %edx            # imm = 0xA4D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_symbol_by_token_key
uint64_t asm_parser_get_symbol_by_token_key(
	ParserContext *ctx,
	LexerToken *key
) {
	assert(ctx);
	assert(key);

	ResizableString rstr_key;
	rstr_init_with_raw(&rstr_key, key->content, key->len);
	uint64_t value = asm_parser_get_symbol_by_rstr_key(ctx, &rstr_key);
	rstr_free(&rstr_key);

	return value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1f0ff
testq %rsi, %rsi
je 0x1f11e
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movl 0x4(%rsi), %edx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xe60d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f027
movq %rax, %rbx
movq %r14, %rdi
callq 0xe958
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x17650(%rip), %rdi     # 0x36756
leaq 0x163b7(%rip), %rsi     # 0x354c4
leaq 0x165cc(%rip), %rcx     # 0x356e0
movl $0xa58, %edx            # imm = 0xA58
callq 0xa0b0
leaq 0xfcc0(%rip), %rdi      # 0x2ede5
leaq 0x16398(%rip), %rsi     # 0x354c4
leaq 0x165ad(%rip), %rcx     # 0x356e0
movl $0xa59, %edx            # imm = 0xA59
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_uint32_val
uint32_t asm_parser_get_uint32_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f160
testq %rsi, %rsi
je 0x1f17f
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x1f19e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c6ec
leaq 0x175ef(%rip), %rdi     # 0x36756
leaq 0x16356(%rip), %rsi     # 0x354c4
leaq 0x165b6(%rip), %rcx     # 0x3572b
movl $0xa67, %edx            # imm = 0xA67
callq 0xa0b0
leaq 0x13b75(%rip), %rdi     # 0x32cfb
leaq 0x16337(%rip), %rsi     # 0x354c4
leaq 0x16597(%rip), %rcx     # 0x3572b
movl $0xa68, %edx            # imm = 0xA68
callq 0xa0b0
leaq 0x165cb(%rip), %rdi     # 0x35770
leaq 0x16318(%rip), %rsi     # 0x354c4
leaq 0x16578(%rip), %rcx     # 0x3572b
movl $0xa69, %edx            # imm = 0xA69
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_uint64_val
uint64_t asm_parser_get_uint64_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f1e0
testq %rsi, %rsi
je 0x1f1ff
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x1f21e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c7ab
leaq 0x1756f(%rip), %rdi     # 0x36756
leaq 0x162d6(%rip), %rsi     # 0x354c4
leaq 0x1659f(%rip), %rcx     # 0x35794
movl $0xa72, %edx            # imm = 0xA72
callq 0xa0b0
leaq 0x13af5(%rip), %rdi     # 0x32cfb
leaq 0x162b7(%rip), %rsi     # 0x354c4
leaq 0x16580(%rip), %rcx     # 0x35794
movl $0xa73, %edx            # imm = 0xA73
callq 0xa0b0
leaq 0x1654b(%rip), %rdi     # 0x35770
leaq 0x16298(%rip), %rsi     # 0x354c4
leaq 0x16561(%rip), %rcx     # 0x35794
movl $0xa74, %edx            # imm = 0xA74
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_float_val
float asm_parser_get_float_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f260
testq %rsi, %rsi
je 0x1f27f
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x1f29e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c86a
leaq 0x174ef(%rip), %rdi     # 0x36756
leaq 0x16256(%rip), %rsi     # 0x354c4
leaq 0x16564(%rip), %rcx     # 0x357d9
movl $0xa7d, %edx            # imm = 0xA7D
callq 0xa0b0
leaq 0x13a75(%rip), %rdi     # 0x32cfb
leaq 0x16237(%rip), %rsi     # 0x354c4
leaq 0x16545(%rip), %rcx     # 0x357d9
movl $0xa7e, %edx            # imm = 0xA7E
callq 0xa0b0
leaq 0x16575(%rip), %rdi     # 0x3581a
leaq 0x16218(%rip), %rsi     # 0x354c4
leaq 0x16526(%rip), %rcx     # 0x357d9
movl $0xa7f, %edx            # imm = 0xA7F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_double_val
double asm_parser_get_double_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f2e0
testq %rsi, %rsi
je 0x1f2ff
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x1f31e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c8ea
leaq 0x1746f(%rip), %rdi     # 0x36756
leaq 0x161d6(%rip), %rsi     # 0x354c4
leaq 0x16549(%rip), %rcx     # 0x3583e
movl $0xa88, %edx            # imm = 0xA88
callq 0xa0b0
leaq 0x139f5(%rip), %rdi     # 0x32cfb
leaq 0x161b7(%rip), %rsi     # 0x354c4
leaq 0x1652a(%rip), %rcx     # 0x3583e
movl $0xa89, %edx            # imm = 0xA89
callq 0xa0b0
leaq 0x164f5(%rip), %rdi     # 0x3581a
leaq 0x16198(%rip), %rsi     # 0x354c4
leaq 0x1650b(%rip), %rcx     # 0x3583e
movl $0xa8a, %edx            # imm = 0xA8A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_get_char_val
char asm_parser_get_char_val(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_CHAR);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f360
testq %rsi, %rsi
je 0x1f37f
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x1f39e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1c96a
leaq 0x173ef(%rip), %rdi     # 0x36756
leaq 0x16156(%rip), %rsi     # 0x354c4
leaq 0x1650c(%rip), %rcx     # 0x35881
movl $0xa93, %edx            # imm = 0xA93
callq 0xa0b0
leaq 0x13975(%rip), %rdi     # 0x32cfb
leaq 0x16137(%rip), %rsi     # 0x354c4
leaq 0x164ed(%rip), %rcx     # 0x35881
movl $0xa94, %edx            # imm = 0xA94
callq 0xa0b0
leaq 0x1651b(%rip), %rdi     # 0x358c0
leaq 0x16118(%rip), %rsi     # 0x354c4
leaq 0x164ce(%rip), %rcx     # 0x35881
movl $0xa95, %edx            # imm = 0xA95
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_has_unsigned_mark
bool asm_parser_has_unsigned_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f3e0
testq %rsi, %rsi
je 0x1f3ff
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x1f41e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1ca69
leaq 0x1736f(%rip), %rdi     # 0x36756
leaq 0x160d6(%rip), %rsi     # 0x354c4
leaq 0x164ef(%rip), %rcx     # 0x358e4
movl $0xa9e, %edx            # imm = 0xA9E
callq 0xa0b0
leaq 0x138f5(%rip), %rdi     # 0x32cfb
leaq 0x160b7(%rip), %rsi     # 0x354c4
leaq 0x164d0(%rip), %rcx     # 0x358e4
movl $0xa9f, %edx            # imm = 0xA9F
callq 0xa0b0
leaq 0x1634b(%rip), %rdi     # 0x35770
leaq 0x16098(%rip), %rsi     # 0x354c4
leaq 0x164b1(%rip), %rcx     # 0x358e4
movl $0xaa0, %edx            # imm = 0xAA0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: asm_parser_has_float_mark
bool asm_parser_has_float_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == ASM_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x1f460
testq %rsi, %rsi
je 0x1f47f
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x1f49e
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1caf2
leaq 0x172ef(%rip), %rdi     # 0x36756
leaq 0x16056(%rip), %rsi     # 0x354c4
leaq 0x164b4(%rip), %rcx     # 0x35929
movl $0xaa9, %edx            # imm = 0xAA9
callq 0xa0b0
leaq 0x13875(%rip), %rdi     # 0x32cfb
leaq 0x16037(%rip), %rsi     # 0x354c4
leaq 0x16495(%rip), %rcx     # 0x35929
movl $0xaaa, %edx            # imm = 0xAAA
callq 0xa0b0
leaq 0x16375(%rip), %rdi     # 0x3581a
leaq 0x16018(%rip), %rsi     # 0x354c4
leaq 0x16476(%rip), %rcx     # 0x35929
movl $0xaab, %edx            # imm = 0xAAB
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: rule_expr_mul
_RULE(expr_mul)
	_RULE_RETURNED_NODE(_RULE_NAME(expr_unary)(_RULE_PARSER_CTX))

	for (;_RULE_CURRENT_NODE != NULL;) {
		_RULE_PUSH_LEXCTX
		_RULE_NEXT_TOKEN
		if (_RULE_TOKEN_TYPE == ASM_TOKEN_PNCT_MUL) {
			_EXPR_BINARY_ITEM(ASM_NODE_EXPR_MUL, expr_unary)
		} else if (_RULE_TOKEN_TYPE == ASM_TOKEN_PNCT_DIV) {
			_EXPR_BINARY_ITEM(ASM_NODE_EXPR_DIV, expr_unary)
		} else if (_RULE_TOKEN_TYPE == ASM_TOKEN_PNCT_MOD) {
			_EXPR_BINARY_ITEM(ASM_NODE_EXPR_MOD, expr_unary)
		} else {
			_RULE_POP_LEXCTX
			break;
		}
		_RULE_ABANDON_LEXCTX
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2259d
callq 0xb5c2
movq %rbx, %rdi
callq 0x225bc
testq %rax, %rax
je 0x22576
movq %rax, %r13
leaq 0x1391b(%rip), %r15     # 0x35da5
leaq 0x13902(%rip), %r12     # 0x35d93
movq (%rbx), %rdi
callq 0xb5c2
movq (%rbx), %rdi
callq 0xb36e
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x2257b
movl (%rax), %eax
cmpl $0x4015, %eax           # imm = 0x4015
je 0x22503
cmpl $0x4014, %eax           # imm = 0x4014
je 0x224e6
cmpl $0x4013, %eax           # imm = 0x4013
jne 0x2257b
movq %rbx, %rdi
callq 0x225bc
movq %rax, %r14
testq %rax, %rax
je 0x22558
movq %rbx, %rdi
movl $0xeb0, %esi            # imm = 0xEB0
movq %r12, %rdx
jmp 0x22522
movq %rbx, %rdi
callq 0x225bc
movq %rax, %r14
testq %rax, %rax
je 0x22558
movq %rbx, %rdi
movl $0xeb1, %esi            # imm = 0xEB1
movq %r15, %rdx
jmp 0x22522
movq %rbx, %rdi
callq 0x225bc
movq %rax, %r14
testq %rax, %rax
je 0x22558
movq %rbx, %rdi
movl $0xeb2, %esi            # imm = 0xEB2
leaq 0x13895(%rip), %rdx     # 0x35db7
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xd641
movq %rax, 0x30(%r13)
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xd91f
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xd91f
movq %rax, %r13
jmp 0x22560
movq (%rbx), %rdi
callq 0xb62a
testq %r14, %r14
je 0x22583
movq (%rbx), %rdi
callq 0xb68b
testq %r13, %r13
jne 0x22491
xorl %r13d, %r13d
jmp 0x22583
movq (%rbx), %rdi
callq 0xb62a
movq (%rbx), %rdi
callq 0xb68b
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x133f4(%rip), %rdi     # 0x35998
leaq 0x12f19(%rip), %rsi     # 0x354c4
leaq 0x137b2(%rip), %rcx     # 0x35d64
movl $0x12e, %edx            # imm = 0x12E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: get_seg_reg_id
static int _get_seg_reg_id(
	LexerToken *token
) {
	assert(token);

	InsRegister *reg = _get_ins_reg_by_token(token);
	
	if (reg != NULL && reg->type == INS_REGISTER_SEG) {
		return reg->id;
	} else {
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x23039
callq 0x2316b
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x23037
cmpl $0x1, 0xc(%rcx)
jne 0x23037
movl 0x8(%rcx), %eax
popq %rbp
retq
leaq 0xb48a(%rip), %rdi      # 0x2e4ca
leaq 0x1247d(%rip), %rsi     # 0x354c4
leaq 0x1303e(%rip), %rcx     # 0x3608c
movl $0x217, %edx            # imm = 0x217
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/comment.c
// Function: pp_comment_process
void pp_comment_process(
	ResizableString *dst,
	const char *file,
	const char *src,
	int len
) {
	assert(dst);
	assert(file);
	assert(src);

	LexerContext *ctx = lexer_new_context(file, src, len, _matchers);
	lexer_parse_first(ctx);

	LexerToken *token;
	while ((token = lexer_next_token(ctx)) != NULL) {
		switch (token->type) {
			case _TOKEN_LITERAL_CHAR:
			case _TOKEN_LITERAL_STRING:
			case _TOKEN_TEXT: {
				rstr_append_with_raw(dst, token->content, token->len);
				break;
			}
			case _TOKEN_SINGLE_LINE_COMMENT: {
				for (int i = 0; i < token->len; i++) {
					rstr_append_with_char(dst, ' ');
				}
				break;
			}
			case _TOKEN_MULTILINE_COMMENT: {
				for (int i = 0; i < token->len; i++) {
					if (token->content[i] == '\n') {
						rstr_append_with_char(dst, '\n');
					} else {
						rstr_append_with_char(dst, ' ');
					}
				}
				break;
			}
			default: {
				assert(0);
			}
		}
	}

	lexer_free_context(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x24c4b
testq %rsi, %rsi
je 0x24c6a
testq %rdx, %rdx
je 0x24c89
movq %rdi, %rbx
leaq 0x224b8(%rip), %rax     # 0x47010
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
callq 0xae24
movq %rax, %r14
movq %rax, %rdi
callq 0xb8d6
movq %r14, %rdi
callq 0xb36e
testq %rax, %rax
je 0x24c1c
movq %rax, %r15
movl (%r15), %eax
leal -0x1000(%rax), %ecx
cmpl $0x3, %ecx
jae 0x24bb7
movq 0x8(%r15), %rsi
movl 0x4(%r15), %edx
movq %rbx, %rdi
callq 0xe688
movq %r14, %rdi
callq 0xb36e
movq %rax, %r15
testq %rax, %rax
jne 0x24b87
jmp 0x24c1c
cmpl $0xe000, %eax           # imm = 0xE000
je 0x24bfa
cmpl $0xe001, %eax           # imm = 0xE001
jne 0x24c2c
cmpl $0x0, 0x4(%r15)
jle 0x24ba5
xorl %r12d, %r12d
movq 0x8(%r15), %rax
cmpb $0xa, (%rax,%r12)
movl $0xa, %esi
je 0x24be4
movl $0x20, %esi
movq %rbx, %rdi
callq 0xe5eb
incq %r12
movslq 0x4(%r15), %rax
cmpq %rax, %r12
jl 0x24bcf
jmp 0x24ba5
cmpl $0x0, 0x4(%r15)
jle 0x24ba5
xorl %r12d, %r12d
movq %rbx, %rdi
movl $0x20, %esi
callq 0xe5eb
incl %r12d
cmpl 0x4(%r15), %r12d
jl 0x24c04
jmp 0x24ba5
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb119
leaq 0xa761(%rip), %rdi      # 0x2f394
leaq 0x11961(%rip), %rsi     # 0x3659b
leaq 0x1197a(%rip), %rcx     # 0x365bb
movl $0x111, %edx            # imm = 0x111
callq 0xa0b0
leaq 0x9417(%rip), %rdi      # 0x2e069
leaq 0x11942(%rip), %rsi     # 0x3659b
leaq 0x1195b(%rip), %rcx     # 0x365bb
movl $0xf0, %edx
callq 0xa0b0
leaq 0x9da8(%rip), %rdi      # 0x2ea19
leaq 0x11923(%rip), %rsi     # 0x3659b
leaq 0x1193c(%rip), %rcx     # 0x365bb
movl $0xf1, %edx
callq 0xa0b0
leaq 0xb26d(%rip), %rdi      # 0x2fefd
leaq 0x11904(%rip), %rsi     # 0x3659b
leaq 0x1191d(%rip), %rcx     # 0x365bb
movl $0xf2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/evaluator.c
// Function: pp_eval
int pp_eval(
	PPGeneratorContext *genctx,
	const char *expr,
	int len
) {
	assert(genctx);
	assert(expr);

	int result;

	LexerContext *lexctx = lexer_new_context(
		genctx->psrctx->lexctx->file,
		expr,
		len,
		_matchers
	);
	lexer_parse(lexctx);

	ParserContext *psrctx = parser_new_context(lexctx);
	psrctx->arch = genctx->psrctx->arch;
	psrctx->ast = _rule_expr_wrapper(psrctx);

	result = _eval_expr(genctx, psrctx->ast);

	parser_free_context(psrctx);

	lexer_free_context(lexctx);

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2527a
testq %rsi, %rsi
je 0x25299
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x21ed1(%rip), %rcx     # 0x47070
callq 0xae24
movq %rax, %r14
movq %rax, %rdi
callq 0xb6e0
movq %r14, %rdi
callq 0xd539
movq %rax, %r15
movq (%rbx), %rax
movl 0x30(%rax), %eax
movl %eax, 0x30(%r15)
testq %r15, %r15
je 0x252b8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x252c1
callq 0xb5c2
movq %r15, %rdi
callq 0x274ae
movq %rax, %r12
testq %rax, %rax
je 0x2522e
leaq 0xc14d(%rip), %rdx      # 0x31342
movq %r15, %rdi
movl $0xe00, %esi            # imm = 0xE00
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xd641
movq 0x20(%r15), %rcx
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
movq %rax, 0x30(%r12)
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xd91f
movq %rax, %r13
jmp 0x25231
xorl %r13d, %r13d
movq (%r15), %rdi
testq %r12, %r12
je 0x25240
callq 0xb68b
jmp 0x25248
callq 0xb62a
xorl %r13d, %r13d
movq %r13, 0x8(%r15)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x252e0
movl %eax, %ebx
movq %r15, %rdi
callq 0xd547
movq %r14, %rdi
callq 0xb119
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x11467(%rip), %rdi     # 0x366e8
leaq 0x11467(%rip), %rsi     # 0x366ef
leaq 0x11482(%rip), %rcx     # 0x36711
movl $0x585, %edx            # imm = 0x585
callq 0xa0b0
leaq 0xc890(%rip), %rdi      # 0x31b30
leaq 0x11448(%rip), %rsi     # 0x366ef
leaq 0x11463(%rip), %rcx     # 0x36711
movl $0x586, %edx            # imm = 0x586
callq 0xa0b0
leaq 0x11495(%rip), %rdi     # 0x36754
jmp 0x252c8
leaq 0x106d0(%rip), %rdi     # 0x35998
leaq 0x11420(%rip), %rsi     # 0x366ef
leaq 0x1076f(%rip), %rcx     # 0x35a45
movl $0x2a0, %edx            # imm = 0x2A0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/evaluator.c
// Function: get_string_from_node
static void _get_string_from_node(
	PPGeneratorContext *genctx,
	ResizableString *rstr,
	ParserASTNode *node
) {
	assert(rstr);
	assert(node);

	if (node->type == _NODE_IDENTIFIER) {
		ResizableString rstr_tmp;
		rstr_init(&rstr_tmp);

		ResizableString rstr_tmp_trimed;
		rstr_init(&rstr_tmp_trimed);

		expand_macro_rstr(
			&rstr_tmp,
			genctx,
			node->token->content,
			node->token->len
		);

		rstr_trim_ex(&rstr_tmp_trimed, &rstr_tmp, RSTR_SPACE_CHAR_COMPARER);

		if (util_is_literal_string(RSTR_CSTR(&rstr_tmp_trimed), RSTR_LEN(&rstr_tmp_trimed))) {
			util_get_str_val(
				rstr,
				RSTR_CSTR(&rstr_tmp_trimed),
				RSTR_LEN(&rstr_tmp_trimed)
			);
		} else {
			rstr_append_with_rstr(rstr, &rstr_tmp);
		}

		rstr_free(&rstr_tmp);
		rstr_free(&rstr_tmp_trimed);	
	} else if (node->type == _NODE_LITERAL_STRING) {
		util_get_str_val(
			rstr,
			node->token->content,
			node->token->len
		);
	} else {
		assert(0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rsi, %rsi
je 0x288de
movq %rdx, %r15
testq %rdx, %rdx
je 0x288fd
movq %rsi, %rbx
movl (%r15), %eax
cmpl $0x302, %eax            # imm = 0x302
je 0x28890
cmpl $0x200, %eax            # imm = 0x200
jne 0x2891c
movq %rdi, %r14
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xe468
leaq -0x38(%rbp), %r13
movq %r13, %rdi
callq 0xe468
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdx
movl 0x4(%rax), %ecx
movq %r12, %rdi
movq %r14, %rsi
callq 0x2b098
leaq -0x193ac(%rip), %rdx    # 0xf49f
movq %r13, %rdi
movq %r12, %rsi
callq 0xf6fa
movq 0x8(%r13), %rdi
testq %rdi, %rdi
leaq 0x6f52(%rip), %r14      # 0x2f7b6
cmoveq %r14, %rdi
movl 0x4(%r13), %esi
callq 0x109bb
testb %al, %al
je 0x288b1
movq -0x30(%rbp), %rax
testq %rax, %rax
cmovneq %rax, %r14
movl -0x34(%rbp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10f79
jmp 0x288bd
movq 0x10(%r15), %rax
movq 0x8(%rax), %rsi
movl 0x4(%rax), %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10f79
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xe7ac
leaq -0x48(%rbp), %rdi
callq 0xe958
leaq -0x38(%rbp), %rdi
callq 0xe958
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x717b(%rip), %rdi      # 0x2fa60
leaq 0xde03(%rip), %rsi      # 0x366ef
leaq 0xdf02(%rip), %rcx      # 0x367f5
movl $0x49f, %edx            # imm = 0x49F
callq 0xa0b0
leaq 0xa3f7(%rip), %rdi      # 0x32cfb
leaq 0xdde4(%rip), %rsi      # 0x366ef
leaq 0xdee3(%rip), %rcx      # 0x367f5
movl $0x4a0, %edx            # imm = 0x4A0
callq 0xa0b0
leaq 0x6a71(%rip), %rdi      # 0x2f394
leaq 0xddc5(%rip), %rsi      # 0x366ef
leaq 0xdec4(%rip), %rcx      # 0x367f5
movl $0x4c5, %edx            # imm = 0x4C5
callq 0xa0b0
nop
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: pp_gen_generate
void pp_gen_generate(PPGeneratorContext *ctx) {
	assert(ctx);
	assert(ctx->psrctx);
	assert(ctx->psrctx->ast);
	assert(ctx->psrctx->ast->type == PP_NODE_MODULE);

	_gen_module(ctx, ctx->psrctx->ast);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2896b
movq (%rdi), %rax
testq %rax, %rax
je 0x2898a
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x289a9
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x289c8
movq 0x48(%rax), %rax
movq (%rax), %rsi
popq %rbp
jmp 0x28ddc
leaq 0xdde4(%rip), %rdi      # 0x36756
leaq 0xe00b(%rip), %rsi      # 0x36984
leaq 0xe020(%rip), %rcx      # 0x369a0
movl $0x409, %edx            # imm = 0x409
callq 0xa0b0
leaq 0xe03a(%rip), %rdi      # 0x369cb
leaq 0xdfec(%rip), %rsi      # 0x36984
leaq 0xe001(%rip), %rcx      # 0x369a0
movl $0x40a, %edx            # imm = 0x40A
callq 0xa0b0
leaq 0xe027(%rip), %rdi      # 0x369d7
leaq 0xdfcd(%rip), %rsi      # 0x36984
leaq 0xdfe2(%rip), %rcx      # 0x369a0
movl $0x40b, %edx            # imm = 0x40B
callq 0xa0b0
leaq 0xe019(%rip), %rdi      # 0x369e8
leaq 0xdfae(%rip), %rsi      # 0x36984
leaq 0xdfc3(%rip), %rcx      # 0x369a0
movl $0x40c, %edx            # imm = 0x40C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: delete_gen_func_macro
static void _delete_gen_func_macro(PPGeneratorFuncMacro *macro) {
	assert(macro);
	llst_free(&(macro->params), true);
	rstr_free(&(macro->body));
	free(macro);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28c19
movq %rdi, %rbx
movl $0x1, %esi
callq 0xbd6d
leaq 0x28(%rbx), %rdi
callq 0xe958
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa190
leaq 0xe52c(%rip), %rdi      # 0x3714c
leaq 0xdd5d(%rip), %rsi      # 0x36984
leaq 0xe524(%rip), %rcx      # 0x37152
movl $0x10e, %edx            # imm = 0x10E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: pp_gen_free_context
void pp_gen_free_context(PPGeneratorContext *ctx) {
	assert(ctx);

	if (ctx->map_kv != NULL) {
		map_free(ctx->map_kv, true, true);
		free(ctx->map_kv);
	}

	if (ctx->map_kv_with_params != NULL) {
		map_free(ctx->map_kv_with_params, true, true);
		free(ctx->map_kv_with_params);
	}

	llst_free(&(ctx->include_paths), true);

	free(ctx);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28ca4
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x28c67
movl $0x1, %esi
movl $0x1, %edx
callq 0xc5ca
movq 0x18(%rbx), %rdi
callq 0xa190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x28c88
movl $0x1, %esi
movl $0x1, %edx
callq 0xc5ca
movq 0x20(%rbx), %rdi
callq 0xa190
leaq 0x30(%rbx), %rdi
movl $0x1, %esi
callq 0xbd6d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa190
leaq 0xdaab(%rip), %rdi      # 0x36756
leaq 0xdcd2(%rip), %rsi      # 0x36984
leaq 0xde17(%rip), %rcx      # 0x36ad0
movl $0x457, %edx            # imm = 0x457
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: pp_gen_define
void pp_gen_define(
	PPGeneratorContext *ctx,
	ResizableString *k,
	ResizableString *v
) {
	assert(ctx);
	assert(k);

	ResizableString *key = rstr_new_with_rstr(k);
	if (RSTR_LEN(key) == 0) {
		_SYNERR(ctx, "invalid macro name.");
	}
	for (int i = 0; i < RSTR_LEN(key); i++) {
		if (!util_is_identifier_item(RSTR_CHAR(key, i))) {
			_SYNERR(ctx, "invalid macro name.");
		}
	}

	ResizableString *value;
	if (v == NULL) {
		value = rstr_new();
	} else {
		value = rstr_new_with_rstr(v);
	}

	map_remove(ctx->map_kv, key, true, true);
	map_set(ctx->map_kv, key, value, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x28d9e
testq %rsi, %rsi
je 0x28dbd
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
movq %rsi, %rdi
callq 0xe933
movq %rax, %r14
cmpl $0x0, 0x4(%rax)
jne 0x28d08
movq (%rbx), %rdi
leaq 0xde4b(%rip), %rsi      # 0x36b50
callq *0x48(%rdi)
cmpl $0x0, 0x4(%r14)
jle 0x28d4e
xorl %r13d, %r13d
leaq 0x6a9d(%rip), %r15      # 0x2f7b6
leaq 0xde30(%rip), %r12      # 0x36b50
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %r15, %rax
movsbl (%rax,%r13), %edi
callq 0x107e2
testb %al, %al
jne 0x28d42
movq (%rbx), %rdi
movq %r12, %rsi
callq *0x48(%rdi)
incq %r13
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jl 0x28d20
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x28d5e
callq 0xe933
jmp 0x28d63
callq 0xe84a
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0xc855
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl $0x1, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc658
leaq 0xd9b1(%rip), %rdi      # 0x36756
leaq 0xdbd8(%rip), %rsi      # 0x36984
leaq 0xdd4c(%rip), %rcx      # 0x36aff
movl $0x46d, %edx            # imm = 0x46D
callq 0xa0b0
leaq 0xdd8a(%rip), %rdi      # 0x36b4e
leaq 0xdbb9(%rip), %rsi      # 0x36984
leaq 0xdd2d(%rip), %rcx      # 0x36aff
movl $0x46e, %edx            # imm = 0x46E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: include_file_from_include_path
static void _include_file_from_include_path(
	PPGeneratorContext *ctx,
	ParserASTNode *node,
	ResizableString *filename
) {
	assert(ctx);
	assert(node);
	assert(filename);

	bool included = false;
	LinkedListNode *n = ctx->include_paths.head;
	while (!included && n != NULL) {
		ResizableString filepath;
		rstr_init_with_rstr(&filepath, n->data);
		rstr_append_with_rstr(&filepath, filename);

		if (_include_file(ctx, RSTR_CSTR(&filepath))) {
			included = true;
		}

		rstr_free(&filepath);
		n = n->next;
	}
	if (!included) {
		_SYNERR_NODE(ctx, node, "cannot include file.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rdx, %rdx
je 0x29f25
movq %rdi, %r14
movq 0x30(%rdi), %r13
testq %r13, %r13
je 0x29eee
movq %rdx, %r15
movq %rsi, -0x30(%rbp)
xorl %ebx, %ebx
leaq -0x430(%rbp), %r12
movq 0x8(%r13), %rsi
movq %r12, %rdi
callq 0xe754
movq %r12, %rdi
movq %r15, %rsi
callq 0xe7ac
movq -0x428(%rbp), %rsi
testq %rsi, %rsi
leaq 0x5900(%rip), %rax      # 0x2f7b6
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x29f44
movzbl %bl, %ebx
testb %al, %al
movl $0x1, %eax
cmovnel %eax, %ebx
movq %r12, %rdi
callq 0xe958
testb $0x1, %bl
jne 0x29ee5
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x29e8e
testb $0x1, %bl
movq -0x30(%rbp), %rsi
jne 0x29f13
movups 0xcdc0(%rip), %xmm0     # 0x36cb5
leaq -0x430(%rbp), %rdx
movaps %xmm0, (%rdx)
movabsq $0x2e656c69662065, %rax # imm = 0x2E656C69662065
movq %rax, 0xd(%rdx)
movq (%r14), %rdi
callq *0x58(%rdi)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcd80(%rip), %rdi      # 0x36cac
leaq 0xca51(%rip), %rsi      # 0x36984
leaq 0xcd13(%rip), %rcx      # 0x36c4d
movl $0xb2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_if_block
static void _gen_if_block(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_BLOCK);

	if (node->nchilds > 0) {
		ParserASTNode *child = node->childs[0];
		_OUT_FMT(ctx, "#line %d \"%s\"", child->line, child->file);
	}

	_gen_block(ctx, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rsi, %rsi
je 0x2a228
movq %rsi, %rbx
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x2a247
movq %rdi, %r14
cmpl $0x0, 0x44(%rbx)
jle 0x2a20f
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2a1df
movl 0x20(%rax), %edx
movq 0x18(%rax), %rcx
leaq 0xca4a(%rip), %rsi      # 0x36c20
xorl %eax, %eax
callq 0xa0f0
jmp 0x2a20f
movl 0x20(%rax), %ecx
movq 0x18(%rax), %r8
leaq 0xca33(%rip), %rdx      # 0x36c20
leaq -0x420(%rbp), %r15
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdi
xorl %eax, %eax
callq 0xa0a0
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0xe4ef
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28ddc
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8acc(%rip), %rdi      # 0x32cfb
leaq 0xc74e(%rip), %rsi      # 0x36984
leaq 0xcbe1(%rip), %rcx      # 0x36e1e
movl $0x3ef, %edx            # imm = 0x3EF
callq 0xa0b0
leaq 0xc94d(%rip), %rdi      # 0x36b9b
leaq 0xc72f(%rip), %rsi      # 0x36984
leaq 0xcbc2(%rip), %rcx      # 0x36e1e
movl $0x3f0, %edx            # imm = 0x3F0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/lexer.c
// Function: pp_lexer_new_context
LexerContext * pp_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
testq %rdi, %rdi
je 0x2a8a3
testq %rsi, %rsi
je 0x2a8c2
testl %edx, %edx
js 0x2a8e1
leaq 0x1c9d3(%rip), %rcx     # 0x47270
popq %rbp
jmp 0xae24
leaq 0x416f(%rip), %rdi      # 0x2ea19
leaq 0xc8d5(%rip), %rsi      # 0x37186
leaq 0xc8ec(%rip), %rcx      # 0x371a4
movl $0xdc, %edx
callq 0xa0b0
leaq 0x3c7d(%rip), %rdi      # 0x2e546
leaq 0xc8b6(%rip), %rsi      # 0x37186
leaq 0xc8cd(%rip), %rcx      # 0x371a4
movl $0xdd, %edx
callq 0xa0b0
leaq 0x3c65(%rip), %rdi      # 0x2e54d
leaq 0xc897(%rip), %rsi      # 0x37186
leaq 0xc8ae(%rip), %rcx      # 0x371a4
movl $0xde, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/line.c
// Function: expand_macro_rstr
void expand_macro_rstr(
	ResizableString *rstr,
	PPGeneratorContext *genctx,
	const char *key,
	int len
) {
	assert(rstr);
	assert(genctx);
	assert(key);

	_expand_macro_rstr(rstr, genctx, key, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2b0ae
testq %rsi, %rsi
je 0x2b0cd
testq %rdx, %rdx
je 0x2b0ec
popq %rbp
jmp 0x2b10b
leaq 0x49ab(%rip), %rdi      # 0x2fa60
leaq 0xc222(%rip), %rsi      # 0x372de
leaq 0xc238(%rip), %rcx      # 0x372fb
movl $0x296, %edx            # imm = 0x296
callq 0xa0b0
leaq 0xb614(%rip), %rdi      # 0x366e8
leaq 0xc203(%rip), %rsi      # 0x372de
leaq 0xc219(%rip), %rcx      # 0x372fb
movl $0x297, %edx            # imm = 0x297
callq 0xa0b0
leaq 0x3cf2(%rip), %rdi      # 0x2ede5
leaq 0xc1e4(%rip), %rsi      # 0x372de
leaq 0xc1fa(%rip), %rcx      # 0x372fb
movl $0x298, %edx            # imm = 0x298
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/line.c
// Function: expand_macro_rstr
static void _expand_macro_rstr(
	ResizableString *rstr,
	PPGeneratorContext *genctx,
	const char *key,
	int len
) {
	assert(rstr);
	assert(genctx);
	assert(key);

	ResizableString rstr_key;
	rstr_init_with_raw(&rstr_key, key, len);

	if (map_exists_key(genctx->map_kv, &rstr_key)) {
		ResizableString *value = map_get(genctx->map_kv, &rstr_key);
		_expand_rstr(rstr, genctx, RSTR_CSTR(value), RSTR_LEN(value));
	} else {
		rstr_append_with_raw(rstr, key, len);
	}

	rstr_free(&rstr_key);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdx, %rdx
je 0x2b1aa
movl %ecx, %r15d
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r13
movq %r13, %rdi
movq %rdx, %rsi
movl %ecx, %edx
callq 0xe60d
movq 0x18(%r14), %rdi
movq %r13, %rsi
callq 0xc91a
testb %al, %al
je 0x2b184
movq 0x18(%r14), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc7de
movq 0x8(%rax), %rcx
testq %rcx, %rcx
leaq 0x4649(%rip), %rdx      # 0x2f7b6
cmovneq %rcx, %rdx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
callq 0x2b317
jmp 0x2b192
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0xe688
leaq -0x38(%rbp), %rdi
callq 0xe958
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3c34(%rip), %rdi      # 0x2ede5
leaq 0xc126(%rip), %rsi      # 0x372de
leaq 0xc1e6(%rip), %rcx      # 0x373a5
movl $0x17c, %edx            # imm = 0x17C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O1/Ihsoh[P]ilang/compiler/preprocessor/line.c
// Function: pp_line_process
void pp_line_process(
	PPGeneratorContext *genctx,
	ParserASTNode *node
) {
	assert(genctx);
	assert(node);
	assert(node->type == PP_NODE_LINE);

	_expand(genctx, node->token->content, node->token->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x2b29b
testq %rsi, %rsi
je 0x2b2ba
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x2b2d9
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x2b2f8
movq %rdi, %rbx
movl 0x4(%rax), %r15d
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0xe468
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r15d, %ecx
xorl %r8d, %r8d
callq 0x2b317
cmpl $0x0, 0x4(%r12)
jle 0x2b285
xorl %r14d, %r14d
leaq 0x4576(%rip), %r15      # 0x2f7b6
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x2b260
movq -0x28(%rbp), %rax
testq %rax, %rax
cmoveq %r15, %rax
movsbl (%rax,%r14), %edi
callq 0xa0d0
jmp 0x2b279
movq 0x10(%rbx), %rdi
movq -0x28(%rbp), %rax
testq %rax, %rax
cmoveq %r15, %rax
movsbl (%rax,%r14), %esi
callq 0xe5eb
incq %r14
movslq -0x2c(%rbp), %rax
cmpq %rax, %r14
jl 0x2b240
leaq -0x30(%rbp), %rdi
callq 0xe958
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb446(%rip), %rdi      # 0x366e8
leaq 0xc035(%rip), %rsi      # 0x372de
leaq 0xc09e(%rip), %rcx      # 0x3734e
movl $0x2a1, %edx            # imm = 0x2A1
callq 0xa0b0
leaq 0x7a3a(%rip), %rdi      # 0x32cfb
leaq 0xc016(%rip), %rsi      # 0x372de
leaq 0xc07f(%rip), %rcx      # 0x3734e
movl $0x2a2, %edx            # imm = 0x2A2
callq 0xa0b0
leaq 0xc0aa(%rip), %rdi      # 0x3738a
leaq 0xbff7(%rip), %rsi      # 0x372de
leaq 0xc060(%rip), %rcx      # 0x3734e
movl $0x2a3, %edx            # imm = 0x2A3
callq 0xa0b0
leaq 0x4bfe(%rip), %rdi      # 0x2fefd
leaq 0xbfd8(%rip), %rsi      # 0x372de
leaq 0xc322(%rip), %rcx      # 0x3762f
movl $0x285, %edx            # imm = 0x285
callq 0xa0b0