LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0xd0, %rsp
testb %al, %al
je 0x29dd5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rax
leaq -0xd0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0x2e1d1(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
leaq 0x23868(%rip), %rdi     # 0x4d699
callq 0xa0c0
movq 0x2e1bb(%rip), %rax     # 0x57ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0xa160
movq 0x2e1a4(%rip), %rax     # 0x57ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0xa0e0
leaq -0x20(%rbp), %rax
movl $0x1, %edi
callq 0xa180
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x29e8f
jmp 0x29eae
leaq 0x1cbd8(%rip), %rdi     # 0x46a6e
leaq 0x2381b(%rip), %rsi     # 0x4d6b8
movl $0x987, %edx            # imm = 0x987
leaq 0x2382b(%rip), %rcx     # 0x4d6d4
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x29eb7
jmp 0x29ed6
leaq 0x1c6dd(%rip), %rdi     # 0x4659b
leaq 0x237f3(%rip), %rsi     # 0x4d6b8
movl $0x988, %edx            # imm = 0x988
leaq 0x23803(%rip), %rcx     # 0x4d6d4
callq 0xa0b0
cmpl $0x0, -0x14(%rbp)
jl 0x29ede
jmp 0x29efd
leaq 0x1c6bd(%rip), %rdi     # 0x465a2
leaq 0x237cc(%rip), %rsi     # 0x4d6b8
movl $0x989, %edx            # imm = 0x989
leaq 0x237dc(%rip), %rcx     # 0x4d6d4
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x25bd0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbe70
leaq -0x88(%rbp), %rdi
leaq -0x1bfc8(%rip), %rsi    # 0xdf60
xorl %eax, %eax
movl %eax, %edx
leaq -0x19b93(%rip), %rcx    # 0x103a0
leaq -0x1c02a(%rip), %r8     # 0xdf10
callq 0xd210
movl $0x1, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x1, -0x28(%rbp)
movb $0x0, -0x24(%rbp)
movb $0x0, -0x23(%rbp)
movq -0x20(%rbp), %rdi
movl $0x68, %esi
leaq -0x88(%rbp), %rdx
callq 0xe320
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: rule_module
_RULE_END
_RULE(module)
	_RULE_NODE(ASM_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 0x2a075
jmp 0x2a094
leaq 0x23ae3(%rip), %rdi     # 0x4db5f
leaq 0x23635(%rip), %rsi     # 0x4d6b8
movl $0x972, %edx            # imm = 0x972
leaq 0x23ad6(%rip), %rcx     # 0x4db65
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x2a0a0
jmp 0x2a0bf
leaq 0x23aeb(%rip), %rdi     # 0x4db92
leaq 0x2360a(%rip), %rsi     # 0x4d6b8
movl $0x972, %edx            # imm = 0x972
leaq 0x23aab(%rip), %rcx     # 0x4db65
callq 0xa0b0
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbcd0
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
leaq 0x23ab5(%rip), %rdx     # 0x4dba0
xorl %eax, %eax
movl %eax, %ecx
callq 0x2ad60
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 0x2af40
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2a14b
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 0xee30
movq %rax, -0x18(%rbp)
jmp 0x2a169
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0x2a167
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
jmp 0x2a16b
jmp 0x2a114
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbdf0
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/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a1a9
jmp 0x2a1c8
leaq 0x239b1(%rip), %rdi     # 0x4db61
leaq 0x23501(%rip), %rsi     # 0x4d6b8
movl $0xa20, %edx            # imm = 0xA20
leaq 0x235be(%rip), %rcx     # 0x4d781
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2a1d5
jmp 0x2a1f4
leaq 0x24d74(%rip), %rdi     # 0x4ef50
leaq 0x234d5(%rip), %rsi     # 0x4d6b8
movl $0xa21, %edx            # imm = 0xA21
leaq 0x23592(%rip), %rcx     # 0x4d781
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2a1fd
jmp 0x2a21c
leaq 0x1c86a(%rip), %rdi     # 0x46a6e
leaq 0x234ad(%rip), %rsi     # 0x4d6b8
movl $0xa22, %edx            # imm = 0xA22
leaq 0x2356a(%rip), %rcx     # 0x4d781
callq 0xa0b0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
movl $0x9, %ecx
callq 0x2a240
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a5ed
jmp 0x2a60c
leaq 0x2356d(%rip), %rdi     # 0x4db61
leaq 0x230bd(%rip), %rsi     # 0x4d6b8
movl $0xa2c, %edx            # imm = 0xA2C
leaq 0x231ad(%rip), %rcx     # 0x4d7b4
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2a615
jmp 0x2a634
leaq 0x1c871(%rip), %rdi     # 0x46e8d
leaq 0x23095(%rip), %rsi     # 0x4d6b8
movl $0xa2d, %edx            # imm = 0xA2D
leaq 0x23185(%rip), %rcx     # 0x4d7b4
callq 0xa0b0
movq -0x8(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xdc40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl $0x1, %ecx
callq 0xd460
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a68d
jmp 0x2a6ac
leaq 0x234cd(%rip), %rdi     # 0x4db61
leaq 0x2301d(%rip), %rsi     # 0x4d6b8
movl $0xa3b, %edx            # imm = 0xA3B
leaq 0x23162(%rip), %rcx     # 0x4d809
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2a6b5
jmp 0x2a6d4
leaq 0x1c7d1(%rip), %rdi     # 0x46e8d
leaq 0x22ff5(%rip), %rsi     # 0x4d6b8
movl $0xa3c, %edx            # imm = 0xA3C
leaq 0x2313a(%rip), %rcx     # 0x4d809
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x102b0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2a5d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2a729
jmp 0x2a748
leaq 0x23431(%rip), %rdi     # 0x4db61
leaq 0x22f81(%rip), %rsi     # 0x4d6b8
movl $0xa46, %edx            # imm = 0xA46
leaq 0x23117(%rip), %rcx     # 0x4d85a
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x2a751
jmp 0x2a770
leaq 0x1c735(%rip), %rdi     # 0x46e8d
leaq 0x22f59(%rip), %rsi     # 0x4d6b8
movl $0xa47, %edx            # imm = 0xA47
leaq 0x230ef(%rip), %rcx     # 0x4d85a
callq 0xa0b0
movq -0x10(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd750
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x2a7cf
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5, %eax
jne 0x2a7a2
jmp 0x2a7c1
leaq 0x23100(%rip), %rdi     # 0x4d8a9
leaq 0x22f08(%rip), %rsi     # 0x4d6b8
movl $0xa4d, %edx            # imm = 0xA4D
leaq 0x2309e(%rip), %rcx     # 0x4d85a
callq 0xa0b0
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x2a7d7
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a809
jmp 0x2a828
leaq 0x23351(%rip), %rdi     # 0x4db61
leaq 0x22ea1(%rip), %rsi     # 0x4d6b8
movl $0xa58, %edx            # imm = 0xA58
leaq 0x230b1(%rip), %rcx     # 0x4d8d4
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2a831
jmp 0x2a850
leaq 0x1c655(%rip), %rdi     # 0x46e8d
leaq 0x22e79(%rip), %rsi     # 0x4d6b8
movl $0xa59, %edx            # imm = 0xA59
leaq 0x23089(%rip), %rcx     # 0x4d8d4
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq -0x20(%rbp), %rdi
callq 0xfef0
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2a710
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x10320
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a8a9
jmp 0x2a8c8
leaq 0x232b1(%rip), %rdi     # 0x4db61
leaq 0x22e01(%rip), %rsi     # 0x4d6b8
movl $0xa67, %edx            # imm = 0xA67
leaq 0x2305c(%rip), %rcx     # 0x4d91f
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2a8d1
jmp 0x2a8f0
leaq 0x207af(%rip), %rdi     # 0x4b087
leaq 0x22dd9(%rip), %rsi     # 0x4d6b8
movl $0xa68, %edx            # imm = 0xA68
leaq 0x23034(%rip), %rcx     # 0x4d91f
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x2a8fe
jmp 0x2a91d
leaq 0x2305f(%rip), %rdi     # 0x4d964
leaq 0x22dac(%rip), %rsi     # 0x4d6b8
movl $0xa69, %edx            # imm = 0xA69
leaq 0x23007(%rip), %rcx     # 0x4d91f
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x25cd0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2a959
jmp 0x2a978
leaq 0x23201(%rip), %rdi     # 0x4db61
leaq 0x22d51(%rip), %rsi     # 0x4d6b8
movl $0xa72, %edx            # imm = 0xA72
leaq 0x23015(%rip), %rcx     # 0x4d988
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2a981
jmp 0x2a9a0
leaq 0x206ff(%rip), %rdi     # 0x4b087
leaq 0x22d29(%rip), %rsi     # 0x4d6b8
movl $0xa73, %edx            # imm = 0xA73
leaq 0x22fed(%rip), %rcx     # 0x4d988
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x2a9ae
jmp 0x2a9cd
leaq 0x22faf(%rip), %rdi     # 0x4d964
leaq 0x22cfc(%rip), %rsi     # 0x4d6b8
movl $0xa74, %edx            # imm = 0xA74
leaq 0x22fc0(%rip), %rcx     # 0x4d988
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x25df0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2aa09
jmp 0x2aa28
leaq 0x23151(%rip), %rdi     # 0x4db61
leaq 0x22ca1(%rip), %rsi     # 0x4d6b8
movl $0xa7d, %edx            # imm = 0xA7D
leaq 0x22faa(%rip), %rcx     # 0x4d9cd
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2aa31
jmp 0x2aa50
leaq 0x2064f(%rip), %rdi     # 0x4b087
leaq 0x22c79(%rip), %rsi     # 0x4d6b8
movl $0xa7e, %edx            # imm = 0xA7E
leaq 0x22f82(%rip), %rcx     # 0x4d9cd
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x2aa5e
jmp 0x2aa7d
leaq 0x22fa9(%rip), %rdi     # 0x4da0e
leaq 0x22c4c(%rip), %rsi     # 0x4d6b8
movl $0xa7f, %edx            # imm = 0xA7F
leaq 0x22f55(%rip), %rcx     # 0x4d9cd
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x25f10
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2aab9
jmp 0x2aad8
leaq 0x230a1(%rip), %rdi     # 0x4db61
leaq 0x22bf1(%rip), %rsi     # 0x4d6b8
movl $0xa88, %edx            # imm = 0xA88
leaq 0x22f5f(%rip), %rcx     # 0x4da32
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2aae1
jmp 0x2ab00
leaq 0x2059f(%rip), %rdi     # 0x4b087
leaq 0x22bc9(%rip), %rsi     # 0x4d6b8
movl $0xa89, %edx            # imm = 0xA89
leaq 0x22f37(%rip), %rcx     # 0x4da32
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x2ab0e
jmp 0x2ab2d
leaq 0x22ef9(%rip), %rdi     # 0x4da0e
leaq 0x22b9c(%rip), %rsi     # 0x4d6b8
movl $0xa8a, %edx            # imm = 0xA8A
leaq 0x22f0a(%rip), %rcx     # 0x4da32
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x25fc0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2ab69
jmp 0x2ab88
leaq 0x22ff1(%rip), %rdi     # 0x4db61
leaq 0x22b41(%rip), %rsi     # 0x4d6b8
movl $0xa93, %edx            # imm = 0xA93
leaq 0x22ef2(%rip), %rcx     # 0x4da75
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2ab91
jmp 0x2abb0
leaq 0x204ef(%rip), %rdi     # 0x4b087
leaq 0x22b19(%rip), %rsi     # 0x4d6b8
movl $0xa94, %edx            # imm = 0xA94
leaq 0x22eca(%rip), %rcx     # 0x4da75
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x302, (%rax)          # imm = 0x302
jne 0x2abbe
jmp 0x2abdd
leaq 0x22eef(%rip), %rdi     # 0x4dab4
leaq 0x22aec(%rip), %rsi     # 0x4d6b8
movl $0xa95, %edx            # imm = 0xA95
leaq 0x22e9d(%rip), %rcx     # 0x4da75
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x26070
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2ac19
jmp 0x2ac38
leaq 0x22f41(%rip), %rdi     # 0x4db61
leaq 0x22a91(%rip), %rsi     # 0x4d6b8
movl $0xa9e, %edx            # imm = 0xA9E
leaq 0x22ea5(%rip), %rcx     # 0x4dad8
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2ac41
jmp 0x2ac60
leaq 0x2043f(%rip), %rdi     # 0x4b087
leaq 0x22a69(%rip), %rsi     # 0x4d6b8
movl $0xa9f, %edx            # imm = 0xA9F
leaq 0x22e7d(%rip), %rcx     # 0x4dad8
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x2ac6e
jmp 0x2ac8d
leaq 0x22cef(%rip), %rdi     # 0x4d964
leaq 0x22a3c(%rip), %rsi     # 0x4d6b8
movl $0xaa0, %edx            # imm = 0xAA0
leaq 0x22e50(%rip), %rcx     # 0x4dad8
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x261d0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x2acc9
jmp 0x2ace8
leaq 0x22e91(%rip), %rdi     # 0x4db61
leaq 0x229e1(%rip), %rsi     # 0x4d6b8
movl $0xaa9, %edx            # imm = 0xAA9
leaq 0x22e3a(%rip), %rcx     # 0x4db1d
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x2acf1
jmp 0x2ad10
leaq 0x2038f(%rip), %rdi     # 0x4b087
leaq 0x229b9(%rip), %rsi     # 0x4d6b8
movl $0xaaa, %edx            # imm = 0xAAA
leaq 0x22e12(%rip), %rcx     # 0x4db1d
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x2ad1e
jmp 0x2ad3d
leaq 0x22ce9(%rip), %rdi     # 0x4da0e
leaq 0x2298c(%rip), %rsi     # 0x4d6b8
movl $0xaab, %edx            # imm = 0xAAB
leaq 0x22de5(%rip), %rcx     # 0x4db1d
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x262b0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: is_seg_oprd
static bool _is_seg_oprd(
	uint16_t oprd_type
) {
	return oprd_type == INS_AM_CS
			|| oprd_type == INS_AM_SS
			|| oprd_type == INS_AM_DS
			|| oprd_type == INS_AM_ES
			|| oprd_type == INS_AM_FS
			|| oprd_type == INS_AM_GS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, %ax
movw %ax, -0x2(%rbp)
movzwl -0x2(%rbp), %ecx
movb $0x1, %al
cmpl $0x8000, %ecx           # imm = 0x8000
movb %al, -0x3(%rbp)
je 0x2fddf
movzwl -0x2(%rbp), %ecx
movb $0x1, %al
cmpl $0x8100, %ecx           # imm = 0x8100
movb %al, -0x3(%rbp)
je 0x2fddf
movzwl -0x2(%rbp), %ecx
movb $0x1, %al
cmpl $0x8200, %ecx           # imm = 0x8200
movb %al, -0x3(%rbp)
je 0x2fddf
movzwl -0x2(%rbp), %ecx
movb $0x1, %al
cmpl $0x8300, %ecx           # imm = 0x8300
movb %al, -0x3(%rbp)
je 0x2fddf
movzwl -0x2(%rbp), %ecx
movb $0x1, %al
cmpl $0x8400, %ecx           # imm = 0x8400
movb %al, -0x3(%rbp)
je 0x2fddf
movzwl -0x2(%rbp), %eax
cmpl $0x8500, %eax           # imm = 0x8500
sete %al
movb %al, -0x3(%rbp)
movb -0x3(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x325e5
jmp 0x32604
leaq 0x13f4e(%rip), %rdi     # 0x4653a
leaq 0x1b0c5(%rip), %rsi     # 0x4d6b8
movl $0x217, %edx            # imm = 0x217
leaq 0x1bcc7(%rip), %rcx     # 0x4e2c6
callq 0xa0b0
movq -0x10(%rbp), %rdi
callq 0x32e80
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3262e
movq -0x18(%rbp), %rax
cmpl $0x1, 0xc(%rax)
jne 0x3262e
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x32635
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3639c
jmp 0x363bb
leaq 0x18821(%rip), %rdi     # 0x4ebc4
leaq 0x18821(%rip), %rsi     # 0x4ebcb
movl $0x585, %edx            # imm = 0x585
leaq 0x18837(%rip), %rcx     # 0x4ebed
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x363c4
jmp 0x363e3
leaq 0x13af1(%rip), %rdi     # 0x49ebc
leaq 0x187f9(%rip), %rsi     # 0x4ebcb
movl $0x586, %edx            # imm = 0x586
leaq 0x1880f(%rip), %rcx     # 0x4ebed
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
leaq 0x28db2(%rip), %rcx     # 0x5f1b0
callq 0xb170
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xbe70
movq -0x20(%rbp), %rdi
callq 0xe870
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x28(%rbp), %rdi
callq 0x36480
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x365b0
movl %eax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
callq 0xe8a0
movq -0x20(%rbp), %rdi
callq 0xb590
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/evaluator.c
// Function: rule_expr_or
_RULE(expr_or)
	_RULE_RETURNED_NODE(_RULE_NAME(expr_and)(_RULE_PARSER_CTX))

	for (;_RULE_CURRENT_NODE != NULL;) {
		_RULE_PUSH_LEXCTX
		_RULE_NEXT_TOKEN
		if (_RULE_TOKEN_TYPE == _TOKEN_PNCT_OR) {
			_EXPR_BINARY_ITEM(_NODE_EXPR_OR, expr_and)
		} else {
			_RULE_POP_LEXCTX
			break;
		}
		_RULE_ABANDON_LEXCTX
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x39d15
jmp 0x39d34
leaq 0x13e43(%rip), %rdi     # 0x4db5f
leaq 0x14ea8(%rip), %rsi     # 0x4ebcb
movl $0x2bb, %edx            # imm = 0x2BB
leaq 0x13fc1(%rip), %rcx     # 0x4dcf0
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x39d40
jmp 0x39d5f
leaq 0x13e4b(%rip), %rdi     # 0x4db92
leaq 0x14e7d(%rip), %rsi     # 0x4ebcb
movl $0x2bb, %edx            # imm = 0x2BB
leaq 0x13f96(%rip), %rcx     # 0x4dcf0
callq 0xa0b0
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbcd0
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39eb0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x39e8f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbcd0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xb950
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
cmpq $0x0, -0x20(%rbp)
jne 0x39dcc
movl $0xffff, %eax           # imm = 0xFFFF
movl %eax, -0x34(%rbp)
jmp 0x39dd5
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl $0x4002, %eax           # imm = 0x4002
jne 0x39e70
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x39eb0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x39e60
movq -0x10(%rbp), %rdi
movl $0xe10, %esi            # imm = 0xE10
leaq 0x13f12(%rip), %rdx     # 0x4dd21
xorl %eax, %eax
movl %eax, %ecx
callq 0x39c70
movq %rax, -0x18(%rbp)
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 0xee30
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xee30
movq %rax, -0x18(%rbp)
jmp 0x39e6e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbd60
jmp 0x39e8f
jmp 0x39e7e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbd60
jmp 0x39e8f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbdf0
jmp 0x39d88
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xbdf0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/evaluator.c
// Function: eval_expr_atom
static int _eval_expr_atom(
	PPGeneratorContext *genctx,
	ParserASTNode *node
) {
	assert(genctx);
	assert(node);
	assert(node->type == _NODE_EXPR_ATOM);
	assert(node->nchilds == 1);

	ParserASTNode *child = node->childs[0];
	switch (child->type) {
		case _NODE_IDENTIFIER: {
			return _eval_identifier(genctx, child);
		}
		case _NODE_LITERAL_UINT: {
			return _eval_literal_uint(genctx, child);
		}
		case _NODE_LITERAL_CHAR: {
			return _eval_literal_char(genctx, child);
		}
		case _NODE_LITERAL_STRING: {
			return _eval_literal_string(genctx, child);
		}
		default: {
			assert(0);
			return 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3c419
jmp 0x3c438
leaq 0x127a4(%rip), %rdi     # 0x4ebc4
leaq 0x127a4(%rip), %rsi     # 0x4ebcb
movl $0x480, %edx            # imm = 0x480
leaq 0x128ed(%rip), %rcx     # 0x4ed20
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x3c441
jmp 0x3c460
leaq 0xec3f(%rip), %rdi      # 0x4b087
leaq 0x1277c(%rip), %rsi     # 0x4ebcb
movl $0x481, %edx            # imm = 0x481
leaq 0x128c5(%rip), %rcx     # 0x4ed20
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0xec0, (%rax)          # imm = 0xEC0
jne 0x3c46e
jmp 0x3c48d
leaq 0x128e6(%rip), %rdi     # 0x4ed5b
leaq 0x1274f(%rip), %rsi     # 0x4ebcb
movl $0x482, %edx            # imm = 0x482
leaq 0x12898(%rip), %rcx     # 0x4ed20
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x3c499
jmp 0x3c4b8
leaq 0xe5d6(%rip), %rdi      # 0x4aa76
leaq 0x12724(%rip), %rsi     # 0x4ebcb
movl $0x483, %edx            # imm = 0x483
leaq 0x1286d(%rip), %rcx     # 0x4ed20
callq 0xa0b0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0x200, %eax            # imm = 0x200
je 0x3c4fd
jmp 0x3c4d9
movl -0x24(%rbp), %eax
subl $0x300, %eax            # imm = 0x300
je 0x3c50f
jmp 0x3c4e5
movl -0x24(%rbp), %eax
subl $0x301, %eax            # imm = 0x301
je 0x3c521
jmp 0x3c4f1
movl -0x24(%rbp), %eax
subl $0x302, %eax            # imm = 0x302
je 0x3c533
jmp 0x3c545
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c570
movl %eax, -0x4(%rbp)
jmp 0x3c564
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c760
movl %eax, -0x4(%rbp)
jmp 0x3c564
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c8b0
movl %eax, -0x4(%rbp)
jmp 0x3c564
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3c990
movl %eax, -0x4(%rbp)
jmp 0x3c564
leaq 0xaf19(%rip), %rdi      # 0x47465
leaq 0x12678(%rip), %rsi     # 0x4ebcb
movl $0x494, %edx            # imm = 0x494
leaq 0x127c1(%rip), %rcx     # 0x4ed20
callq 0xa0b0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/evaluator.c
// Function: eval_literal_uint
static int _eval_literal_uint(
	PPGeneratorContext *genctx,
	ParserASTNode *node
) {
	assert(genctx);
	assert(node);
	assert(node->type == _NODE_LITERAL_UINT);

	LexerToken *token = node->token;
	switch (token->type) {
		case _TOKEN_LITERAL_UINT_BIN: {
			return util_get_uint_bin_val(token->content, token->len);
		}
		case _TOKEN_LITERAL_UINT_OCT: {
			return util_get_uint_oct_val(token->content, token->len);
		}
		case _TOKEN_LITERAL_UINT_DEC: {
			return util_get_uint_dec_val(token->content, token->len);
		}
		case _TOKEN_LITERAL_UINT_HEX: {
			return util_get_uint_hex_val(token->content, token->len);
		}
		default: {
			assert(0);
			return 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x3c779
jmp 0x3c798
leaq 0x12444(%rip), %rdi     # 0x4ebc4
leaq 0x12444(%rip), %rsi     # 0x4ebcb
movl $0x433, %edx            # imm = 0x433
leaq 0x12641(%rip), %rcx     # 0x4edd4
callq 0xa0b0
cmpq $0x0, -0x18(%rbp)
je 0x3c7a1
jmp 0x3c7c0
leaq 0xe8df(%rip), %rdi      # 0x4b087
leaq 0x1241c(%rip), %rsi     # 0x4ebcb
movl $0x434, %edx            # imm = 0x434
leaq 0x12619(%rip), %rcx     # 0x4edd4
callq 0xa0b0
movq -0x18(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x3c7ce
jmp 0x3c7ed
leaq 0x1263d(%rip), %rdi     # 0x4ee12
leaq 0x123ef(%rip), %rsi     # 0x4ebcb
movl $0x435, %edx            # imm = 0x435
leaq 0x125ec(%rip), %rcx     # 0x4edd4
callq 0xa0b0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl $0xfffff000, %eax       # imm = 0xFFFFF000
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x3, %eax
ja 0x3c887
movq -0x28(%rbp), %rax
leaq 0x1239a(%rip), %rcx     # 0x4ebb4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13ad0
movl %eax, -0x4(%rbp)
jmp 0x3c8a6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13d80
movl %eax, -0x4(%rbp)
jmp 0x3c8a6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x14010
movl %eax, -0x4(%rbp)
jmp 0x3c8a6
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x14380
movl %eax, -0x4(%rbp)
jmp 0x3c8a6
leaq 0xabd7(%rip), %rdi      # 0x47465
leaq 0x12336(%rip), %rsi     # 0x4ebcb
movl $0x446, %edx            # imm = 0x446
leaq 0x12533(%rip), %rcx     # 0x4edd4
callq 0xa0b0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/evaluator.c
// Function: eval_literal_char
static int _eval_literal_char(
	PPGeneratorContext *genctx,
	ParserASTNode *node
) {
	assert(genctx);
	assert(node);
	assert(node->type == _NODE_LITERAL_CHAR);

	LexerToken *token = node->token;
	if (token->type == _TOKEN_LITERAL_CHAR) {
		return util_get_uint_char_val(token->content, token->len);
	} else {
		assert(0);
		return 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3c8c9
jmp 0x3c8e8
leaq 0x122f4(%rip), %rdi     # 0x4ebc4
leaq 0x122f4(%rip), %rsi     # 0x4ebcb
movl $0x450, %edx            # imm = 0x450
leaq 0x12550(%rip), %rcx     # 0x4ee33
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3c8f1
jmp 0x3c910
leaq 0xe78f(%rip), %rdi      # 0x4b087
leaq 0x122cc(%rip), %rsi     # 0x4ebcb
movl $0x451, %edx            # imm = 0x451
leaq 0x12528(%rip), %rcx     # 0x4ee33
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x301, (%rax)          # imm = 0x301
jne 0x3c91e
jmp 0x3c93d
leaq 0x1254c(%rip), %rdi     # 0x4ee71
leaq 0x1229f(%rip), %rsi     # 0x4ebcb
movl $0x452, %edx            # imm = 0x452
leaq 0x124fb(%rip), %rcx     # 0x4ee33
callq 0xa0b0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1004, (%rax)         # imm = 0x1004
jne 0x3c96f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x13710
addq $0x20, %rsp
popq %rbp
retq
leaq 0xaaef(%rip), %rdi      # 0x47465
leaq 0x1224e(%rip), %rsi     # 0x4ebcb
movl $0x458, %edx            # imm = 0x458
leaq 0x124aa(%rip), %rcx     # 0x4ee33
callq 0xa0b0
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cb45
jmp 0x3cb64
leaq 0x11015(%rip), %rdi     # 0x4db61
leaq 0x123a2(%rip), %rsi     # 0x4eef5
movl $0x409, %edx            # imm = 0x409
leaq 0x123b2(%rip), %rcx     # 0x4ef11
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x3cb70
jmp 0x3cb8f
leaq 0x123c5(%rip), %rdi     # 0x4ef3c
leaq 0x12377(%rip), %rsi     # 0x4eef5
movl $0x40a, %edx            # imm = 0x40A
leaq 0x12387(%rip), %rcx     # 0x4ef11
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
je 0x3cb9f
jmp 0x3cbbe
leaq 0x123a2(%rip), %rdi     # 0x4ef48
leaq 0x12348(%rip), %rsi     # 0x4eef5
movl $0x40b, %edx            # imm = 0x40B
leaq 0x12358(%rip), %rcx     # 0x4ef11
callq 0xa0b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x3cbd3
jmp 0x3cbf2
leaq 0x1237f(%rip), %rdi     # 0x4ef59
leaq 0x12314(%rip), %rsi     # 0x4eef5
movl $0x40c, %edx            # imm = 0x40C
leaq 0x12324(%rip), %rcx     # 0x4ef11
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rsi
callq 0x3cc10
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_module
static void _gen_module(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_MODULE);

	_gen_block(ctx, node->childs[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cc29
jmp 0x3cc48
leaq 0x10f31(%rip), %rdi     # 0x4db61
leaq 0x122be(%rip), %rsi     # 0x4eef5
movl $0x3fe, %edx            # imm = 0x3FE
leaq 0x12492(%rip), %rcx     # 0x4f0d5
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3cc51
jmp 0x3cc70
leaq 0xe42f(%rip), %rdi      # 0x4b087
leaq 0x12296(%rip), %rsi     # 0x4eef5
movl $0x3ff, %edx            # imm = 0x3FF
leaq 0x1246a(%rip), %rcx     # 0x4f0d5
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x3cc7e
jmp 0x3cc9d
leaq 0x12488(%rip), %rdi     # 0x4f10d
leaq 0x12269(%rip), %rsi     # 0x4eef5
movl $0x400, %edx            # imm = 0x400
leaq 0x1243d(%rip), %rcx     # 0x4f0d5
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rsi
callq 0x3d1b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cf25
jmp 0x3cf44
leaq 0x12ba8(%rip), %rdi     # 0x4fad4
leaq 0x11fc2(%rip), %rsi     # 0x4eef5
movl $0x10e, %edx            # imm = 0x10E
leaq 0x12b9b(%rip), %rcx     # 0x4fada
callq 0xa0b0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0xc870
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0x10320
movq -0x8(%rbp), %rdi
callq 0xa1b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3cf85
jmp 0x3cfa4
leaq 0x10bd5(%rip), %rdi     # 0x4db61
leaq 0x11f62(%rip), %rsi     # 0x4eef5
movl $0x457, %edx            # imm = 0x457
leaq 0x120a2(%rip), %rcx     # 0x4f041
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x3cfd0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xd360
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa1b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x3cffc
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xd360
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0xa1b0
movq -0x8(%rbp), %rdi
addq $0x30, %rdi
movl $0x1, %esi
callq 0xc870
movq -0x8(%rbp), %rdi
callq 0xa1b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3d03d
jmp 0x3d05c
leaq 0x10b1d(%rip), %rdi     # 0x4db61
leaq 0x11eaa(%rip), %rsi     # 0x4eef5
movl $0x46d, %edx            # imm = 0x46D
leaq 0x12019(%rip), %rcx     # 0x4f070
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3d065
jmp 0x3d084
leaq 0x12053(%rip), %rdi     # 0x4f0bf
leaq 0x11e82(%rip), %rsi     # 0x4eef5
movl $0x46e, %edx            # imm = 0x46E
leaq 0x11ff1(%rip), %rcx     # 0x4f070
callq 0xa0b0
movq -0x10(%rbp), %rdi
callq 0x102f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x3d0b6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
leaq 0x1200d(%rip), %rsi     # 0x4f0c1
callq *%rax
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3d150
movl -0x24(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jl 0x3d0e3
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, -0x34(%rbp)
jmp 0x3d116
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3d0fb
leaq 0xa792(%rip), %rax      # 0x47887
movq %rax, -0x40(%rbp)
jmp 0x3d107
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movsbl %al, %edi
callq 0x12b20
testb $0x1, %al
jne 0x3d140
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x48(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
leaq 0x11f83(%rip), %rsi     # 0x4f0c1
callq *%rax
jmp 0x3d142
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3d0bd
cmpq $0x0, -0x18(%rbp)
jne 0x3d162
callq 0x101f0
movq %rax, -0x30(%rbp)
jmp 0x3d16f
movq -0x18(%rbp), %rdi
callq 0x102f0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xd7f0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl $0x1, %ecx
callq 0xd460
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_block
static void _gen_block(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_BLOCK);

	for (int i = 0; i < node->nchilds; i++) {
		ParserASTNode *child = node->childs[i];
		_gen_block_item(ctx, child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3d1c9
jmp 0x3d1e8
leaq 0x10991(%rip), %rdi     # 0x4db61
leaq 0x11d1e(%rip), %rsi     # 0x4eef5
movl $0x3e0, %edx            # imm = 0x3E0
leaq 0x11f47(%rip), %rcx     # 0x4f12a
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3d1f1
jmp 0x3d210
leaq 0xde8f(%rip), %rdi      # 0x4b087
leaq 0x11cf6(%rip), %rsi     # 0x4eef5
movl $0x3e1, %edx            # imm = 0x3E1
leaq 0x11f1f(%rip), %rcx     # 0x4f12a
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x300, (%rax)          # imm = 0x300
jne 0x3d21e
jmp 0x3d23d
leaq 0x11f3c(%rip), %rdi     # 0x4f161
leaq 0x11cc9(%rip), %rsi     # 0x4eef5
movl $0x3e2, %edx            # imm = 0x3E2
leaq 0x11ef2(%rip), %rcx     # 0x4f12a
callq 0xa0b0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x3d27c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3d290
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d244
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_space
static void _gen_space(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_SPACE);

	_OUT_STR(ctx, node->token->content, node->token->len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3d559
jmp 0x3d578
leaq 0x10601(%rip), %rdi     # 0x4db61
leaq 0x1198e(%rip), %rsi     # 0x4eef5
movl $0x48, %edx
leaq 0x11c58(%rip), %rcx     # 0x4f1cb
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3d581
jmp 0x3d5a0
leaq 0xdaff(%rip), %rdi      # 0x4b087
leaq 0x11966(%rip), %rsi     # 0x4eef5
movl $0x49, %edx
leaq 0x11c30(%rip), %rcx     # 0x4f1cb
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x400, (%rax)          # imm = 0x400
jne 0x3d5ae
jmp 0x3d5cd
leaq 0x11c4d(%rip), %rdi     # 0x4f202
leaq 0x11939(%rip), %rsi     # 0x4eef5
movl $0x4a, %edx
leaq 0x11c03(%rip), %rcx     # 0x4f1cb
callq 0xa0b0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3d640
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3d612
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0xa0e0
jmp 0x3d633
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %esi
callq 0xfeb0
jmp 0x3d635
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3d5d4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/preprocessor/gen.c
// Function: gen_ifdef
static void _gen_ifdef(
	PPGeneratorContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == PP_NODE_DIRECTIVE_IFDEF);
	assert(node->nchilds >= 1);

	_gen_ifxdef(ctx, node, false);

	LexerToken *token_endif = PP_IFXXX_AST_NODE_GET_TOKEN_ENDIF(node);
	assert(token_endif);
	_OUT_FMT(ctx, "#line %d \"%s\"", token_endif->line + 1, token_endif->file);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x3ebcc
jmp 0x3ebeb
leaq 0xef8e(%rip), %rdi      # 0x4db61
leaq 0x1031b(%rip), %rsi     # 0x4eef5
movl $0x2f1, %edx            # imm = 0x2F1
leaq 0x10c01(%rip), %rcx     # 0x4f7e7
callq 0xa0b0
cmpq $0x0, -0x10(%rbp)
je 0x3ebf4
jmp 0x3ec13
leaq 0xc48c(%rip), %rdi      # 0x4b087
leaq 0x102f3(%rip), %rsi     # 0x4eef5
movl $0x2f2, %edx            # imm = 0x2F2
leaq 0x10bd9(%rip), %rcx     # 0x4f7e7
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x204, (%rax)          # imm = 0x204
jne 0x3ec21
jmp 0x3ec40
leaq 0x10bf6(%rip), %rdi     # 0x4f81e
leaq 0x102c6(%rip), %rsi     # 0x4eef5
movl $0x2f3, %edx            # imm = 0x2F3
leaq 0x10bac(%rip), %rcx     # 0x4f7e7
callq 0xa0b0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jl 0x3ec4c
jmp 0x3ec6b
leaq 0x10919(%rip), %rdi     # 0x4f56c
leaq 0x1029b(%rip), %rsi     # 0x4eef5
movl $0x2f4, %edx            # imm = 0x2F4
leaq 0x10b81(%rip), %rcx     # 0x4f7e7
callq 0xa0b0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x40810
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x3ec8f
jmp 0x3ecae
leaq 0x1092b(%rip), %rdi     # 0x4f5c1
leaq 0x10258(%rip), %rsi     # 0x4eef5
movl $0x2f9, %edx            # imm = 0x2F9
leaq 0x10b3e(%rip), %rcx     # 0x4f7e7
callq 0xa0b0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3ece3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %edx
addl $0x1, %edx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
leaq 0x105c9(%rip), %rsi     # 0x4f2a3
movb $0x0, %al
callq 0xa100
jmp 0x3ed23
leaq -0x420(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %r8
movl $0x400, %esi            # imm = 0x400
leaq 0x1059b(%rip), %rdx     # 0x4f2a3
movb $0x0, %al
callq 0xa0a0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x420(%rbp), %rsi
callq 0xfd80
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)