LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_unsigned_mark
bool be_parser_has_unsigned_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_UINT);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x234bc
testq %rsi, %rsi
je 0x234db
cmpl $0x300, (%rsi)          # imm = 0x300
jne 0x234fa
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x200f5
leaq 0x1c8f1(%rip), %rdi     # 0x3fdb4
leaq 0x25d5e(%rip), %rsi     # 0x49228
leaq 0x2632e(%rip), %rcx     # 0x497ff
movl $0xa6b, %edx            # imm = 0xA6B
callq 0x30a0
leaq 0x1da29(%rip), %rdi     # 0x40f0b
leaq 0x25d3f(%rip), %rsi     # 0x49228
leaq 0x2630f(%rip), %rcx     # 0x497ff
movl $0xa6c, %edx            # imm = 0xA6C
callq 0x30a0
leaq 0x25e66(%rip), %rdi     # 0x49367
leaq 0x25d20(%rip), %rsi     # 0x49228
leaq 0x262f0(%rip), %rcx     # 0x497ff
movl $0xa6d, %edx            # imm = 0xA6D
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/parser.c
// Function: be_parser_has_float_mark
bool be_parser_has_float_mark(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_LITERAL_REAL);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2353c
testq %rsi, %rsi
je 0x2355b
cmpl $0x301, (%rsi)          # imm = 0x301
jne 0x2357a
movq (%rdi), %rdi
movq 0x10(%rsi), %rsi
popq %rbp
jmp 0x2017e
leaq 0x1c871(%rip), %rdi     # 0x3fdb4
leaq 0x25cde(%rip), %rsi     # 0x49228
leaq 0x262f2(%rip), %rcx     # 0x49843
movl $0xa76, %edx            # imm = 0xA76
callq 0x30a0
leaq 0x1d9a9(%rip), %rdi     # 0x40f0b
leaq 0x25cbf(%rip), %rsi     # 0x49228
leaq 0x262d3(%rip), %rcx     # 0x49843
movl $0xa77, %edx            # imm = 0xA77
callq 0x30a0
leaq 0x25ecf(%rip), %rdi     # 0x49450
leaq 0x25ca0(%rip), %rsi     # 0x49228
leaq 0x262b4(%rip), %rcx     # 0x49843
movl $0xa78, %edx            # imm = 0xA78
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/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 == BE_TOKEN_PNCT_MUL) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_MUL, expr_unary)
		} else if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_DIV) {
			_EXPR_BINARY_ITEM(BE_NODE_EXPR_DIV, expr_unary)
		} else if (_RULE_TOKEN_TYPE == BE_TOKEN_PNCT_MOD) {
			_EXPR_BINARY_ITEM(BE_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
subq $0x38, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x24f73
callq 0x4699
movq %rbx, %rdi
callq 0x24f92
testq %rax, %rax
je 0x24f4c
movq %rax, %r14
leaq -0x50(%rbp), %r15
leaq -0x58(%rbp), %r12
movq (%rbx), %rdi
callq 0x4699
movq (%rbx), %rdi
callq 0x440c
movq %rax, 0x28(%rbx)
testq %rax, %rax
je 0x24f51
movl (%rax), %eax
cmpl $0x4018, %eax           # imm = 0x4018
je 0x24eca
cmpl $0x4017, %eax           # imm = 0x4017
je 0x24e84
cmpl $0x4016, %eax           # imm = 0x4016
jne 0x24f51
movq %rbx, %rdi
callq 0x24f92
testq %rax, %rax
je 0x24f51
movq %rax, %r13
movb $0x0, -0x58(%rbp)
movl $0x0, 0x7(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movl $0x30, %r8d
movq %rbx, %rdi
movl $0xeb0, %esi            # imm = 0xEB0
leaq 0x24eae(%rip), %rdx     # 0x49d2d
jmp 0x24f0a
movq %rbx, %rdi
callq 0x24f92
testq %rax, %rax
je 0x24f51
movq %rax, %r13
movb $0x0, -0x58(%rbp)
movl $0x0, 0x7(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movl $0x30, %r8d
movq %rbx, %rdi
movl $0xeb1, %esi            # imm = 0xEB1
leaq 0x24e76(%rip), %rdx     # 0x49d3e
jmp 0x24f0a
movq %rbx, %rdi
callq 0x24f92
testq %rax, %rax
je 0x24f51
movq %rax, %r13
movb $0x0, -0x58(%rbp)
movl $0x0, 0x7(%r15)
movq $0x0, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movl $0x30, %r8d
movq %rbx, %rdi
movl $0xeb2, %esi            # imm = 0xEB2
leaq 0x24e45(%rip), %rdx     # 0x49d4f
xorl %ecx, %ecx
movq %r12, %r9
callq 0x65b1
movq %rax, 0x30(%r14)
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x688f
movq %rax, 0x30(%r13)
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x688f
movq %rax, %r14
movq (%rbx), %rdi
callq 0x4762
testq %r14, %r14
jne 0x24dff
xorl %r14d, %r14d
jmp 0x24f59
movq (%rbx), %rdi
callq 0x4701
movq (%rbx), %rdi
callq 0x4762
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2498a(%rip), %rdi     # 0x49904
leaq 0x242a7(%rip), %rsi     # 0x49228
leaq 0x24d76(%rip), %rcx     # 0x49cfe
movl $0x341, %edx            # imm = 0x341
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.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",
		node->type_name != NULL ? node->type_name : "N/A",
		node->type,
		node->parent,
		node
	);
	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);

	if (BE_IS_EXPR_NODE(node->type)) {
		for (int i = 0; i < level; i++) {
			fputc(padchr, file);
		}
		fputs("|ExprNodeType: ", file);
		ParserASTNode *node_t = BE_EXPR_AST_NODE_GET_TYPE_NODE(node);
		if (node_t != NULL) {
			_print_type_node(node_t, file);
		}
		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 %r12
pushq %rbx
testq %rdi, %rdi
je 0x2a329
movl %edx, %ebx
testl %edx, %edx
js 0x2a348
movq %rsi, %r14
movq %rdi, %r15
je 0x2a212
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2a200
movq 0x8(%r15), %rax
testq %rax, %rax
leaq 0x2135d(%rip), %rdx     # 0x4b57d
cmovneq %rax, %rdx
movl (%r15), %ecx
movq 0x30(%r15), %r8
leaq 0x2133e(%rip), %rsi     # 0x4b570
movq %r14, %rdi
movq %r15, %r9
xorl %eax, %eax
callq 0x30f0
cmpq $0x0, 0x10(%r15)
je 0x2a294
movl $0x28, %edi
movq %r14, %rsi
callq 0x30c0
movq 0x10(%r15), %rax
cmpl $0x0, 0x4(%rax)
jle 0x2a281
xorl %r12d, %r12d
movq 0x8(%rax), %rax
movsbl (%rax,%r12), %edi
movq %r14, %rsi
callq 0x30c0
incq %r12
movq 0x10(%r15), %rax
movslq 0x4(%rax), %rcx
cmpq %rcx, %r12
jl 0x2a260
movl (%rax), %edx
leaq 0x212f7(%rip), %rsi     # 0x4b581
movq %r14, %rdi
xorl %eax, %eax
callq 0x30f0
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
movzbl 0x1(%r15), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2a2f6
testl %ebx, %ebx
je 0x2a2c9
movl %ebx, %r12d
movl $0x9, %edi
movq %r14, %rsi
callq 0x30c0
decl %r12d
jne 0x2a2b7
leaq 0x24acd(%rip), %rdi     # 0x4ed9d
movq %r14, %rsi
callq 0x30b0
movq 0x68(%r15), %rdi
testq %rdi, %rdi
je 0x2a2e9
movq %r14, %rsi
callq 0x33ffb
movl $0xa, %edi
movq %r14, %rsi
callq 0x30c0
cmpl $0x0, 0x44(%r15)
jle 0x2a320
incl %ebx
xorl %r12d, %r12d
movq 0x48(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x2a1d7
incq %r12
movslq 0x44(%r15), %rax
cmpq %rax, %r12
jl 0x2a302
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x16bdb(%rip), %rdi     # 0x40f0b
leaq 0x21e09(%rip), %rsi     # 0x4c140
leaq 0x211f3(%rip), %rcx     # 0x4b531
movl $0x191c, %edx           # imm = 0x191C
callq 0x30a0
leaq 0x21216(%rip), %rdi     # 0x4b565
leaq 0x21dea(%rip), %rsi     # 0x4c140
leaq 0x211d4(%rip), %rcx     # 0x4b531
movl $0x191e, %edx           # imm = 0x191E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: be_sem_calc_type_size
size_t be_sem_calc_type_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);

	return _calc_type_size(ctx, node, node_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2a37d
testq %rsi, %rsi
je 0x2a39c
testq %rdx, %rdx
je 0x2a3bb
popq %rbp
jmp 0x2a3da
leaq 0x15a30(%rip), %rdi     # 0x3fdb4
leaq 0x21db5(%rip), %rsi     # 0x4c140
leaq 0x21e26(%rip), %rcx     # 0x4c1b8
movl $0x1955, %edx           # imm = 0x1955
callq 0x30a0
leaq 0x16b68(%rip), %rdi     # 0x40f0b
leaq 0x21d96(%rip), %rsi     # 0x4c140
leaq 0x21e07(%rip), %rcx     # 0x4c1b8
movl $0x1956, %edx           # imm = 0x1956
callq 0x30a0
leaq 0x243f7(%rip), %rdi     # 0x4e7b9
leaq 0x21d77(%rip), %rsi     # 0x4c140
leaq 0x21de8(%rip), %rcx     # 0x4c1b8
movl $0x1957, %edx           # imm = 0x1957
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_struct_member_symbol
static ParserSymbol * _get_struct_member_symbol(
	ParserContext *ctx,
	ParserASTNode *node_struct_id,
	ParserASTNode *node_struct_member_id
) {
	assert(ctx);
	assert(node_struct_id);
	assert(node_struct_id->type == BE_NODE_IDENTIFIER);
	assert(node_struct_member_id);
	assert(node_struct_member_id->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol_struct = _get_struct_symbol_by_id_node(
		ctx, node_struct_id
	);

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

	return symbol_struct_member;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x2aa94
movq %rsi, %r15
testq %rsi, %rsi
je 0x2aab3
cmpl $0x200, (%r15)          # imm = 0x200
jne 0x2aad2
movq %rdx, %r14
testq %rdx, %rdx
je 0x2aaf1
cmpl $0x200, (%r14)          # imm = 0x200
jne 0x2ab10
movq %rdi, %rbx
movq 0x10(%r15), %rcx
movq %r15, %rsi
movl $0x2, %edx
callq 0x6c49
movq %rax, %r12
testq %rax, %rax
jne 0x2aa5b
movq 0x10(%r15), %rsi
leaq 0x235e8(%rip), %rdx     # 0x4e03d
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x10(%r14), %rcx
movq %rbx, %rdi
movq %r12, %rsi
movl $0x5, %edx
callq 0x7198
movq %rax, %r15
testq %rax, %rax
jne 0x2aa88
movq 0x10(%r14), %rsi
leaq 0x235bb(%rip), %rdx     # 0x4e03d
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15319(%rip), %rdi     # 0x3fdb4
leaq 0x2169e(%rip), %rsi     # 0x4c140
leaq 0x244ec(%rip), %rcx     # 0x4ef95
movl $0xfe2, %edx            # imm = 0xFE2
callq 0x30a0
leaq 0x24536(%rip), %rdi     # 0x4eff0
leaq 0x2167f(%rip), %rsi     # 0x4c140
leaq 0x244cd(%rip), %rcx     # 0x4ef95
movl $0xfe3, %edx            # imm = 0xFE3
callq 0x30a0
leaq 0x24526(%rip), %rdi     # 0x4efff
leaq 0x21660(%rip), %rsi     # 0x4c140
leaq 0x244ae(%rip), %rcx     # 0x4ef95
movl $0xfe4, %edx            # imm = 0xFE4
callq 0x30a0
leaq 0x24532(%rip), %rdi     # 0x4f02a
leaq 0x21641(%rip), %rsi     # 0x4c140
leaq 0x2448f(%rip), %rcx     # 0x4ef95
movl $0xfe5, %edx            # imm = 0xFE5
callq 0x30a0
leaq 0x24529(%rip), %rdi     # 0x4f040
leaq 0x21622(%rip), %rsi     # 0x4c140
leaq 0x24470(%rip), %rcx     # 0x4ef95
movl $0xfe6, %edx            # imm = 0xFE6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: expr_wrapper
static void _expr_wrapper(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_EXPR);

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

	_expr(ctx, child);

	BE_EXPR_AST_NODE_COPY(node, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2db4c
movq %rsi, %rbx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x2db6b
movq 0x48(%rbx), %rax
movq (%rax), %r14
movq %r14, %rsi
callq 0x2d6f0
movups 0x60(%r14), %xmm0
movups 0x70(%r14), %xmm1
movups 0x80(%r14), %xmm2
movups %xmm2, 0x80(%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x133b8(%rip), %rdi     # 0x40f0b
leaq 0x1e5e6(%rip), %rsi     # 0x4c140
leaq 0x1ffd0(%rip), %rcx     # 0x4db31
movl $0xe64, %edx            # imm = 0xE64
callq 0x30a0
leaq 0x1fff4(%rip), %rdi     # 0x4db66
leaq 0x1e5c7(%rip), %rsi     # 0x4c140
leaq 0x1ffb1(%rip), %rcx     # 0x4db31
movl $0xe65, %edx            # imm = 0xE65
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_integer_type_node
static bool _is_integer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_integer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2e4c4
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e4e3
movb 0x60(%rdi), %al
decb %al
cmpb $0x9, %al
setb %al
popq %rbp
retq
leaq 0x12a40(%rip), %rdi     # 0x40f0b
leaq 0x1dc6e(%rip), %rsi     # 0x4c140
leaq 0x1f356(%rip), %rcx     # 0x4d82f
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x30a0
leaq 0x1e97c(%rip), %rdi     # 0x4ce66
leaq 0x1dc4f(%rip), %rsi     # 0x4c140
leaq 0x1f337(%rip), %rcx     # 0x4d82f
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_pointer_type_node
static bool _is_pointer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_pointer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2e522
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e541
cmpb $0x10, 0x60(%rdi)
sete %al
popq %rbp
retq
leaq 0x129e2(%rip), %rdi     # 0x40f0b
leaq 0x1dc10(%rip), %rsi     # 0x4c140
leaq 0x1f336(%rip), %rcx     # 0x4d86d
movl $0x208, %edx            # imm = 0x208
callq 0x30a0
leaq 0x1e91e(%rip), %rdi     # 0x4ce66
leaq 0x1dbf1(%rip), %rsi     # 0x4c140
leaq 0x1f317(%rip), %rcx     # 0x4d86d
movl $0x209, %edx            # imm = 0x209
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_primitive_type_node
static bool _is_primitive_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_primitive_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2e583
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2e5a2
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0x12981(%rip), %rdi     # 0x40f0b
leaq 0x1dbaf(%rip), %rsi     # 0x4c140
leaq 0x1f313(%rip), %rcx     # 0x4d8ab
movl $0x22a, %edx            # imm = 0x22A
callq 0x30a0
leaq 0x1e8bd(%rip), %rdi     # 0x4ce66
leaq 0x1db90(%rip), %rsi     # 0x4c140
leaq 0x1f2f4(%rip), %rcx     # 0x4d8ab
movl $0x22b, %edx            # imm = 0x22B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_number_type_node
static bool _is_number_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_number_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x31d0f
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x31d2e
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0xf1f5(%rip), %rdi      # 0x40f0b
leaq 0x1a423(%rip), %rsi     # 0x4c140
leaq 0x1b105(%rip), %rcx     # 0x4ce29
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x30a0
leaq 0x1b131(%rip), %rdi     # 0x4ce66
leaq 0x1a404(%rip), %rsi     # 0x4c140
leaq 0x1b0e6(%rip), %rcx     # 0x4ce29
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_type_by_type_node
static uint8_t _get_type_by_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	switch (node->type) {
		case BE_NODE_TYPE_CHAR: {
			return BE_TYPE_CHAR;
		}
		case BE_NODE_TYPE_INT8: {
			return BE_TYPE_INT8;
		}
		case BE_NODE_TYPE_UINT8: {
			return BE_TYPE_UINT8;
		}
		case BE_NODE_TYPE_INT16: {
			return BE_TYPE_INT16;
		}
		case BE_NODE_TYPE_UINT16: {
			return BE_TYPE_UINT16;
		}
		case BE_NODE_TYPE_INT32: {
			return BE_TYPE_INT32;
		}
		case BE_NODE_TYPE_UINT32: {
			return BE_TYPE_UINT32;
		}
		case BE_NODE_TYPE_INT64: {
			return BE_TYPE_INT64;
		}
		case BE_NODE_TYPE_UINT64: {
			return BE_TYPE_UINT64;
		}
		case BE_NODE_TYPE_FLOAT: {
			return BE_TYPE_FLOAT;
		}
		case BE_NODE_TYPE_DOUBLE: {
			return BE_TYPE_DOUBLE;
		}
		case BE_NODE_TYPE_VA_LIST: {
			return BE_TYPE_VA_LIST;
		}
		case BE_NODE_TYPE_STRUCT: {
			return BE_TYPE_STRUCT;
		}
		case BE_NODE_TYPE_ARRAY: {
			return BE_TYPE_ARRAY;
		}
		case BE_NODE_TYPE_FUNC: {
			return BE_TYPE_FUNC;
		}
		case BE_NODE_TYPE_POINTER: {
			return BE_TYPE_POINTER;
		}
		case BE_NODE_TYPE_VOID: {
			return BE_TYPE_VOID;
		}
		default: {
			assert(0);
		}
	}

	return BE_TYPE_UNKNOWN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x31dda
movl (%rdi), %eax
cmpl $0x42f, %eax            # imm = 0x42F
jg 0x31d85
addl $0xfffffc00, %eax       # imm = 0xFFFFFC00
cmpl $0x20, %eax
ja 0x31df9
leaq 0x19d1c(%rip), %rcx     # 0x4ba94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, %al
jmp 0x31dd8
cmpl $0x430, %eax            # imm = 0x430
je 0x31dd6
cmpl $0x440, %eax            # imm = 0x440
je 0x31dd2
cmpl $0x4ff, %eax            # imm = 0x4FF
jne 0x31df9
movb $-0x1, %al
jmp 0x31dd8
movb $0xa, %al
jmp 0x31dd8
movb $0xc, %al
jmp 0x31dd8
movb $0xb, %al
jmp 0x31dd8
movb $0x7, %al
jmp 0x31dd8
movb $0x6, %al
jmp 0x31dd8
movb $0x5, %al
jmp 0x31dd8
movb $0xe, %al
jmp 0x31dd8
movb $0x4, %al
jmp 0x31dd8
movb $0x9, %al
jmp 0x31dd8
movb $0x3, %al
jmp 0x31dd8
movb $0x2, %al
jmp 0x31dd8
movb $0x8, %al
jmp 0x31dd8
movb $0xd, %al
jmp 0x31dd8
movb $0x10, %al
jmp 0x31dd8
movb $0xf, %al
popq %rbp
retq
leaq 0xf12a(%rip), %rdi      # 0x40f0b
leaq 0x1a358(%rip), %rsi     # 0x4c140
leaq 0x1b093(%rip), %rcx     # 0x4ce82
movl $0xb5, %edx
callq 0x30a0
leaq 0xc569(%rip), %rdi      # 0x3e369
leaq 0x1a339(%rip), %rsi     # 0x4c140
leaq 0x1b074(%rip), %rcx     # 0x4ce82
movl $0xec, %edx
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_int64
static int64_t _get_constexpr_int64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return (int64_t) BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node);	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		_A(POINTER)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x325b4
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x325d3
cmpb $0x0, 0x70(%rdi)
je 0x325f2
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x32611
leaq 0x19903(%rip), %rcx     # 0x4be58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x325b2
movsbq 0x88(%rdi), %rax
jmp 0x325b2
cvttsd2si 0x88(%rdi), %rax
jmp 0x325b2
movl 0x88(%rdi), %eax
jmp 0x325b2
cvttss2si 0x88(%rdi), %rax
jmp 0x325b2
movzwl 0x88(%rdi), %eax
jmp 0x325b2
movswq 0x88(%rdi), %rax
jmp 0x325b2
movslq 0x88(%rdi), %rax
jmp 0x325b2
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0xe950(%rip), %rdi      # 0x40f0b
leaq 0x19b7e(%rip), %rsi     # 0x4c140
leaq 0x1adab(%rip), %rcx     # 0x4d374
movl $0x69f, %edx            # imm = 0x69F
callq 0x30a0
leaq 0x1a88c(%rip), %rdi     # 0x4ce66
leaq 0x19b5f(%rip), %rsi     # 0x4c140
leaq 0x1ad8c(%rip), %rcx     # 0x4d374
movl $0x6a0, %edx            # imm = 0x6A0
callq 0x30a0
leaq 0x1adba(%rip), %rdi     # 0x4d3b3
leaq 0x19b40(%rip), %rsi     # 0x4c140
leaq 0x1ad6d(%rip), %rcx     # 0x4d374
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x30a0
leaq 0xbd51(%rip), %rdi      # 0x3e369
leaq 0x19b21(%rip), %rsi     # 0x4c140
leaq 0x1ad4e(%rip), %rcx     # 0x4d374
movl $0x6b6, %edx            # imm = 0x6B6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_uint64
static uint64_t _get_constexpr_uint64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return (uint64_t) BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node);	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		_A(POINTER)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x32903
cmpb $0x0, 0x70(%rdi)
je 0x32922
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x32941
leaq 0x1966d(%rip), %rcx     # 0x4bed8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x32901
movsbq 0x88(%rdi), %rax
jmp 0x32901
movsd 0x88(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x19862(%rip), %xmm0    # 0x4c108
cvttsd2si %xmm0, %rax
jmp 0x328d6
movl 0x88(%rdi), %eax
jmp 0x32901
movss 0x88(%rdi), %xmm0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x1983f(%rip), %xmm0    # 0x4c110
cvttss2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x32901
movzwl 0x88(%rdi), %eax
jmp 0x32901
movswq 0x88(%rdi), %rax
jmp 0x32901
movslq 0x88(%rdi), %rax
jmp 0x32901
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0x1a55c(%rip), %rdi     # 0x4ce66
leaq 0x1982f(%rip), %rsi     # 0x4c140
leaq 0x1ad60(%rip), %rcx     # 0x4d678
movl $0x6d9, %edx            # imm = 0x6D9
callq 0x30a0
leaq 0x1aa8a(%rip), %rdi     # 0x4d3b3
leaq 0x19810(%rip), %rsi     # 0x4c140
leaq 0x1ad41(%rip), %rcx     # 0x4d678
movl $0x6da, %edx            # imm = 0x6DA
callq 0x30a0
leaq 0xba21(%rip), %rdi      # 0x3e369
leaq 0x197f1(%rip), %rsi     # 0x4c140
leaq 0x1ad22(%rip), %rcx     # 0x4d678
movl $0x6ef, %edx            # imm = 0x6EF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_float
static float _get_constexpr_float(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return (float) BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node);	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x32adc
cmpb $0x0, 0x70(%rdi)
je 0x32afb
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xa, %eax
ja 0x32b1a
leaq 0x19508(%rip), %rcx     # 0x4bf58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl 0x88(%rdi), %eax
jmp 0x32aa2
cvtsi2ssq 0x88(%rdi), %xmm0
jmp 0x32ada
movss 0x88(%rdi), %xmm0
jmp 0x32ada
movswl 0x88(%rdi), %eax
jmp 0x32aa2
cvtsi2ssl 0x88(%rdi), %xmm0
jmp 0x32ada
movl 0x88(%rdi), %eax
jmp 0x32abe
movzbl 0x88(%rdi), %eax
jmp 0x32aa2
movzwl 0x88(%rdi), %eax
cvtsi2ss %eax, %xmm0
jmp 0x32ada
cvtsd2ss 0x88(%rdi), %xmm0
jmp 0x32ada
movq 0x88(%rdi), %rax
testq %rax, %rax
js 0x32ac5
cvtsi2ss %rax, %xmm0
jmp 0x32ada
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
popq %rbp
retq
leaq 0x1a383(%rip), %rdi     # 0x4ce66
leaq 0x19656(%rip), %rsi     # 0x4c140
leaq 0x1ac18(%rip), %rcx     # 0x4d709
movl $0x712, %edx            # imm = 0x712
callq 0x30a0
leaq 0x1a8b1(%rip), %rdi     # 0x4d3b3
leaq 0x19637(%rip), %rsi     # 0x4c140
leaq 0x1abf9(%rip), %rcx     # 0x4d709
movl $0x713, %edx            # imm = 0x713
callq 0x30a0
leaq 0xb848(%rip), %rdi      # 0x3e369
leaq 0x19618(%rip), %rsi     # 0x4c140
leaq 0x1abda(%rip), %rcx     # 0x4d709
movl $0x727, %edx            # imm = 0x727
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: calc_pointer_type_increment_size
static size_t _calc_pointer_type_increment_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);
	assert(node_type->type == BE_NODE_TYPE_POINTER);
	assert(node_type->nchilds == 1);

	return _calc_type_size(ctx, node, node_type->childs[0]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdx, %rdx
je 0x32d3e
cmpl $0x440, (%rdx)          # imm = 0x440
jne 0x32d5d
cmpl $0x1, 0x44(%rdx)
jne 0x32d7c
movq 0x48(%rdx), %rax
movq (%rax), %rdx
popq %rbp
jmp 0x2a3da
leaq 0x1ba74(%rip), %rdi     # 0x4e7b9
leaq 0x193f4(%rip), %rsi     # 0x4c140
leaq 0x1aa80(%rip), %rcx     # 0x4d7d3
movl $0x545, %edx            # imm = 0x545
callq 0x30a0
leaq 0x1086f(%rip), %rdi     # 0x435d3
leaq 0x193d5(%rip), %rsi     # 0x4c140
leaq 0x1aa61(%rip), %rcx     # 0x4d7d3
movl $0x546, %edx            # imm = 0x546
callq 0x30a0
leaq 0x19943(%rip), %rdi     # 0x4c6c6
leaq 0x193b6(%rip), %rsi     # 0x4c140
leaq 0x1aa42(%rip), %rcx     # 0x4d7d3
movl $0x547, %edx            # imm = 0x547
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_compatible_pointer_type
static bool _is_compatible_pointer_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_get_type_by_type_node(ctx, target) == BE_TYPE_POINTER
			&& _get_type_by_type_node(ctx, source) == BE_TYPE_POINTER) {
		if (same) {
			ParserASTNode *target_type = target->childs[0];
			ParserASTNode *source_type = source->childs[0];
			return _is_compatible_type(ctx, target_type, source_type, true);
		} else {
			if (_get_type_by_type_node(ctx, target->childs[0]) == BE_TYPE_VOID) {
				return true;
			} else {
				ParserASTNode *target_type = target->childs[0];
				ParserASTNode *source_type = source->childs[0];
				return _is_compatible_type(ctx, target_type, source_type, true);
			}
		}
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x31d4d
cmpb $0x10, %al
jne 0x3304c
movq %r14, %rdi
callq 0x31d4d
cmpb $0x10, %al
jne 0x3304c
movq 0x48(%r15), %rax
movq (%rax), %rsi
testb %r12b, %r12b
jne 0x33030
movq %rsi, %rdi
callq 0x31d4d
cmpb $-0x1, %al
je 0x33057
movq 0x48(%r15), %rax
movq (%rax), %rsi
movq 0x48(%r14), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2e5c1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x3304e
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_bool
static bool _get_constexpr_bool(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case BE_TYPE_##type: {	\
			return BE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node) != 0;	\
		}

	switch (BE_EXPR_AST_NODE_GET_CONSTANT_TYPE(node)) {
		_A(CHAR)
		_A(INT8)
		_A(INT16)
		_A(INT32)
		_A(INT64)
		_A(UINT8)
		_A(UINT16)
		_A(UINT32)
		_A(UINT64)
		_A(FLOAT)
		_A(DOUBLE)
		_A(POINTER)
		default: {
			assert(0);
			return 0;
		}
	}

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x330e8
cmpb $0x0, 0x70(%rdi)
je 0x33107
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x33126
leaq 0x18f63(%rip), %rcx     # 0x4bff0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, 0x88(%rdi)
jmp 0x330ba
cmpq $0x0, 0x88(%rdi)
jmp 0x330ba
cmpw $0x0, 0x88(%rdi)
jmp 0x330ba
cmpl $0x0, 0x88(%rdi)
setne %al
popq %rbp
retq
xorpd %xmm0, %xmm0
cmpneqsd 0x88(%rdi), %xmm0
movq %xmm0, %rax
jmp 0x330e3
xorps %xmm0, %xmm0
cmpneqss 0x88(%rdi), %xmm0
movd %xmm0, %eax
andl $0x1, %eax
jmp 0x330bd
leaq 0x19d77(%rip), %rdi     # 0x4ce66
leaq 0x1904a(%rip), %rsi     # 0x4c140
leaq 0x1a9ba(%rip), %rcx     # 0x4dab7
movl $0x758, %edx            # imm = 0x758
callq 0x30a0
leaq 0x1a2a5(%rip), %rdi     # 0x4d3b3
leaq 0x1902b(%rip), %rsi     # 0x4c140
leaq 0x1a99b(%rip), %rcx     # 0x4dab7
movl $0x759, %edx            # imm = 0x759
callq 0x30a0
leaq 0xb23c(%rip), %rdi      # 0x3e369
leaq 0x1900c(%rip), %rsi     # 0x4c140
leaq 0x1a97c(%rip), %rcx     # 0x4dab7
movl $0x76e, %edx            # imm = 0x76E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: _func_process_label
static void __func_process_label(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *current
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STATS_BLOCK);
	assert(current);

	if (current->type == BE_NODE_STAT_LABEL) {
		parser_add_symbol_to_node(
			ctx,
			node,
			BE_SYM_LABEL,
			current->childs[0]->token,
			0,
			NULL
		);
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0xb00, (%rsi)          # imm = 0xB00
jne 0x334fb
movq %rdx, %rbx
testq %rdx, %rdx
je 0x3351a
movq %rsi, %r14
movq %rdi, %r15
cmpl $0xb30, (%rbx)          # imm = 0xB30
jne 0x334ca
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6cf0
cmpl $0x0, 0x44(%rbx)
jle 0x334f2
xorl %r12d, %r12d
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x33480
incq %r12
movslq 0x44(%rbx), %rax
cmpq %rax, %r12
jl 0x334d3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a9e4(%rip), %rdi     # 0x4dee6
leaq 0x18c37(%rip), %rsi     # 0x4c140
leaq 0x1a9f8(%rip), %rcx     # 0x4df08
movl $0x1781, %edx           # imm = 0x1781
callq 0x30a0
leaq 0x1aa34(%rip), %rdi     # 0x4df55
leaq 0x18c18(%rip), %rsi     # 0x4c140
leaq 0x1a9d9(%rip), %rcx     # 0x4df08
movl $0x1782, %edx           # imm = 0x1782
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_var_symbol_by_id_node
static ParserSymbol * _get_var_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx, node, BE_SYM_VAR, node->token
	);
	if (symbol == NULL) {
		_SYNERR_TOKEN(ctx, node->token, "invalid identifier.");
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3358e
movq %rsi, %r14
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x335ad
movq %rdi, %rbx
movq 0x10(%r14), %rcx
movq %r14, %rsi
movl $0x1, %edx
callq 0x6c49
movq %rax, %r15
testq %rax, %rax
jne 0x33580
movq 0x10(%r14), %rsi
leaq 0x1aac3(%rip), %rdx     # 0x4e03d
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd976(%rip), %rdi      # 0x40f0b
leaq 0x18ba4(%rip), %rsi     # 0x4c140
leaq 0x1aa4f(%rip), %rcx     # 0x4dff2
movl $0xfbe, %edx            # imm = 0xFBE
callq 0x30a0
leaq 0xd840(%rip), %rdi      # 0x40df4
leaq 0x18b85(%rip), %rsi     # 0x4c140
leaq 0x1aa30(%rip), %rcx     # 0x4dff2
movl $0xfbf, %edx            # imm = 0xFBF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_param_info
static void _get_param_info(
	ParserContext *ctx,
	ParserASTNode *node_param,
	_GetParamInfoResult *result
) {
	assert(ctx);
	assert(node_param);
	assert(result);

	ParserASTNode *node_type = NULL;
	uint8_t type = BE_TYPE_UNKNOWN;

	if (node_param->type == BE_NODE_IDENTIFIER) {
		ParserSymbol *symbol = _get_symbol_by_id_node(ctx, node_param);
		if (symbol->type == BE_SYM_VAR) {
			node_type = BE_VAR_SYMBOL_GET_TYPE_NODE(symbol);
		} else if (symbol->type == BE_SYM_FUNC) {
			node_type = BE_FUNC_SYMBOL_GET_FUNC_POINTER_TYPE_NODE(symbol);
		} else {
			_SYNERR_NODE(
				ctx,
				node_param,
				"expect variable name or function name."
			);
		}
	} else if (node_param->type == BE_NODE_EXPR) {
		_expr_wrapper(ctx, node_param);
		node_type = BE_EXPR_AST_NODE_GET_TYPE_NODE(node_param);
	} else {
		assert(0);
	}
	type = _get_type_by_type_node(ctx, node_type);

	result->node_type = node_type;
	result->type = type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rsi, %rsi
je 0x33692
movq %rdx, %rbx
testq %rdx, %rdx
je 0x336b1
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x33628
cmpl $0x200, %eax            # imm = 0x200
jne 0x336d0
movq %r15, %rdi
movq %r14, %rsi
callq 0x33790
movl (%rax), %ecx
cmpl $0x3, %ecx
je 0x33639
cmpl $0x1, %ecx
jne 0x3363f
movq 0x38(%rax), %r14
jmp 0x33676
movq %r15, %rdi
movq %r14, %rsi
callq 0x2db00
movq 0x68(%r14), %r14
jmp 0x33676
movq 0x48(%rax), %r14
jmp 0x33676
movups 0x1ab41(%rip), %xmm0    # 0x4e187
leaq -0x420(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movups 0x1ab1f(%rip), %xmm0    # 0x4e177
movaps %xmm0, (%rdx)
movabsq $0x2e656d616e206e, %rax # imm = 0x2E656D616E206E
movq %rax, 0x1f(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq *0x58(%r15)
xorl %r14d, %r14d
movq %r14, %rdi
callq 0x31d4d
movq %r14, (%rbx)
movb %al, 0x8(%rbx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1aacc(%rip), %rdi     # 0x4e165
leaq 0x18aa0(%rip), %rsi     # 0x4c140
leaq 0x1aa70(%rip), %rcx     # 0x4e117
movl $0x105e, %edx           # imm = 0x105E
callq 0x30a0
leaq 0x1aab8(%rip), %rdi     # 0x4e170
leaq 0x18a81(%rip), %rsi     # 0x4c140
leaq 0x1aa51(%rip), %rcx     # 0x4e117
movl $0x105f, %edx           # imm = 0x105F
callq 0x30a0
leaq 0xac92(%rip), %rdi      # 0x3e369
leaq 0x18a62(%rip), %rsi     # 0x4c140
leaq 0x1aa32(%rip), %rcx     # 0x4e117
movl $0x1075, %edx           # imm = 0x1075
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: check_param_combination2
static void _check_param_combination2(
	ParserContext *ctx,
	ParserASTNode *node,		// 用来报错时提供错误位置。
	ParserASTNode *node_type1,
	ParserASTNode *node_type2
) {
	assert(ctx);
	assert(node);
	assert(node_type1);
	assert(node_type2);

	if (!_is_compatible_type(ctx, node_type1, node_type2, true)) {
		_SYNERR_NODE(ctx, node, "invalid parameter combination.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
testq %rdx, %rdx
je 0x33752
testq %rcx, %rcx
je 0x33771
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %rsi
movq %rcx, %rdx
movl $0x1, %ecx
callq 0x2e5c1
testb %al, %al
jne 0x33746
movups 0x1ab45(%rip), %xmm0    # 0x4e26d
leaq -0x410(%rbp), %rdx
movups %xmm0, 0xf(%rdx)
movups 0x1ab24(%rip), %xmm0    # 0x4e25e
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x58(%rbx)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1aaef(%rip), %rdi     # 0x4e248
leaq 0x189e0(%rip), %rsi     # 0x4c140
leaq 0x1aa7e(%rip), %rcx     # 0x4e1e5
movl $0x1040, %edx           # imm = 0x1040
callq 0x30a0
leaq 0x1aadb(%rip), %rdi     # 0x4e253
leaq 0x189c1(%rip), %rsi     # 0x4c140
leaq 0x1aa5f(%rip), %rcx     # 0x4e1e5
movl $0x1041, %edx           # imm = 0x1041
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_symbol_by_id_node
static ParserSymbol * _get_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol = parser_get_symbol_from_node(
		ctx, node, 0, node->token
	);
	if (symbol == NULL) {
		_SYNERR_TOKEN(ctx, node->token, "invalid identifier.");
	}

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x337e2
movq %rsi, %r14
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x33801
movq %rdi, %rbx
movq 0x10(%r14), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x6c49
movq %rax, %r15
testq %rax, %rax
jne 0x337d4
movq 0x10(%r14), %rsi
leaq 0x1a86f(%rip), %rdx     # 0x4e03d
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd722(%rip), %rdi      # 0x40f0b
leaq 0x18950(%rip), %rsi     # 0x4c140
leaq 0x1a9a7(%rip), %rcx     # 0x4e19e
movl $0xffb, %edx            # imm = 0xFFB
callq 0x30a0
leaq 0xd5ec(%rip), %rdi      # 0x40df4
leaq 0x18931(%rip), %rsi     # 0x4c140
leaq 0x1a988(%rip), %rcx     # 0x4e19e
movl $0xffc, %edx            # imm = 0xFFC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: check_stat_i_ci
static void _check_stat_i_ci(
	ParserContext *ctx,
	ParserASTNode *node,
	uint32_t node_type,
	_ResultCheckStat_I_CI *result
) {
	assert(ctx);
	assert(node);
	assert(node->type == node_type);
	assert(node->nchilds == 2);
	assert(result);

	ParserASTNode *node_target = node->childs[0];
	assert(node_target->type == BE_NODE_IDENTIFIER);
	ParserSymbol *symbol_target = _get_var_symbol_by_id_node(ctx, node_target);
	ParserASTNode *node_type_target = BE_VAR_SYMBOL_GET_TYPE_NODE(symbol_target);

	ParserASTNode *node_source = node->childs[1];
	_GetParamInfoResult result_source;
	_get_param_info(ctx, node_source, &result_source);

	result->node_target = node_target;
	result->node_type_target = node_type_target;
	result->type_target = _get_type_by_type_node(ctx, node_type_target);
	result->size_target = _calc_type_size(ctx, node, node_type_target);

	result->node_source = node_source;
	result->node_type_source = result_source.node_type;
	result->type_source = result_source.type;
	result->size_source = _calc_type_size(ctx, node, result_source.node_type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, (%rsi)
jne 0x33a19
movq %rsi, %r14
cmpl $0x2, 0x44(%rsi)
jne 0x33a38
movq %rcx, %rbx
testq %rcx, %rcx
je 0x33a57
movq 0x48(%r14), %rax
movq (%rax), %r12
cmpl $0x200, (%r12)          # imm = 0x200
jne 0x33a76
movq %rdi, %r15
movq %r12, %rsi
callq 0x33539
movq 0x38(%rax), %r13
movq 0x48(%r14), %rax
movq 0x8(%rax), %rsi
movq %rsi, -0x30(%rbp)
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x335cc
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
movq %r13, %rdi
callq 0x31d4d
movb %al, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2a3da
movq %rax, 0x18(%rbx)
movq -0x30(%rbp), %rax
movq %rax, 0x20(%rbx)
leaq -0x40(%rbp), %rax
movq (%rax), %rdx
movq %rdx, 0x28(%rbx)
movb 0x8(%rax), %al
movb %al, 0x30(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2a3da
movq %rax, 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1ad8b(%rip), %rdi     # 0x4e7ab
leaq 0x18719(%rip), %rsi     # 0x4c140
leaq 0x1ad22(%rip), %rcx     # 0x4e750
movl $0x11df, %edx           # imm = 0x11DF
callq 0x30a0
leaq 0x18b96(%rip), %rdi     # 0x4c5d5
leaq 0x186fa(%rip), %rsi     # 0x4c140
leaq 0x1ad03(%rip), %rcx     # 0x4e750
movl $0x11e0, %edx           # imm = 0x11E0
callq 0x30a0
leaq 0x1a712(%rip), %rdi     # 0x4e170
leaq 0x186db(%rip), %rsi     # 0x4c140
leaq 0x1ace4(%rip), %rcx     # 0x4e750
movl $0x11e1, %edx           # imm = 0x11E1
callq 0x30a0
leaq 0xd2ef(%rip), %rdi      # 0x40d6c
leaq 0x186bc(%rip), %rsi     # 0x4c140
leaq 0x1acc5(%rip), %rcx     # 0x4e750
movl $0x11e4, %edx           # imm = 0x11E4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]enchive/src/optparse.h
// Function: optparse_error
static int
optparse_error(struct optparse *options, const char *msg, const char *data)
{
    unsigned p = 0;
    const char *sep = " -- '";
    while (*msg)
        options->errmsg[p++] = *msg++;
    while (*sep)
        options->errmsg[p++] = *sep++;
    while (p < sizeof(options->errmsg) - 2 && *data)
        options->errmsg[p++] = *data++;
    options->errmsg[p++] = '\'';
    options->errmsg[p++] = '\0';
    return '?';
}

// Assembly:
movb (%rsi), %cl
xorl %eax, %eax
testb %cl, %cl
je 0x2824
movl %eax, %r8d
movb %cl, 0x20(%rdi,%r8)
movb 0x1(%rsi,%rax), %cl
incq %rax
jmp 0x280f
movl %eax, %eax
movb $0x20, %sil
xorl %ecx, %ecx
leaq 0x598e(%rip), %r8       # 0x81c0
leal (%rax,%rcx), %r9d
movb %sil, 0x20(%rdi,%r9)
movb 0x1(%rcx,%r8), %sil
incq %rcx
cmpq $0x5, %rcx
jne 0x2832
addq %rcx, %rax
cmpl $0x3e, %eax
jae 0x2872
movl %eax, %ecx
movb (%rdx), %sil
testb %sil, %sil
je 0x2876
incq %rdx
leaq 0x1(%rcx), %rax
movb %sil, 0x20(%rdi,%rcx)
cmpq $0x3d, %rcx
movq %rax, %rcx
jb 0x2853
jmp 0x2879
movl %eax, %ecx
jmp 0x287c
movq %rcx, %rax
movq %rax, %rcx
incl %eax
movb $0x27, 0x20(%rdi,%rcx)
movb $0x0, 0x20(%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]enchive/src/optparse.h
// Function: optparse_arg
OPTPARSE_API
char *
optparse_arg(struct optparse *options)
{
    char *option = options->argv[options->optind];
    options->subopt = 0;
    if (option != 0)
        options->optind++;
    return option;
}

// Assembly:
movq (%rdi), %rax
movslq 0xc(%rdi), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x60(%rdi)
testq %rax, %rax
je 0x28a5
incl %ecx
movl %ecx, 0xc(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]enchive/src/enchive.c
// Function: fatal
static void
fatal(const char *fmt, ...)
{
    unsigned i;
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "enchive: ");
    vfprintf(stderr, fmt, ap);
    fputc('\n', stderr);
    for (i = 0; i < sizeof(cleanup) / sizeof(*cleanup); i++) {
        if (cleanup[i].file)
            fclose(cleanup[i].file);
        if (cleanup[i].name)
            remove(cleanup[i].name);
    }
    va_end(ap);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3f0b
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x70c6(%rip), %r15      # 0xaff8
movq (%r15), %rcx
leaq 0x428a(%rip), %rdi      # 0x81c6
movl $0x9, %esi
movl $0x1, %edx
callq 0x2320
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x22d0
movq (%r15), %rsi
movl $0xa, %edi
callq 0x2190
movb $0x1, %bl
xorl %r15d, %r15d
leaq 0x728e(%rip), %r14      # 0xb200
shlq $0x4, %r15
movq 0x8(%r15,%r14), %rdi
testq %rdi, %rdi
je 0x3f85
callq 0x2100
addq %r14, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3f95
callq 0x2090
movl $0x1, %r15d
testb $0x1, %bl
movl $0x0, %ebx
jne 0x3f72
movl $0x1, %edi
callq 0x2300
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]enchive/src/enchive.c
// Function: dupstr
static char *
dupstr(const char *s)
{
    char *copy = 0;
    if (s) {
        size_t len = strlen(s) + 1;
        copy = malloc(len);
        if (!copy)
            fatal("out of memory");
        memcpy(copy, s, len);
    }
    return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x4032
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x2230
testq %rax, %rax
je 0x403c
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x46e6(%rip), %rdi      # 0x8729
xorl %eax, %eax
callq 0x3ea8
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]enchive/src/enchive.c
// Function: print_fingerprint
static void
print_fingerprint(const uint8_t *key)
{
    int i;
    uint8_t hash[32];
    SHA256_CTX sha[1];

    sha256_init(sha);
    sha256_update(sha, key, 32);
    sha256_final(sha, hash);
    for (i = 0; i < 16; i += 4) {
        unsigned long chunk =
            ((unsigned long)hash[i + 0] << 24) |
            ((unsigned long)hash[i + 1] << 16) |
            ((unsigned long)hash[i + 2] <<  8) |
            ((unsigned long)hash[i + 3] <<  0);
        printf("%s%08lx", i ? "-" : "", chunk);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x700c
movl $0x20, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7032
movq %rsp, %rsi
movq %r14, %rdi
callq 0x709b
movq $-0x4, %r14
leaq 0x3f3e(%rip), %r15      # 0x8b14
leaq 0x400b(%rip), %r12      # 0x8be8
leaq 0x3ffc(%rip), %rbx      # 0x8be0
movl 0x4(%rsp,%r14), %edx
bswapl %edx
cmpq $-0x4, %r14
movq %r12, %rsi
cmoveq %r15, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2140
addq $0x4, %r14
cmpq $0xc, %r14
jb 0x4be4
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/skeeto[P]enchive/src/enchive.c
// Function: storage_directory
static char *
storage_directory(char *file)
{
    static const char enchive[] = "/enchive/";
    static const char config[] = "/.config";
    char *xdg_config_home = getenv("XDG_CONFIG_HOME");
    char *path, *s;

    if (!xdg_config_home) {
        char *home = getenv("HOME");
        if (!home)
            fatal("no $HOME or $XDG_CONFIG_HOME, giving up");
        if (home[0] != '/')
            fatal("$HOME is not absolute");
        path = joinstr(4, home, config, enchive, file);
    } else {
        if (xdg_config_home[0] != '/')
            fatal("$XDG_CONFIG_HOME is not absolute");
        path = joinstr(3, xdg_config_home, enchive, file);
    }

    s = strchr(path + 1, '/');
    while (s) {
        *s = 0;
        if (mkdir(path, 0700) && !dir_exists(path))
            fatal("mkdir(%s) -- %s", path, strerror(errno));
        *s = '/';
        s = strchr(s + 1, '/');
    }

    return path;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x3b13(%rip), %rdi      # 0x8743
callq 0x2030
testq %rax, %rax
je 0x4c5e
cmpb $0x2f, (%rax)
jne 0x4d3d
leaq 0x3436(%rip), %rdx      # 0x8080
movl $0x3, %edi
movq %rax, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x4d5d
jmp 0x4c9c
leaq 0x3ae9(%rip), %rdi      # 0x874e
callq 0x2030
testq %rax, %rax
je 0x4d46
cmpb $0x2f, (%rax)
jne 0x4d4f
leaq 0x3407(%rip), %rdx      # 0x808a
leaq 0x33f6(%rip), %rcx      # 0x8080
movl $0x4, %edi
movq %rax, %rsi
movq %rbx, %r8
xorl %eax, %eax
callq 0x4d5d
movq %rax, %rbx
leaq 0x1(%rax), %rdi
movl $0x2f, %esi
callq 0x2130
testq %rax, %rax
je 0x4d0c
movq %rax, %r14
leaq 0x8(%rsp), %r15
movl $0xf000, %ebp           # imm = 0xF000
movb $0x0, (%r14)
movq %rbx, %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20b0
testl %eax, %eax
je 0x4cf0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
testl %eax, %eax
jne 0x4d1d
movl 0x20(%rsp), %eax
andl %ebp, %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4d1d
movb $0x2f, (%r14)
incq %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x2130
movq %rax, %r14
testq %rax, %rax
jne 0x4cbf
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movl (%rax), %edi
callq 0x2340
leaq 0x3a82(%rip), %rdi      # 0x87b2
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3ea8
leaq 0x3a4d(%rip), %rdi      # 0x8791
jmp 0x4d56
leaq 0x3a06(%rip), %rdi      # 0x8753
jmp 0x4d56
leaq 0x3a25(%rip), %rdi      # 0x877b
xorl %eax, %eax
callq 0x3ea8