LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x1faed
testq %rsi, %rsi
je 0x1fb0c
addq $0x68, %rdi
callq 0xc417
testq %rax, %rax
je 0x1fae9
cmpb $0x5, (%rax)
jne 0x1fb2b
movq 0x8(%rax), %rax
jmp 0x1faeb
xorl %eax, %eax
popq %rbp
retq
leaq 0xf2e0(%rip), %rdi      # 0x2edd4
leaq 0x139b5(%rip), %rsi     # 0x334b0
leaq 0x13b50(%rip), %rcx     # 0x33652
movl $0xa46, %edx            # imm = 0xA46
callq 0xa0b0
leaq 0xd2ae(%rip), %rdi      # 0x2cdc1
leaq 0x13996(%rip), %rsi     # 0x334b0
leaq 0x13b31(%rip), %rcx     # 0x33652
movl $0xa47, %edx            # imm = 0xA47
callq 0xa0b0
leaq 0x13b6f(%rip), %rdi     # 0x336a1
leaq 0x13977(%rip), %rsi     # 0x334b0
leaq 0x13b12(%rip), %rcx     # 0x33652
movl $0xa4d, %edx            # imm = 0xA4D
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fb9a
testq %rsi, %rsi
je 0x1fbb9
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movl 0x4(%rsi), %edx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xdfa2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fac2
movq %rax, %rbx
movq %r14, %rdi
callq 0xe2b9
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xf233(%rip), %rdi      # 0x2edd4
leaq 0x13908(%rip), %rsi     # 0x334b0
leaq 0x13b1d(%rip), %rcx     # 0x336cc
movl $0xa58, %edx            # imm = 0xA58
callq 0xa0b0
leaq 0xd201(%rip), %rdi      # 0x2cdc1
leaq 0x138e9(%rip), %rsi     # 0x334b0
leaq 0x13afe(%rip), %rcx     # 0x336cc
movl $0xa59, %edx            # imm = 0xA59
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fbfb
testq %rsi, %rsi
je 0x1fc1a
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x1fc39
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1b658
leaq 0xf1d2(%rip), %rdi      # 0x2edd4
leaq 0x138a7(%rip), %rsi     # 0x334b0
leaq 0x13b07(%rip), %rcx     # 0x33717
movl $0xa67, %edx            # imm = 0xA67
callq 0xa0b0
leaq 0x1109a(%rip), %rdi     # 0x30cbb
leaq 0x13888(%rip), %rsi     # 0x334b0
leaq 0x13ae8(%rip), %rcx     # 0x33717
movl $0xa68, %edx            # imm = 0xA68
callq 0xa0b0
leaq 0x13b1c(%rip), %rdi     # 0x3375c
leaq 0x13869(%rip), %rsi     # 0x334b0
leaq 0x13ac9(%rip), %rcx     # 0x33717
movl $0xa69, %edx            # imm = 0xA69
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fc7b
testq %rsi, %rsi
je 0x1fc9a
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x1fcb9
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1b717
leaq 0xf152(%rip), %rdi      # 0x2edd4
leaq 0x13827(%rip), %rsi     # 0x334b0
leaq 0x13af0(%rip), %rcx     # 0x33780
movl $0xa72, %edx            # imm = 0xA72
callq 0xa0b0
leaq 0x1101a(%rip), %rdi     # 0x30cbb
leaq 0x13808(%rip), %rsi     # 0x334b0
leaq 0x13ad1(%rip), %rcx     # 0x33780
movl $0xa73, %edx            # imm = 0xA73
callq 0xa0b0
leaq 0x13a9c(%rip), %rdi     # 0x3375c
leaq 0x137e9(%rip), %rsi     # 0x334b0
leaq 0x13ab2(%rip), %rcx     # 0x33780
movl $0xa74, %edx            # imm = 0xA74
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fcfb
testq %rsi, %rsi
je 0x1fd1a
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x1fd39
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1b7d6
leaq 0xf0d2(%rip), %rdi      # 0x2edd4
leaq 0x137a7(%rip), %rsi     # 0x334b0
leaq 0x13ab5(%rip), %rcx     # 0x337c5
movl $0xa7d, %edx            # imm = 0xA7D
callq 0xa0b0
leaq 0x10f9a(%rip), %rdi     # 0x30cbb
leaq 0x13788(%rip), %rsi     # 0x334b0
leaq 0x13a96(%rip), %rcx     # 0x337c5
movl $0xa7e, %edx            # imm = 0xA7E
callq 0xa0b0
leaq 0x13ac6(%rip), %rdi     # 0x33806
leaq 0x13769(%rip), %rsi     # 0x334b0
leaq 0x13a77(%rip), %rcx     # 0x337c5
movl $0xa7f, %edx            # imm = 0xA7F
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fd7b
testq %rsi, %rsi
je 0x1fd9a
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x1fdb9
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1b856
leaq 0xf052(%rip), %rdi      # 0x2edd4
leaq 0x13727(%rip), %rsi     # 0x334b0
leaq 0x13a9a(%rip), %rcx     # 0x3382a
movl $0xa88, %edx            # imm = 0xA88
callq 0xa0b0
leaq 0x10f1a(%rip), %rdi     # 0x30cbb
leaq 0x13708(%rip), %rsi     # 0x334b0
leaq 0x13a7b(%rip), %rcx     # 0x3382a
movl $0xa89, %edx            # imm = 0xA89
callq 0xa0b0
leaq 0x13a46(%rip), %rdi     # 0x33806
leaq 0x136e9(%rip), %rsi     # 0x334b0
leaq 0x13a5c(%rip), %rcx     # 0x3382a
movl $0xa8a, %edx            # imm = 0xA8A
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fdfb
testq %rsi, %rsi
je 0x1fe1a
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x1fe39
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1b8d6
leaq 0xefd2(%rip), %rdi      # 0x2edd4
leaq 0x136a7(%rip), %rsi     # 0x334b0
leaq 0x13a5d(%rip), %rcx     # 0x3386d
movl $0xa93, %edx            # imm = 0xA93
callq 0xa0b0
leaq 0x10e9a(%rip), %rdi     # 0x30cbb
leaq 0x13688(%rip), %rsi     # 0x334b0
leaq 0x13a3e(%rip), %rcx     # 0x3386d
movl $0xa94, %edx            # imm = 0xA94
callq 0xa0b0
leaq 0x13a6c(%rip), %rdi     # 0x338ac
leaq 0x13669(%rip), %rsi     # 0x334b0
leaq 0x13a1f(%rip), %rcx     # 0x3386d
movl $0xa95, %edx            # imm = 0xA95
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fe7b
testq %rsi, %rsi
je 0x1fe9a
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x1feb9
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1b9d5
leaq 0xef52(%rip), %rdi      # 0x2edd4
leaq 0x13627(%rip), %rsi     # 0x334b0
leaq 0x13a40(%rip), %rcx     # 0x338d0
movl $0xa9e, %edx            # imm = 0xA9E
callq 0xa0b0
leaq 0x10e1a(%rip), %rdi     # 0x30cbb
leaq 0x13608(%rip), %rsi     # 0x334b0
leaq 0x13a21(%rip), %rcx     # 0x338d0
movl $0xa9f, %edx            # imm = 0xA9F
callq 0xa0b0
leaq 0x1389c(%rip), %rdi     # 0x3375c
leaq 0x135e9(%rip), %rsi     # 0x334b0
leaq 0x13a02(%rip), %rcx     # 0x338d0
movl $0xaa0, %edx            # imm = 0xAA0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x1fefb
testq %rsi, %rsi
je 0x1ff1a
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x1ff39
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x1ba5e
leaq 0xeed2(%rip), %rdi      # 0x2edd4
leaq 0x135a7(%rip), %rsi     # 0x334b0
leaq 0x13a05(%rip), %rcx     # 0x33915
movl $0xaa9, %edx            # imm = 0xAA9
callq 0xa0b0
leaq 0x10d9a(%rip), %rdi     # 0x30cbb
leaq 0x13588(%rip), %rsi     # 0x334b0
leaq 0x139e6(%rip), %rcx     # 0x33915
movl $0xaaa, %edx            # imm = 0xAAA
callq 0xa0b0
leaq 0x138c6(%rip), %rdi     # 0x33806
leaq 0x13569(%rip), %rsi     # 0x334b0
leaq 0x139c7(%rip), %rcx     # 0x33915
movl $0xaab, %edx            # imm = 0xAAB
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/assembler/parser.c
// Function: new_node
static ParserASTNode * _new_node(
	ParserContext *ctx,
	int32_t type,
	char *type_name,
	LexerToken *token
) {
	assert(ctx);
	assert(type_name);

	if (type == ASM_NODE_INSTRUCTION) {
		AsmParserInsASTNodeData data;
		memset(&data, 0, sizeof(data));

		return parser_new_node(
			ctx, type, type_name, token, sizeof(AsmParserInsASTNodeData), &data
		);
	} else if (type == ASM_NODE_EXPR) {
		AsmParserExprASTNodeData data;
		data.result.type = ASM_EXPR_EVAL_RESULT_TYPE_NULL;

		return parser_new_node(
			ctx, type, type_name, token, sizeof(AsmParserExprASTNodeData), &data
		);
	} else if (type == ASM_NODE_REG) {
		AsmParserRegASTNodeData data;
		memset(&data, 0, sizeof(data));

		return parser_new_node(
			ctx, type, type_name, token, sizeof(AsmParserRegASTNodeData), &data
		);
	} else if (type == ASM_NODE_MEM) {
		AsmParserMemASTNodeData data;
		memset(&data, 0, sizeof(data));

		return parser_new_node(
			ctx, type, type_name, token, sizeof(AsmParserMemASTNodeData), &data
		);
	} else if (type == ASM_NODE_DIRECT_ADDRESS) {
		AsmParserDirectAddressASTNodeData data;
		memset(&data, 0, sizeof(data));

		return parser_new_node(
			ctx, type, type_name, token, sizeof(AsmParserDirectAddressASTNodeData), &data
		);
	} else {
		return parser_new_node(
			ctx, type, type_name, token, 0, NULL
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
testq %rdx, %rdx
je 0x20030
leal -0x400(%rsi), %eax
roll $0x18, %eax
cmpl $0xa, %eax
ja 0x1ffa7
leaq 0x1348a(%rip), %r8      # 0x33408
movslq (%r8,%rax,4), %rax
addq %r8, %rax
jmpq *%rax
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r9
movaps %xmm0, 0x20(%r9)
movaps %xmm0, 0x10(%r9)
movaps %xmm0, (%r9)
pushq $0x30
popq %r8
movl $0x400, %esi            # imm = 0x400
jmp 0x20025
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x50, %rsp
popq %rbp
jmp 0xd0f4
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r9
movaps %xmm0, 0x40(%r9)
movaps %xmm0, 0x30(%r9)
movaps %xmm0, 0x20(%r9)
movaps %xmm0, 0x10(%r9)
movaps %xmm0, (%r9)
pushq $0x50
popq %r8
movl $0x600, %esi            # imm = 0x600
jmp 0x20025
leaq -0x50(%rbp), %r9
andq $0x0, (%r9)
pushq $0x8
popq %r8
movl $0x500, %esi            # imm = 0x500
jmp 0x20025
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r9
movaps %xmm0, 0x10(%r9)
movaps %xmm0, (%r9)
andq $0x0, 0x20(%r9)
pushq $0x28
popq %r8
movl $0x700, %esi            # imm = 0x700
jmp 0x20025
leaq -0x50(%rbp), %r9
movb $0x0, (%r9)
pushq $0x18
popq %r8
movl $0xe00, %esi            # imm = 0xE00
callq 0xd0f4
addq $0x50, %rsp
popq %rbp
retq
leaq 0x139b4(%rip), %rdi     # 0x339eb
leaq 0x13472(%rip), %rsi     # 0x334b0
leaq 0x1395d(%rip), %rcx     # 0x339a2
pushq $0x1b
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x21088
callq 0xb3b3
movq %rbx, %rdi
callq 0x210a7
movq %rax, %r14
leaq 0x12e5e(%rip), %r12     # 0x33de4
leaq 0x12e45(%rip), %r13     # 0x33dd2
testq %r14, %r14
je 0x2106e
movq (%rbx), %rdi
callq 0xb3b3
movq (%rbx), %rdi
callq 0xb167
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x21066
movl (%rax), %eax
cmpl $0x4015, %eax           # imm = 0x4015
je 0x2100c
cmpl $0x4014, %eax           # imm = 0x4014
je 0x20fef
cmpl $0x4013, %eax           # imm = 0x4013
jne 0x21066
movq %rbx, %rdi
callq 0x210a7
testq %rax, %rax
je 0x21066
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb0, %esi            # imm = 0xEB0
movq %r13, %rdx
jmp 0x2102b
movq %rbx, %rdi
callq 0x210a7
testq %rax, %rax
je 0x21066
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb1, %esi            # imm = 0xEB1
movq %r12, %rdx
jmp 0x2102b
movq %rbx, %rdi
callq 0x210a7
testq %rax, %rax
je 0x21066
movq %rax, %r15
movq %rbx, %rdi
movl $0xeb2, %esi            # imm = 0xEB2
leaq 0x12dcb(%rip), %rdx     # 0x33df6
xorl %ecx, %ecx
callq 0x1ff58
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xd3c4
movq %rax, 0x30(%r15)
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0xd3c4
movq %rax, %r14
movq (%rbx), %rdi
callq 0xb47c
jmp 0x20f8d
movq (%rbx), %rdi
callq 0xb41b
movq (%rbx), %rdi
callq 0xb47c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x128f5(%rip), %rdi     # 0x33984
leaq 0x1241a(%rip), %rsi     # 0x334b0
leaq 0x12d06(%rip), %rcx     # 0x33da3
movl $0x12e, %edx            # imm = 0x12E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x219ff
callq 0x21af1
movq %rax, %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x219fd
cmpl $0x1, 0xc(%rcx)
jne 0x219fd
movl 0x8(%rcx), %eax
popq %rbp
retq
leaq 0xaab4(%rip), %rdi      # 0x2c4ba
leaq 0x11aa3(%rip), %rsi     # 0x334b0
leaq 0x126b7(%rip), %rcx     # 0x340cb
movl $0x217, %edx            # imm = 0x217
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x232c3
testq %rsi, %rsi
je 0x232e2
testq %rdx, %rdx
je 0x23301
movq %rdi, %rbx
leaq 0x21e2d(%rip), %rax     # 0x45010
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movq %rax, %rcx
callq 0xac5c
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0xb677
pushq $0x20
popq %r15
pushq $0xa
popq %r13
movq -0x30(%rbp), %rdi
callq 0xb167
testq %rax, %rax
je 0x2328d
movq %rax, %r12
movl (%rax), %eax
leal -0x1000(%rax), %ecx
cmpl $0x3, %ecx
jae 0x23239
movq 0x8(%r12), %rsi
movl 0x4(%r12), %edx
movq %rbx, %rdi
callq 0xe00f
jmp 0x23207
cmpl $0xe000, %eax           # imm = 0xE000
je 0x23273
cmpl $0xe001, %eax           # imm = 0xE001
jne 0x232a4
xorl %r14d, %r14d
movslq 0x4(%r12), %rax
cmpq %rax, %r14
jge 0x23207
movq 0x8(%r12), %rax
cmpb $0xa, (%rax,%r14)
movl %r13d, %esi
je 0x23266
movl %r15d, %esi
movq %rbx, %rdi
callq 0xdf81
incq %r14
jmp 0x2324a
xorl %r14d, %r14d
cmpl 0x4(%r12), %r14d
jge 0x23207
movq %rbx, %rdi
movl %r15d, %esi
callq 0xdf81
incl %r14d
jmp 0x23276
movq -0x30(%rbp), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaf21
leaq 0xa0c5(%rip), %rdi      # 0x2d370
leaq 0x11328(%rip), %rsi     # 0x345da
leaq 0x11341(%rip), %rcx     # 0x345fa
movl $0x111, %edx            # imm = 0x111
callq 0xa0b0
leaq 0x8d9f(%rip), %rdi      # 0x2c069
leaq 0x11309(%rip), %rsi     # 0x345da
leaq 0x11322(%rip), %rcx     # 0x345fa
movl $0xf0, %edx
callq 0xa0b0
leaq 0x9720(%rip), %rdi      # 0x2ca09
leaq 0x112ea(%rip), %rsi     # 0x345da
leaq 0x11303(%rip), %rcx     # 0x345fa
movl $0xf1, %edx
callq 0xa0b0
leaq 0xabd5(%rip), %rdi      # 0x2dedd
leaq 0x112cb(%rip), %rsi     # 0x345da
leaq 0x112e4(%rip), %rcx     # 0x345fa
movl $0xf2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x238b3
testq %rsi, %rsi
je 0x238d2
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rax
movq (%rax), %rdi
leaq 0x2187c(%rip), %rcx     # 0x45070
callq 0xac5c
movq %rax, %r14
movq %rax, %rdi
callq 0xb4d1
movq %r14, %rdi
callq 0xcff7
movq %rax, %r15
movq (%rbx), %rax
movl 0x30(%rax), %eax
movl %eax, 0x30(%r15)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x238f1
callq 0xb3b3
movq %r15, %rdi
callq 0x258df
testq %rax, %rax
je 0x2387c
movq %rax, %r12
leaq 0xbac1(%rip), %rdx      # 0x2f302
movq %r15, %rdi
movl $0xe00, %esi            # imm = 0xE00
xorl %ecx, %ecx
callq 0x259fd
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 0xd3c4
movq %rax, %r12
movq (%r15), %rdi
callq 0xb47c
jmp 0x23887
movq (%r15), %rdi
callq 0xb41b
xorl %r12d, %r12d
movq %r12, 0x8(%r15)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x23910
movl %eax, %ebx
movq %r15, %rdi
callq 0xd005
movq %r14, %rdi
callq 0xaf21
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10e6e(%rip), %rdi     # 0x34728
leaq 0x10e6e(%rip), %rsi     # 0x3472f
leaq 0x10e89(%rip), %rcx     # 0x34751
movl $0x585, %edx            # imm = 0x585
callq 0xa0b0
leaq 0xc217(%rip), %rdi      # 0x2faf0
leaq 0x10e4f(%rip), %rsi     # 0x3472f
leaq 0x10e6a(%rip), %rcx     # 0x34751
movl $0x586, %edx            # imm = 0x586
callq 0xa0b0
leaq 0x1008c(%rip), %rdi     # 0x33984
leaq 0x10e30(%rip), %rsi     # 0x3472f
leaq 0x1017e(%rip), %rcx     # 0x33a84
movl $0x2a0, %edx            # imm = 0x2A0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x26b41
movq %rdx, %r15
testq %rdx, %rdx
je 0x26b60
movq %rsi, %rbx
movl (%r15), %eax
cmpl $0x302, %eax            # imm = 0x302
je 0x26af3
cmpl $0x200, %eax            # imm = 0x200
jne 0x26b7f
movq %rdi, %r14
leaq -0x48(%rbp), %r12
movq %r12, %rdi
callq 0xde1c
leaq -0x38(%rbp), %r13
movq %r13, %rdi
callq 0xde1c
movq 0x10(%r15), %rax
movq 0x8(%rax), %rdx
movl 0x4(%rax), %ecx
movq %r12, %rdi
movq %r14, %rsi
callq 0x29160
leaq -0x17d13(%rip), %rdx    # 0xed9b
movq %r13, %rdi
movq %r12, %rsi
callq 0xefe8
movq 0x8(%r13), %rdi
testq %rdi, %rdi
leaq 0x6ccb(%rip), %r14      # 0x2d792
cmoveq %r14, %rdi
movl 0x4(%r13), %esi
callq 0x1008b
testb %al, %al
je 0x26b14
movq -0x30(%rbp), %rax
testq %rax, %rax
cmovneq %rax, %r14
movl -0x34(%rbp), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10533
jmp 0x26b20
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 0x10533
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0xe12e
leaq -0x48(%rbp), %rdi
callq 0xe2b9
leaq -0x38(%rbp), %rdi
callq 0xe2b9
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6ef8(%rip), %rdi      # 0x2da40
leaq 0xdbe0(%rip), %rsi      # 0x3472f
leaq 0xdcd9(%rip), %rcx      # 0x3482f
movl $0x49f, %edx            # imm = 0x49F
callq 0xa0b0
leaq 0xa154(%rip), %rdi      # 0x30cbb
leaq 0xdbc1(%rip), %rsi      # 0x3472f
leaq 0xdcba(%rip), %rcx      # 0x3482f
movl $0x4a0, %edx            # imm = 0x4A0
callq 0xa0b0
leaq 0x67ea(%rip), %rdi      # 0x2d370
leaq 0xdba2(%rip), %rsi      # 0x3472f
leaq 0xdc9b(%rip), %rcx      # 0x3482f
movl $0x4c5, %edx            # imm = 0x4C5
callq 0xa0b0
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x26bcf
movq (%rdi), %rax
testq %rax, %rax
je 0x26bee
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x26c0d
cmpl $0x100, (%rax)          # imm = 0x100
jne 0x26c2c
movq 0x48(%rax), %rax
movq (%rax), %rsi
popq %rbp
jmp 0x27023
leaq 0x81fe(%rip), %rdi      # 0x2edd4
leaq 0xdddf(%rip), %rsi      # 0x349bc
leaq 0xddf4(%rip), %rcx      # 0x349d8
movl $0x409, %edx            # imm = 0x409
callq 0xa0b0
leaq 0xde0e(%rip), %rdi      # 0x34a03
leaq 0xddc0(%rip), %rsi      # 0x349bc
leaq 0xddd5(%rip), %rcx      # 0x349d8
movl $0x40a, %edx            # imm = 0x40A
callq 0xa0b0
leaq 0xddfb(%rip), %rdi      # 0x34a0f
leaq 0xdda1(%rip), %rsi      # 0x349bc
leaq 0xddb6(%rip), %rcx      # 0x349d8
movl $0x40b, %edx            # imm = 0x40B
callq 0xa0b0
leaq 0xdded(%rip), %rdi      # 0x34a20
leaq 0xdd82(%rip), %rsi      # 0x349bc
leaq 0xdd97(%rip), %rcx      # 0x349d8
movl $0x40c, %edx            # imm = 0x40C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x26e73
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xbad0
leaq 0x28(%rbx), %rdi
callq 0xe2b9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa190
leaq 0xe2c9(%rip), %rdi      # 0x35143
leaq 0xdb3b(%rip), %rsi      # 0x349bc
leaq 0xe2c1(%rip), %rcx      # 0x35149
movl $0x10e, %edx            # imm = 0x10E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x26ef2
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x26ebc
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0xc214
movq 0x18(%rbx), %rdi
callq 0xa190
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x26ed8
pushq $0x1
popq %rdx
movl %edx, %esi
callq 0xc214
movq 0x20(%rbx), %rdi
callq 0xa190
leaq 0x30(%rbx), %rdi
pushq $0x1
popq %rsi
callq 0xbad0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa190
leaq 0x7edb(%rip), %rdi      # 0x2edd4
leaq 0xdabc(%rip), %rsi      # 0x349bc
leaq 0xdc01(%rip), %rcx      # 0x34b08
movl $0x457, %edx            # imm = 0x457
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x26fe5
testq %rsi, %rsi
je 0x27004
movq %rdi, %rbx
movq %rdx, -0x30(%rbp)
movq %rsi, %rdi
callq 0xe294
movq %rax, %r14
cmpl $0x0, 0x4(%rax)
jne 0x26f56
movq (%rbx), %rdi
leaq 0xdc35(%rip), %rsi      # 0x34b88
callq *0x48(%rdi)
xorl %r13d, %r13d
leaq 0x6832(%rip), %r15      # 0x2d792
leaq 0xdc21(%rip), %r12      # 0x34b88
movslq 0x4(%r14), %rax
cmpq %rax, %r13
jge 0x26f97
movq 0x8(%r14), %rax
testq %rax, %rax
cmoveq %r15, %rax
movsbl (%rax,%r13), %edi
callq 0xff0c
testb %al, %al
jne 0x26f92
movq (%rbx), %rdi
movq %r12, %rsi
callq *0x48(%rdi)
incq %r13
jmp 0x26f67
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x26fa7
callq 0xe294
jmp 0x26fac
callq 0xe1d5
movq %rax, %r15
movq 0x18(%rbx), %rdi
pushq $0x1
popq %r12
movq %r14, %rsi
movl %r12d, %edx
movl %r12d, %ecx
callq 0xc477
movq 0x18(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
movl %r12d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc29d
leaq 0x7de8(%rip), %rdi      # 0x2edd4
leaq 0xd9c9(%rip), %rsi      # 0x349bc
leaq 0xdb3d(%rip), %rcx      # 0x34b37
movl $0x46d, %edx            # imm = 0x46D
callq 0xa0b0
leaq 0xdb7b(%rip), %rdi      # 0x34b86
leaq 0xd9aa(%rip), %rsi      # 0x349bc
leaq 0xdb1e(%rip), %rcx      # 0x34b37
movl $0x46e, %edx            # imm = 0x46E
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, -0x30(%rbp)
testq %rdx, %rdx
je 0x2801b
movq %rdx, %r15
movq %rdi, %r14
movq 0x30(%rdi), %rbx
xorl %r13d, %r13d
leaq -0x430(%rbp), %r12
testb $0x1, %r13b
jne 0x27fda
testq %rbx, %rbx
je 0x27fda
movq 0x8(%rbx), %rsi
movq %r12, %rdi
callq 0xe0de
movq %r12, %rdi
movq %r15, %rsi
callq 0xe12e
movq -0x428(%rbp), %rsi
testq %rsi, %rsi
leaq 0x57d5(%rip), %rax      # 0x2d792
cmoveq %rax, %rsi
movq %r14, %rdi
callq 0x2803a
movl %eax, %r13d
movq %r12, %rdi
callq 0xe2b9
movq 0x18(%rbx), %rbx
jmp 0x27f8a
testb $0x1, %r13b
jne 0x28009
movups 0xcd06(%rip), %xmm0     # 0x34ced
leaq -0x430(%rbp), %rdx
movaps %xmm0, (%rdx)
movabsq $0x2e656c69662065, %rax # imm = 0x2E656C69662065
movq %rax, 0xd(%rdx)
movq (%r14), %rdi
movq -0x30(%rbp), %rsi
callq *0x58(%rdi)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xccc2(%rip), %rdi      # 0x34ce4
leaq 0xc993(%rip), %rsi      # 0x349bc
leaq 0xcc55(%rip), %rcx      # 0x34c85
movl $0xb2, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x28319
movq %rsi, %rbx
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x28338
movq %rdi, %r14
cmpl $0x0, 0x44(%rbx)
jle 0x28300
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x282d0
movl 0x20(%rax), %edx
movq 0x18(%rax), %rcx
leaq 0xc991(%rip), %rsi      # 0x34c58
xorl %eax, %eax
callq 0xa0f0
jmp 0x28300
movl 0x20(%rax), %ecx
movq 0x18(%rax), %r8
leaq 0xc97a(%rip), %rdx      # 0x34c58
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 0xde99
movq %r14, %rdi
movq %rbx, %rsi
callq 0x27023
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x899b(%rip), %rdi      # 0x30cbb
leaq 0xc695(%rip), %rsi      # 0x349bc
leaq 0xcae7(%rip), %rcx      # 0x34e15
movl $0x3ef, %edx            # imm = 0x3EF
callq 0xa0b0
leaq 0xc894(%rip), %rdi      # 0x34bd3
leaq 0xc676(%rip), %rsi      # 0x349bc
leaq 0xcac8(%rip), %rcx      # 0x34e15
movl $0x3f0, %edx            # imm = 0x3F0
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x2896b
testq %rsi, %rsi
je 0x2898a
testl %edx, %edx
js 0x289a9
leaq 0x1c90b(%rip), %rcx     # 0x45270
popq %rbp
jmp 0xac5c
leaq 0x4097(%rip), %rdi      # 0x2ca09
leaq 0xc804(%rip), %rsi      # 0x3517d
leaq 0xc81b(%rip), %rcx      # 0x3519b
movl $0xdc, %edx
callq 0xa0b0
leaq 0x3ba5(%rip), %rdi      # 0x2c536
leaq 0xc7e5(%rip), %rsi      # 0x3517d
leaq 0xc7fc(%rip), %rcx      # 0x3519b
movl $0xdd, %edx
callq 0xa0b0
leaq 0x3b8d(%rip), %rdi      # 0x2c53d
leaq 0xc7c6(%rip), %rsi      # 0x3517d
leaq 0xc7dd(%rip), %rcx      # 0x3519b
movl $0xde, %edx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x29176
testq %rsi, %rsi
je 0x29195
testq %rdx, %rdx
je 0x291b4
popq %rbp
jmp 0x291d3
leaq 0x48c3(%rip), %rdi      # 0x2da40
leaq 0xc151(%rip), %rsi      # 0x352d5
leaq 0xc167(%rip), %rcx      # 0x352f2
movl $0x296, %edx            # imm = 0x296
callq 0xa0b0
leaq 0xb58c(%rip), %rdi      # 0x34728
leaq 0xc132(%rip), %rsi      # 0x352d5
leaq 0xc148(%rip), %rcx      # 0x352f2
movl $0x297, %edx            # imm = 0x297
callq 0xa0b0
leaq 0x3c06(%rip), %rdi      # 0x2cdc1
leaq 0xc113(%rip), %rsi      # 0x352d5
leaq 0xc129(%rip), %rcx      # 0x352f2
movl $0x298, %edx            # imm = 0x298
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x2926f
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 0xdfa2
movq 0x18(%r14), %rdi
movq %r13, %rsi
callq 0xc52c
testb %al, %al
je 0x29249
movq 0x18(%r14), %rdi
leaq -0x38(%rbp), %rsi
callq 0xc417
movq 0x8(%rax), %rcx
testq %rcx, %rcx
leaq 0x455d(%rip), %rdx      # 0x2d792
cmovneq %rcx, %rdx
movl 0x4(%rax), %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x293d3
jmp 0x29257
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0xe00f
leaq -0x38(%rbp), %rdi
callq 0xe2b9
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b4b(%rip), %rdi      # 0x2cdc1
leaq 0xc058(%rip), %rsi      # 0x352d5
leaq 0xc118(%rip), %rcx      # 0x3539c
movl $0x17c, %edx            # imm = 0x17C
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/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 0x29357
testq %rsi, %rsi
je 0x29376
cmpl $0x302, (%rsi)          # imm = 0x302
jne 0x29395
movq 0x10(%rsi), %rax
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x293b4
movq %rdi, %rbx
movl 0x4(%rax), %r15d
leaq -0x30(%rbp), %r12
movq %r12, %rdi
callq 0xde1c
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x293d3
xorl %r14d, %r14d
leaq 0x4498(%rip), %r15      # 0x2d792
movslq -0x2c(%rbp), %rax
cmpq %rax, %r14
jge 0x29341
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x29323
movq -0x28(%rbp), %rax
testq %rax, %rax
cmoveq %r15, %rax
movsbl (%rax,%r14), %edi
callq 0xa0d0
jmp 0x2933c
movq 0x10(%rbx), %rdi
movq -0x28(%rbp), %rax
testq %rax, %rax
cmoveq %r15, %rax
movsbl (%rax,%r14), %esi
callq 0xdf81
incq %r14
jmp 0x292fa
leaq -0x30(%rbp), %rdi
callq 0xe2b9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb3ca(%rip), %rdi      # 0x34728
leaq 0xbf70(%rip), %rsi      # 0x352d5
leaq 0xbfd9(%rip), %rcx      # 0x35345
movl $0x2a1, %edx            # imm = 0x2A1
callq 0xa0b0
leaq 0x793e(%rip), %rdi      # 0x30cbb
leaq 0xbf51(%rip), %rsi      # 0x352d5
leaq 0xbfba(%rip), %rcx      # 0x35345
movl $0x2a2, %edx            # imm = 0x2A2
callq 0xa0b0
leaq 0xbfe5(%rip), %rdi      # 0x35381
leaq 0xbf32(%rip), %rsi      # 0x352d5
leaq 0xbf9b(%rip), %rcx      # 0x35345
movl $0x2a3, %edx            # imm = 0x2A3
callq 0xa0b0
leaq 0x4b22(%rip), %rdi      # 0x2dedd
leaq 0xbf13(%rip), %rsi      # 0x352d5
leaq 0xc25d(%rip), %rcx      # 0x35626
movl $0x285, %edx            # imm = 0x285
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/preprocessor/line_concat.c
// Function: process
void _process(
	ResizableString *dst,
	const char *file,
	const char *src,
	int len
) {
	assert(dst);
	assert(file);
	assert(src);
	assert(len >= 0);

	for (int i = 0; i < len; i++) {
		char chr = src[i];
		if (chr == '\\') {
			if (i + 1 < len
					&& src[i + 1] == '\n') {
				i += 2;
				int n = 1;
				for (; i < len; i++) {
					chr = src[i];
					if (chr == '\\') {
						if (i + 1 < len
								&& src[i + 1] == '\n') {
							i++;
							n++;
						} else {
							rstr_append_with_char(dst, chr);
						}
					} else {
						rstr_append_with_char(dst, chr);
						if (chr == '\n') {
							break;
						}
					}
				}
				for (int j = 0; j < n; j++) {
					rstr_append_with_char(dst, '\n');
				}
			} else {
				rstr_append_with_char(dst, chr);
			}
		} else {
			rstr_append_with_char(dst, chr);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
testq %rdi, %rdi
je 0x2a1e9
testq %rsi, %rsi
je 0x2a202
cmpq $0x0, -0x30(%rbp)
je 0x2a21b
movl %ecx, %ebx
testl %ecx, %ecx
js 0x2a234
movq %rdi, %r15
xorl %r12d, %r12d
cmpl %ebx, %r12d
jge 0x2a1da
movslq %r12d, %rcx
movq -0x30(%rbp), %rax
movb (%rax,%rcx), %al
cmpb $0x5c, %al
jne 0x2a1a8
incq %rcx
movb $0x5c, %al
cmpl %ebx, %ecx
jge 0x2a1a8
movq -0x30(%rbp), %rdx
cmpb $0xa, (%rdx,%rcx)
jne 0x2a1a8
addl $0x2, %r12d
pushq $0x1
popq %r13
cmpl %ebx, %r12d
jge 0x2a1bb
movslq %r12d, %rax
movq -0x30(%rbp), %rcx
movb (%rcx,%rax), %r14b
cmpb $0x5c, %r14b
jne 0x2a184
incq %rax
cmpl %ebx, %eax
jge 0x2a198
movq -0x30(%rbp), %rcx
cmpb $0xa, (%rcx,%rax)
jne 0x2a198
incl %r13d
movl %eax, %r12d
jmp 0x2a1a3
movsbl %r14b, %esi
movq %r15, %rdi
callq 0xdf81
cmpb $0xa, %r14b
jne 0x2a1a3
jmp 0x2a1bb
movq %r15, %rdi
pushq $0x5c
popq %rsi
callq 0xdf81
incl %r12d
jmp 0x2a155
movsbl %al, %esi
movq %r15, %rdi
callq 0xdf81
incl %r12d
jmp 0x2a123
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
subl $0x1, %r13d
jb 0x2a1b3
movq %r15, %rdi
pushq $0xa
popq %rsi
callq 0xdf81
jmp 0x2a1c7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1e79(%rip), %rdi      # 0x2c069
leaq 0xb465(%rip), %rsi      # 0x3565c
leaq 0xb482(%rip), %rcx      # 0x35680
pushq $0xb
jmp 0x2a24b
leaq 0x2800(%rip), %rdi      # 0x2ca09
leaq 0xb44c(%rip), %rsi      # 0x3565c
leaq 0xb469(%rip), %rcx      # 0x35680
pushq $0xc
jmp 0x2a24b
leaq 0x3cbb(%rip), %rdi      # 0x2dedd
leaq 0xb433(%rip), %rsi      # 0x3565c
leaq 0xb450(%rip), %rcx      # 0x35680
pushq $0xd
jmp 0x2a24b
leaq 0x2302(%rip), %rdi      # 0x2c53d
leaq 0xb41a(%rip), %rsi      # 0x3565c
leaq 0xb437(%rip), %rcx      # 0x35680
pushq $0xe
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/preprocessor/line_concat.c
// Function: pp_line_concat_process
void pp_line_concat_process(
	ResizableString *dst,
	const char *file,
	const char *src,
	int len
) {
	assert(dst);
	assert(file);
	assert(src);

	_process(dst, file, src, len);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2a26a
testq %rsi, %rsi
je 0x2a283
testq %rdx, %rdx
je 0x2a29c
popq %rbp
jmp 0x2a0e4
leaq 0x1df8(%rip), %rdi      # 0x2c069
leaq 0xb3e4(%rip), %rsi      # 0x3565c
leaq 0xb443(%rip), %rcx      # 0x356c2
pushq $0x3a
jmp 0x2a2b3
leaq 0x277f(%rip), %rdi      # 0x2ca09
leaq 0xb3cb(%rip), %rsi      # 0x3565c
leaq 0xb42a(%rip), %rcx      # 0x356c2
pushq $0x3b
jmp 0x2a2b3
leaq 0x3c3a(%rip), %rdi      # 0x2dedd
leaq 0xb3b2(%rip), %rsi      # 0x3565c
leaq 0xb411(%rip), %rcx      # 0x356c2
pushq $0x3c
popq %rdx
callq 0xa0b0
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/preprocessor/parser.c
// Function: pp_parser_new_context
_RULE_END

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

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

	ParserContext *ctx = parser_new_context(lexctx);
	ctx->arch = 0;

	return ctx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2a2f3
testq %rsi, %rsi
je 0x2a312
testl %edx, %edx
js 0x2a331
callq 0x2894c
movq %rax, %rbx
movq %rax, %rdi
callq 0xb4d1
movq %rbx, %rdi
callq 0xcff7
andl $0x0, 0x30(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x270f(%rip), %rdi      # 0x2ca09
leaq 0xb411(%rip), %rsi      # 0x35712
leaq 0xb429(%rip), %rcx      # 0x35731
movl $0x1b4, %edx            # imm = 0x1B4
callq 0xa0b0
leaq 0x221d(%rip), %rdi      # 0x2c536
leaq 0xb3f2(%rip), %rsi      # 0x35712
leaq 0xb40a(%rip), %rcx      # 0x35731
movl $0x1b5, %edx            # imm = 0x1B5
callq 0xa0b0
leaq 0x2205(%rip), %rdi      # 0x2c53d
leaq 0xb3d3(%rip), %rsi      # 0x35712
leaq 0xb3eb(%rip), %rcx      # 0x35731
movl $0x1b6, %edx            # imm = 0x1B6
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/preprocessor/parser.c
// Function: print_ast
static void _print_ast(
	ParserASTNode *node,
	FILE *file,
	int level,
	char padchr
) {
	assert(node);
	assert(file);
	assert(level >= 0);

	for (int i = 0; i < level; i++) {
		fputc(padchr, file);
	}

	fprintf(
		file,
		"@%s#%x#%p#%p#%d",
		node->type_name != NULL ? node->type_name : "N/A",
		node->type,
		node->parent,
		node,
		node->nchilds
	);
	if (node->token != NULL) {
		fputc('(', file);
		for (int i = 0; i < node->token->len; i++) {
			fputc(*(node->token->content + i), file);
		}
		fprintf(file, "#%x)", node->token->type);
	}
	fputc('\n', file);

	for (int i = 0; i < node->nchilds; i++) {
		_print_ast(node->childs[i], file, level + 1, padchr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2a67c
movl %edx, %ebx
testl %edx, %edx
js 0x2a69b
movq %rsi, %r14
movq %rdi, %r15
pushq $0x9
popq %r12
movl %ebx, %r13d
subl $0x1, %r13d
jb 0x2a5be
movl %r12d, %edi
movq %r14, %rsi
callq 0xa0d0
jmp 0x2a5ab
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x9fe3(%rip), %rdx      # 0x345af
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
movl 0x44(%r15), %eax
movl %eax, (%rsp)
leaq 0xb688(%rip), %rsi      # 0x35c6d
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0xa0f0
cmpq $0x0, 0x10(%r15)
je 0x2a63d
pushq $0x28
popq %rdi
movq %r14, %rsi
callq 0xa0d0
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movslq 0x4(%rax), %rcx
cmpq %rcx, %r12
jge 0x2a62a
movq 0x8(%rax), %rax
movsbl (%rax,%r12), %edi
movq %r14, %rsi
callq 0xa0d0
incq %r12
jmp 0x2a607
movl (%rax), %edx
leaq 0x9f80(%rip), %rsi      # 0x345b3
movq %r14, %rdi
xorl %eax, %eax
callq 0xa0f0
pushq $0xa
popq %rdi
movq %r14, %rsi
callq 0xa0d0
incl %ebx
xorl %r12d, %r12d
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jge 0x2a66d
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2a57d
incq %r12
jmp 0x2a64d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6638(%rip), %rdi      # 0x30cbb
leaq 0xb088(%rip), %rsi      # 0x35712
leaq 0x9ed2(%rip), %rcx      # 0x34563
movl $0x1d5, %edx            # imm = 0x1D5
callq 0xa0b0
leaq 0x9ef5(%rip), %rdi      # 0x34597
leaq 0xb069(%rip), %rsi      # 0x35712
leaq 0x9eb3(%rip), %rcx      # 0x34563
movl $0x1d7, %edx            # imm = 0x1D7
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/preprocessor/parser.c
// Function: new_node
static ParserASTNode * _new_node(
	ParserContext *ctx,
	int32_t type,
	char *type_name,
	LexerToken *token
) {
	assert(ctx);
	assert(type_name);

	if (type == PP_NODE_DIRECTIVE_IF
			|| type == PP_NODE_DIRECTIVE_IFDEF
			|| type == PP_NODE_DIRECTIVE_IFNDEF) {
		PPParserIfxxxASTNodeData data;
		data.token_endif = NULL;

		return parser_new_node(ctx, type, type_name, token, sizeof(PPParserIfxxxASTNodeData), &data);
	} else {
		return parser_new_node(ctx, type, type_name, token, 0, NULL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testq %rdx, %rdx
je 0x2a6f9
leal -0x203(%rsi), %eax
cmpl $0x2, %eax
ja 0x2a6e9
leaq -0x8(%rbp), %r9
andq $0x0, (%r9)
pushq $0x8
popq %r8
callq 0xd0f4
addq $0x10, %rsp
popq %rbp
retq
xorl %r8d, %r8d
xorl %r9d, %r9d
addq $0x10, %rsp
popq %rbp
jmp 0xd0f4
leaq 0x92eb(%rip), %rdi      # 0x339eb
leaq 0xb00b(%rip), %rsi      # 0x35712
leaq 0x9294(%rip), %rcx      # 0x339a2
pushq $0x19
popq %rdx
callq 0xa0b0
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]init/syslog.c
// Function: syslog_open
int syslog_open(void) {
  int fd;
  struct sockaddr_un addr = {
    .sun_family = AF_UNIX,
    .sun_path = "/dev/log"
  };

  if ((fd = socket(AF_UNIX, SOCK_DGRAM | SOCK_NONBLOCK, 0)) < 0)
    err(EXIT_FAILURE, "socket");

  unlink(addr.sun_path);
  umask(0111); /* Syslog socket should be writeable by everyone. */
  if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0)
    err(EXIT_FAILURE, "bind %s", addr.sun_path);

  if (setsockopt(fd, SOL_SOCKET, SO_PASSCRED, &(int) { 1 },
        sizeof(int)) < 0)
    err(EXIT_FAILURE, "setsockopt SO_PASSCRED %s", addr.sun_path);
  return fd;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x78, %rsp
leaq 0xf2d(%rip), %rsi       # 0x3206
leaq 0xa(%rsp), %rdi
pushq $0x6e
popq %rdx
callq 0x20e0
pushq $0x1
popq %rdi
movl $0x802, %esi            # imm = 0x802
xorl %edx, %edx
callq 0x21c0
testl %eax, %eax
js 0x234c
movl %eax, %ebp
leaq 0xc(%rsp), %rbx
movq %rbx, %rdi
callq 0x2050
pushq $0x49
popq %rdi
callq 0x20d0
leaq 0xa(%rsp), %rsi
pushq $0x6e
popq %rdx
movl %ebp, %edi
callq 0x2160
testl %eax, %eax
js 0x235d
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x1
popq %rsi
pushq $0x10
popq %rdx
pushq $0x4
popq %r8
movl %ebp, %edi
callq 0x2060
testl %eax, %eax
js 0x2366
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
leaq 0xd7e(%rip), %rsi       # 0x30d1
pushq $0x1
popq %rdi
xorl %eax, %eax
callq 0x2100
leaq 0xd74(%rip), %rsi       # 0x30d8
jmp 0x236d
leaq 0xd73(%rip), %rsi       # 0x30e0
pushq $0x1
popq %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2100
// File: /workspace/github_c_makefile_star2_O2/arachsys[P]init/syslog.c
// Function: syslog_facility
static char *syslog_facility(int priority) {
  for (size_t i = 0; facilitynames[i].c_val >= 0; i++)
    if (facilitynames[i].c_val == (priority & LOG_FACMASK))
      return facilitynames[i].c_name;
  return "unknown"; /* facility not found in facilitynames[] */
}

// Assembly:
andl $0x3f8, %edi            # imm = 0x3F8
leaq 0x27c0(%rip), %rcx      # 0x51d8
leaq 0x7bd(%rip), %rax       # 0x31dc
movl (%rcx), %edx
testl %edx, %edx
js 0x2a31
addq $0x10, %rcx
cmpl %edi, %edx
jne 0x2a1f
movq -0x18(%rcx), %rax
retq