LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_band
static void _expr_band(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	#define	_CHECK	\
	{	\
		assert(node->nchilds == 2);	\
	}

	uint32_t node_type = node->type;

	switch (node_type) {
		case FE_NODE_EXPR_BAND: {
			_CHECK
			ParserASTNode *node_oprd1 = node->childs[0];
			ParserASTNode *node_oprd2 = node->childs[1];
			_expr_eq(ctx, node_oprd1);
			_expr_eq(ctx, node_oprd2);

			const char *operator = "&";

			_check_expr_band_operands(
				ctx, node, node_oprd1, node_oprd2, operator, true
			);

			FE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (FE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_eq(ctx, node);
			break;
		}
	}

	#undef	_CHECK
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x55109
jmp 0x55128
leaq 0x27446(%rip), %rdi     # 0x7c556
leaq 0x29133(%rip), %rsi     # 0x7e24a
movl $0x1158, %edx           # imm = 0x1158
leaq 0x299c5(%rip), %rcx     # 0x7eae8
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x55131
jmp 0x55150
leaq 0x20e9b(%rip), %rdi     # 0x75fd3
leaq 0x2910b(%rip), %rsi     # 0x7e24a
movl $0x1159, %edx           # imm = 0x1159
leaq 0x2999d(%rip), %rcx     # 0x7eae8
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0xe60, %eax            # imm = 0xE60
jne 0x55241
jmp 0x55169
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x55175
jmp 0x55194
leaq 0x294f8(%rip), %rdi     # 0x7e674
leaq 0x290c7(%rip), %rsi     # 0x7e24a
movl $0x1164, %edx           # imm = 0x1164
leaq 0x29959(%rip), %rcx     # 0x7eae8
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x55260
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x55260
leaq 0x25e09(%rip), %rax     # 0x7afdd
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movl $0x1, %r9d
callq 0x51dd0
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x70(%rcx)
movb %al, -0x31(%rbp)
je 0x55210
movq -0x28(%rbp), %rax
movb 0x70(%rax), %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x70(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x70(%rax)
je 0x5523f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x52e70
jmp 0x5524e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55260
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_number_type_node
static bool _is_number_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));

	return _is_number_type(FE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x57d39
jmp 0x57d58
leaq 0x24816(%rip), %rdi     # 0x7c556
leaq 0x26503(%rip), %rsi     # 0x7e24a
movl $0x1ec, %edx            # imm = 0x1EC
leaq 0x27687(%rip), %rcx     # 0x7f3da
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x57d61
jmp 0x57d80
leaq 0x1e26b(%rip), %rdi     # 0x75fd3
leaq 0x264db(%rip), %rsi     # 0x7e24a
movl $0x1ed, %edx            # imm = 0x1ED
leaq 0x2765f(%rip), %rcx     # 0x7f3da
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x57d94
jmp 0x57db3
leaq 0x2767c(%rip), %rdi     # 0x7f417
leaq 0x264a8(%rip), %rsi     # 0x7e24a
movl $0x1ee, %edx            # imm = 0x1EE
leaq 0x2762c(%rip), %rcx     # 0x7f3da
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4d500
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: expr_parenthesis
static void _expr_parenthesis(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	if (node->type == FE_NODE_EXPR_ATOM) {
		_expr_atom(ctx, node);
	} else {
		_expr(ctx, node);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5a6b9
jmp 0x5a6d8
leaq 0x21e96(%rip), %rdi     # 0x7c556
leaq 0x23b83(%rip), %rsi     # 0x7e24a
movl $0xc6d, %edx            # imm = 0xC6D
leaq 0x24ad4(%rip), %rcx     # 0x7f1a7
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5a6e1
jmp 0x5a700
leaq 0x1b8eb(%rip), %rdi     # 0x75fd3
leaq 0x23b5b(%rip), %rsi     # 0x7e24a
movl $0xc6e, %edx            # imm = 0xC6E
leaq 0x24aac(%rip), %rcx     # 0x7f1a7
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xee0, (%rax)          # imm = 0xEE0
jne 0x5a71b
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5aa70
jmp 0x5a728
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4f4b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/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 == FE_NODE_TYPE_POINTER);
	assert(node_type->nchilds == 1);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5c66d
jmp 0x5c68c
leaq 0x1fee2(%rip), %rdi     # 0x7c556
leaq 0x21bcf(%rip), %rsi     # 0x7e24a
movl $0x82e, %edx            # imm = 0x82E
leaq 0x232db(%rip), %rcx     # 0x7f962
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5c695
jmp 0x5c6b4
leaq 0x19937(%rip), %rdi     # 0x75fd3
leaq 0x21ba7(%rip), %rsi     # 0x7e24a
movl $0x82f, %edx            # imm = 0x82F
leaq 0x232b3(%rip), %rcx     # 0x7f962
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5c6bd
jmp 0x5c6dc
leaq 0x1806f(%rip), %rdi     # 0x74733
leaq 0x21b7f(%rip), %rsi     # 0x7e24a
movl $0x830, %edx            # imm = 0x830
leaq 0x2328b(%rip), %rcx     # 0x7f962
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x440, (%rax)          # imm = 0x440
jne 0x5c6ea
jmp 0x5c709
leaq 0x189a1(%rip), %rdi     # 0x75092
leaq 0x21b52(%rip), %rsi     # 0x7e24a
movl $0x831, %edx            # imm = 0x831
leaq 0x2325e(%rip), %rcx     # 0x7f962
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5c715
jmp 0x5c734
leaq 0x18058(%rip), %rdi     # 0x74774
leaq 0x21b27(%rip), %rsi     # 0x7e24a
movl $0x832, %edx            # imm = 0x832
leaq 0x23233(%rip), %rcx     # 0x7f962
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdx
callq 0x57dd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_primitive_type
static bool _is_compatible_primitive_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (same) {
		uint8_t target_type = _get_type_by_type_node(ctx, target);
		uint8_t source_type = _get_type_by_type_node(ctx, source);
		return _is_primitive_type(target_type)
				&& target_type == source_type;
	} else {
		return _is_primitive_type(_get_type_by_type_node(ctx, target))
				&& _is_primitive_type(_get_type_by_type_node(ctx, source));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5c9e4
jmp 0x5ca03
leaq 0x1fb6b(%rip), %rdi     # 0x7c556
leaq 0x21858(%rip), %rsi     # 0x7e24a
movl $0x23c, %edx            # imm = 0x23C
leaq 0x23788(%rip), %rcx     # 0x80186
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5ca0c
jmp 0x5ca2b
leaq 0x1ed0f(%rip), %rdi     # 0x7b722
leaq 0x21830(%rip), %rsi     # 0x7e24a
movl $0x23d, %edx            # imm = 0x23D
leaq 0x23760(%rip), %rcx     # 0x80186
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5ca34
jmp 0x5ca53
leaq 0x14b56(%rip), %rdi     # 0x71591
leaq 0x21808(%rip), %rsi     # 0x7e24a
movl $0x23e, %edx            # imm = 0x23E
leaq 0x23738(%rip), %rcx     # 0x80186
callq 0x30a0
testb $0x1, -0x21(%rbp)
je 0x5caaa
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d750
movb %al, -0x22(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d750
movb %al, -0x23(%rbp)
movzbl -0x22(%rbp), %edi
callq 0x4d470
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x24(%rbp)
jne 0x5ca90
jmp 0x5caa0
movzbl -0x22(%rbp), %eax
movzbl -0x23(%rbp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x24(%rbp)
movb -0x24(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5caed
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d750
movzbl %al, %edi
callq 0x4d470
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x25(%rbp)
jne 0x5cacd
jmp 0x5cae5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d750
movzbl %al, %edi
callq 0x4d470
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_struct_type
static bool _is_compatible_struct_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_get_type_by_type_node(ctx, target) == FE_TYPE_STRUCT
			&& _get_type_by_type_node(ctx, source) == FE_TYPE_STRUCT) {
		return lexer_compare_token(
			target->childs[0]->token,
			source->childs[0]->token
		);
	} else {
		return false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5cb24
jmp 0x5cb43
leaq 0x1fa2b(%rip), %rdi     # 0x7c556
leaq 0x21718(%rip), %rsi     # 0x7e24a
movl $0x251, %edx            # imm = 0x251
leaq 0x236a6(%rip), %rcx     # 0x801e4
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5cb4c
jmp 0x5cb6b
leaq 0x1ebcf(%rip), %rdi     # 0x7b722
leaq 0x216f0(%rip), %rsi     # 0x7e24a
movl $0x252, %edx            # imm = 0x252
leaq 0x2367e(%rip), %rcx     # 0x801e4
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5cb74
jmp 0x5cb93
leaq 0x14a16(%rip), %rdi     # 0x71591
leaq 0x216c8(%rip), %rsi     # 0x7e24a
movl $0x253, %edx            # imm = 0x253
leaq 0x23656(%rip), %rcx     # 0x801e4
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0xd, %eax
jne 0x5cbe7
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0xd, %eax
jne 0x5cbe7
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
callq 0x5400
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5cbeb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/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) == FE_TYPE_POINTER
			&& _get_type_by_type_node(ctx, source) == FE_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]) == FE_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
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5ce84
jmp 0x5cea3
leaq 0x1f6cb(%rip), %rdi     # 0x7c556
leaq 0x213b8(%rip), %rsi     # 0x7e24a
movl $0x2d7, %edx            # imm = 0x2D7
leaq 0x233fa(%rip), %rcx     # 0x80298
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5ceac
jmp 0x5cecb
leaq 0x1e86f(%rip), %rdi     # 0x7b722
leaq 0x21390(%rip), %rsi     # 0x7e24a
movl $0x2d8, %edx            # imm = 0x2D8
leaq 0x233d2(%rip), %rcx     # 0x80298
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5ced4
jmp 0x5cef3
leaq 0x146b6(%rip), %rdi     # 0x71591
leaq 0x21368(%rip), %rsi     # 0x7e24a
movl $0x2d9, %edx            # imm = 0x2D9
leaq 0x233aa(%rip), %rcx     # 0x80298
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0x10, %eax
jne 0x5cfc5
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0x10, %eax
jne 0x5cfc5
testb $0x1, -0x21(%rbp)
je 0x5cf66
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
movl $0x1, %ecx
callq 0x4d570
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5cfc9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0xff, %eax
jne 0x5cf8a
movb $0x1, -0x1(%rbp)
jmp 0x5cfc9
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
movl $0x1, %ecx
callq 0x4d570
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5cfc9
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: func_process_label
static void _func_process_label(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STATS_BLOCK);

	__func_process_label(ctx, node, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d339
jmp 0x5d358
leaq 0x1f216(%rip), %rdi     # 0x7c556
leaq 0x20f03(%rip), %rsi     # 0x7e24a
movl $0x14cd, %edx           # imm = 0x14CD
leaq 0x2323e(%rip), %rcx     # 0x80591
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5d361
jmp 0x5d380
leaq 0x18c6b(%rip), %rdi     # 0x75fd3
leaq 0x20edb(%rip), %rsi     # 0x7e24a
movl $0x14ce, %edx           # imm = 0x14CE
leaq 0x23216(%rip), %rcx     # 0x80591
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb00, (%rax)          # imm = 0xB00
jne 0x5d38e
jmp 0x5d3ad
leaq 0x23237(%rip), %rdi     # 0x805cc
leaq 0x20eae(%rip), %rsi     # 0x7e24a
movl $0x14cf, %edx           # imm = 0x14CF
leaq 0x231e9(%rip), %rcx     # 0x80591
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5d4b0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stats_block
static void _stats_block(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STATS_BLOCK);

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

		_stat(ctx, child);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d3e9
jmp 0x5d408
leaq 0x1f166(%rip), %rdi     # 0x7c556
leaq 0x20e53(%rip), %rsi     # 0x7e24a
movl $0x143e, %edx           # imm = 0x143E
leaq 0x23240(%rip), %rcx     # 0x80643
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5d411
jmp 0x5d430
leaq 0x18bbb(%rip), %rdi     # 0x75fd3
leaq 0x20e2b(%rip), %rsi     # 0x7e24a
movl $0x143f, %edx           # imm = 0x143F
leaq 0x23218(%rip), %rcx     # 0x80643
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb00, (%rax)          # imm = 0xB00
jne 0x5d43e
jmp 0x5d45d
leaq 0x23187(%rip), %rdi     # 0x805cc
leaq 0x20dfe(%rip), %rsi     # 0x7e24a
movl $0x1440, %edx           # imm = 0x1440
leaq 0x231eb(%rip), %rcx     # 0x80643
callq 0x30a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x5d49c
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d5f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5d464
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: _func_process_label
static void __func_process_label(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *current
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STATS_BLOCK);
	assert(current);

	if (current->type == FE_NODE_STAT_LABEL) {
		parser_add_symbol_to_node(
			ctx,
			node,
			FE_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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d4cd
jmp 0x5d4ec
leaq 0x1f082(%rip), %rdi     # 0x7c556
leaq 0x20d6f(%rip), %rsi     # 0x7e24a
movl $0x14b3, %edx           # imm = 0x14B3
leaq 0x23107(%rip), %rcx     # 0x805ee
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5d4f5
jmp 0x5d514
leaq 0x18ad7(%rip), %rdi     # 0x75fd3
leaq 0x20d47(%rip), %rsi     # 0x7e24a
movl $0x14b4, %edx           # imm = 0x14B4
leaq 0x230df(%rip), %rcx     # 0x805ee
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb00, (%rax)          # imm = 0xB00
jne 0x5d522
jmp 0x5d541
leaq 0x230a3(%rip), %rdi     # 0x805cc
leaq 0x20d1a(%rip), %rsi     # 0x7e24a
movl $0x14b5, %edx           # imm = 0x14B5
leaq 0x230b2(%rip), %rcx     # 0x805ee
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5d54a
jmp 0x5d569
leaq 0x230ea(%rip), %rdi     # 0x8063b
leaq 0x20cf2(%rip), %rsi     # 0x7e24a
movl $0x14b6, %edx           # imm = 0x14B6
leaq 0x2308a(%rip), %rcx     # 0x805ee
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0xb90, (%rax)          # imm = 0xB90
jne 0x5d59e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movl $0x4, %edx
xorl %eax, %eax
movl %eax, %r9d
movq %r9, %r8
callq 0x83f0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x5d5e1
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5d4b0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5d5a5
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_var
static void _stat_var(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_VAR);

	_var(ctx, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d8c9
jmp 0x5d8e8
leaq 0x1ec86(%rip), %rdi     # 0x7c556
leaq 0x20973(%rip), %rsi     # 0x7e24a
movl $0x4c6, %edx            # imm = 0x4C6
leaq 0x22dc1(%rip), %rcx     # 0x806a4
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5d8f1
jmp 0x5d910
leaq 0x186db(%rip), %rdi     # 0x75fd3
leaq 0x2094b(%rip), %rsi     # 0x7e24a
movl $0x4c7, %edx            # imm = 0x4C7
leaq 0x22d99(%rip), %rcx     # 0x806a4
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xc00, (%rax)          # imm = 0xC00
jne 0x5d91e
jmp 0x5d93d
leaq 0x20eb1(%rip), %rdi     # 0x7e7d6
leaq 0x2091e(%rip), %rsi     # 0x7e24a
movl $0x4c8, %edx            # imm = 0x4C8
leaq 0x22d6c(%rip), %rcx     # 0x806a4
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4e0c0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_while
static void _stat_while(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_WHILE);
	assert(node->nchilds == 2);

	ParserASTNode *node_while_cond_expr = node->childs[0];
	_expr_wrapper(ctx, node_while_cond_expr);
	if (!_is_integer_type_node(ctx, node_while_cond_expr)
			&& !_is_pointer_type_node(ctx, node_while_cond_expr)) {
		_SYNERR_NODE(
			ctx,
			node,
			"statement 'while' condition expression requires integer type or pointer type."
		);
	}

	ParserASTNode *node_while_body = node->childs[1];
	_stats_block(ctx, node_while_body);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5dc6c
jmp 0x5dc8b
leaq 0x1e8e3(%rip), %rdi     # 0x7c556
leaq 0x205d0(%rip), %rsi     # 0x7e24a
movl $0x502, %edx            # imm = 0x502
leaq 0x22b5d(%rip), %rcx     # 0x807e3
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5dc94
jmp 0x5dcb3
leaq 0x18338(%rip), %rdi     # 0x75fd3
leaq 0x205a8(%rip), %rsi     # 0x7e24a
movl $0x503, %edx            # imm = 0x503
leaq 0x22b35(%rip), %rcx     # 0x807e3
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb20, (%rax)          # imm = 0xB20
jne 0x5dcc1
jmp 0x5dce0
leaq 0x22b4e(%rip), %rdi     # 0x80816
leaq 0x2057b(%rip), %rsi     # 0x7e24a
movl $0x504, %edx            # imm = 0x504
leaq 0x22b08(%rip), %rcx     # 0x807e3
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5dcec
jmp 0x5dd0b
leaq 0x20981(%rip), %rdi     # 0x7e674
leaq 0x20550(%rip), %rsi     # 0x7e24a
movl $0x505, %edx            # imm = 0x505
leaq 0x22add(%rip), %rcx     # 0x807e3
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f680
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x526c0
testb $0x1, %al
jne 0x5dd77
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52770
testb $0x1, %al
jne 0x5dd77
leaq -0x420(%rbp), %rdi
leaq 0x22ae0(%rip), %rsi     # 0x80837
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x428(%rbp)
movq -0x8(%rbp), %rdi
movq -0x428(%rbp), %rsi
callq 0x5d3d0
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_do
static void _stat_do(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_DO);
	assert(node->nchilds == 2);

	ParserASTNode *node_do_body = node->childs[0];
	_stats_block(ctx, node_do_body);

	ParserASTNode *node_do_cond_expr = node->childs[1];
	_expr_wrapper(ctx, node_do_cond_expr);
	if (!_is_integer_type_node(ctx, node_do_cond_expr)
			&& !_is_pointer_type_node(ctx, node_do_cond_expr)) {
		_SYNERR_NODE(
			ctx,
			node,
			"statement 'do...while' condition expression requires integer type or pointer type."
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ddcc
jmp 0x5ddeb
leaq 0x1e783(%rip), %rdi     # 0x7c556
leaq 0x20470(%rip), %rsi     # 0x7e24a
movl $0x51a, %edx            # imm = 0x51A
leaq 0x22a9f(%rip), %rcx     # 0x80885
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ddf4
jmp 0x5de13
leaq 0x181d8(%rip), %rdi     # 0x75fd3
leaq 0x20448(%rip), %rsi     # 0x7e24a
movl $0x51b, %edx            # imm = 0x51B
leaq 0x22a77(%rip), %rcx     # 0x80885
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb30, (%rax)          # imm = 0xB30
jne 0x5de21
jmp 0x5de40
leaq 0x22a8d(%rip), %rdi     # 0x808b5
leaq 0x2041b(%rip), %rsi     # 0x7e24a
movl $0x51c, %edx            # imm = 0x51C
leaq 0x22a4a(%rip), %rcx     # 0x80885
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5de4c
jmp 0x5de6b
leaq 0x20821(%rip), %rdi     # 0x7e674
leaq 0x203f0(%rip), %rsi     # 0x7e24a
movl $0x51d, %edx            # imm = 0x51D
leaq 0x22a1f(%rip), %rcx     # 0x80885
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d3d0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4f680
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x526c0
testb $0x1, %al
jne 0x5def4
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52770
testb $0x1, %al
jne 0x5def4
leaq -0x420(%rbp), %rdi
leaq 0x229ff(%rip), %rsi     # 0x808d3
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq *%rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_break
static void _stat_break(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_BREAK);
	assert(node->nchilds == 0);

	if (NULL == _search_node_along_parent(
		node->parent, FE_NODE_STAT_WHILE, FE_NODE_STAT_DO, FE_NODE_STAT_FOR, 0
	)) {
		_SYNERR_NODE(
			ctx,
			node,
			"statement 'break' must be use in loop."
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e26c
jmp 0x5e28b
leaq 0x1e2e3(%rip), %rdi     # 0x7c556
leaq 0x1ffd0(%rip), %rsi     # 0x7e24a
movl $0x58e, %edx            # imm = 0x58E
leaq 0x22730(%rip), %rcx     # 0x809b6
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5e294
jmp 0x5e2b3
leaq 0x17d38(%rip), %rdi     # 0x75fd3
leaq 0x1ffa8(%rip), %rsi     # 0x7e24a
movl $0x58f, %edx            # imm = 0x58F
leaq 0x22708(%rip), %rcx     # 0x809b6
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb60, (%rax)          # imm = 0xB60
jne 0x5e2c1
jmp 0x5e2e0
leaq 0x22721(%rip), %rdi     # 0x809e9
leaq 0x1ff7b(%rip), %rsi     # 0x7e24a
movl $0x590, %edx            # imm = 0x590
leaq 0x226db(%rip), %rcx     # 0x809b6
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x5e2ec
jmp 0x5e30b
leaq 0x2030c(%rip), %rdi     # 0x7e5ff
leaq 0x1ff50(%rip), %rsi     # 0x7e24a
movl $0x591, %edx            # imm = 0x591
leaq 0x226b0(%rip), %rcx     # 0x809b6
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0xb20, %esi            # imm = 0xB20
movl $0xb30, %edx            # imm = 0xB30
movl $0xb40, %ecx            # imm = 0xB40
xorl %r8d, %r8d
movb $0x0, %al
callq 0x5f190
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x5e364
leaq -0x410(%rbp), %rdi
leaq 0x226c6(%rip), %rsi     # 0x80a0a
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x410(%rbp), %rdx
callq *%rax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_continue
static void _stat_continue(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_CONTINUE);
	assert(node->nchilds == 0);

	if (NULL == _search_node_along_parent(
		node->parent, FE_NODE_STAT_WHILE, FE_NODE_STAT_DO, FE_NODE_STAT_FOR, 0
	)) {
		_SYNERR_NODE(
			ctx,
			node,
			"statement 'continue' must be use in loop."
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e38c
jmp 0x5e3ab
leaq 0x1e1c3(%rip), %rdi     # 0x7c556
leaq 0x1feb0(%rip), %rsi     # 0x7e24a
movl $0x5a2, %edx            # imm = 0x5A2
leaq 0x226ca(%rip), %rcx     # 0x80a70
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5e3b4
jmp 0x5e3d3
leaq 0x17c18(%rip), %rdi     # 0x75fd3
leaq 0x1fe88(%rip), %rsi     # 0x7e24a
movl $0x5a3, %edx            # imm = 0x5A3
leaq 0x226a2(%rip), %rcx     # 0x80a70
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb50, (%rax)          # imm = 0xB50
jne 0x5e3e1
jmp 0x5e400
leaq 0x226be(%rip), %rdi     # 0x80aa6
leaq 0x1fe5b(%rip), %rsi     # 0x7e24a
movl $0x5a4, %edx            # imm = 0x5A4
leaq 0x22675(%rip), %rcx     # 0x80a70
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x44(%rax)
jne 0x5e40c
jmp 0x5e42b
leaq 0x201ec(%rip), %rdi     # 0x7e5ff
leaq 0x1fe30(%rip), %rsi     # 0x7e24a
movl $0x5a5, %edx            # imm = 0x5A5
leaq 0x2264a(%rip), %rcx     # 0x80a70
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movl $0xb20, %esi            # imm = 0xB20
movl $0xb30, %edx            # imm = 0xB30
movl $0xb40, %ecx            # imm = 0xB40
xorl %r8d, %r8d
movb $0x0, %al
callq 0x5f190
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x5e484
leaq -0x410(%rbp), %rdi
leaq 0x22666(%rip), %rsi     # 0x80aca
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x410(%rbp), %rdx
callq *%rax
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_goto
static void _stat_goto(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_GOTO);
	assert(node->nchilds == 1);

	ParserASTNode *node_id = node->childs[0];
	assert(node_id->type == FE_NODE_IDENTIFIER);

	if (!parser_get_symbol_from_node(ctx, node, FE_SYM_LABEL, node_id->token)) {
		_SYNERR_TOKEN(
			ctx,
			node_id->token,
			"undefined label."
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e6e9
jmp 0x5e708
leaq 0x1de66(%rip), %rdi     # 0x7c556
leaq 0x1fb53(%rip), %rsi     # 0x7e24a
movl $0x5ee, %edx            # imm = 0x5EE
leaq 0x22510(%rip), %rcx     # 0x80c13
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5e711
jmp 0x5e730
leaq 0x178bb(%rip), %rdi     # 0x75fd3
leaq 0x1fb2b(%rip), %rsi     # 0x7e24a
movl $0x5ef, %edx            # imm = 0x5EF
leaq 0x224e8(%rip), %rcx     # 0x80c13
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb80, (%rax)          # imm = 0xB80
jne 0x5e73e
jmp 0x5e75d
leaq 0x22500(%rip), %rdi     # 0x80c45
leaq 0x1fafe(%rip), %rsi     # 0x7e24a
movl $0x5f0, %edx            # imm = 0x5F0
leaq 0x224bb(%rip), %rcx     # 0x80c13
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5e769
jmp 0x5e788
leaq 0x20980(%rip), %rdi     # 0x7f0f0
leaq 0x1fad3(%rip), %rsi     # 0x7e24a
movl $0x5f1, %edx            # imm = 0x5F1
leaq 0x22490(%rip), %rcx     # 0x80c13
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x5e7a5
jmp 0x5e7c4
leaq 0x15fe0(%rip), %rdi     # 0x7478c
leaq 0x1fa97(%rip), %rsi     # 0x7e24a
movl $0x5f4, %edx            # imm = 0x5F4
leaq 0x22454(%rip), %rcx     # 0x80c13
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x4, %edx
callq 0x82f0
cmpq $0x0, %rax
jne 0x5e801
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq 0x22466(%rip), %rdx     # 0x80c65
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_label
static void _stat_label(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_LABEL);
	assert(node->nchilds == 1);


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e829
jmp 0x5e848
leaq 0x1dd26(%rip), %rdi     # 0x7c556
leaq 0x1fa13(%rip), %rsi     # 0x7e24a
movl $0x603, %edx            # imm = 0x603
leaq 0x22433(%rip), %rcx     # 0x80c76
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5e851
jmp 0x5e870
leaq 0x1777b(%rip), %rdi     # 0x75fd3
leaq 0x1f9eb(%rip), %rsi     # 0x7e24a
movl $0x604, %edx            # imm = 0x604
leaq 0x2240b(%rip), %rcx     # 0x80c76
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb90, (%rax)          # imm = 0xB90
jne 0x5e87e
jmp 0x5e89d
leaq 0x22424(%rip), %rdi     # 0x80ca9
leaq 0x1f9be(%rip), %rsi     # 0x7e24a
movl $0x605, %edx            # imm = 0x605
leaq 0x223de(%rip), %rcx     # 0x80c76
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5e8a9
jmp 0x5e8c8
leaq 0x20840(%rip), %rdi     # 0x7f0f0
leaq 0x1f993(%rip), %rsi     # 0x7e24a
movl $0x606, %edx            # imm = 0x606
leaq 0x223b3(%rip), %rcx     # 0x80c76
callq 0x30a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_expr
static void _stat_expr(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_EXPR);

	_expr_wrapper(ctx, node);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ecc9
jmp 0x5ece8
leaq 0x1d886(%rip), %rdi     # 0x7c556
leaq 0x1f573(%rip), %rsi     # 0x7e24a
movl $0x13e0, %edx           # imm = 0x13E0
leaq 0x220bd(%rip), %rcx     # 0x80da0
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ecf1
jmp 0x5ed10
leaq 0x172db(%rip), %rdi     # 0x75fd3
leaq 0x1f54b(%rip), %rsi     # 0x7e24a
movl $0x13e1, %edx           # imm = 0x13E1
leaq 0x22095(%rip), %rcx     # 0x80da0
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xe00, (%rax)          # imm = 0xE00
jne 0x5ed1e
jmp 0x5ed3d
leaq 0x15f7f(%rip), %rdi     # 0x74ca4
leaq 0x1f51e(%rip), %rsi     # 0x7e24a
movl $0x13e2, %edx           # imm = 0x13E2
leaq 0x22068(%rip), %rcx     # 0x80da0
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4f680
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_dummy
static void _stat_dummy(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_DUMMY);

	// 什么也不干。
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ed69
jmp 0x5ed88
leaq 0x1d7e6(%rip), %rdi     # 0x7c556
leaq 0x1f4d3(%rip), %rsi     # 0x7e24a
movl $0x654, %edx            # imm = 0x654
leaq 0x2204f(%rip), %rcx     # 0x80dd2
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ed91
jmp 0x5edb0
leaq 0x1723b(%rip), %rdi     # 0x75fd3
leaq 0x1f4ab(%rip), %rsi     # 0x7e24a
movl $0x655, %edx            # imm = 0x655
leaq 0x22027(%rip), %rcx     # 0x80dd2
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbc0, (%rax)          # imm = 0xBC0
jne 0x5edbe
jmp 0x5eddd
leaq 0x22040(%rip), %rdi     # 0x80e05
leaq 0x1f47e(%rip), %rsi     # 0x7e24a
movl $0x656, %edx            # imm = 0x656
leaq 0x21ffa(%rip), %rcx     # 0x80dd2
callq 0x30a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_va_start
static void _stat_va_start(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_VA_START);
	assert(node->nchilds == 1);

	ParserASTNode *node_expr = node->childs[0];
	_expr_wrapper(ctx, node_expr);
	
	_check_va(ctx, node);

	if (FE_EXPR_AST_NODE_GET_TYPE(node_expr) != FE_TYPE_VA_LIST) {
		_SYNERR_NODE(ctx, node, "__va_start parameter type must be '__va_list'.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ee0c
jmp 0x5ee2b
leaq 0x1d743(%rip), %rdi     # 0x7c556
leaq 0x1f430(%rip), %rsi     # 0x7e24a
movl $0x69d, %edx            # imm = 0x69D
leaq 0x22000(%rip), %rcx     # 0x80e26
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ee34
jmp 0x5ee53
leaq 0x17198(%rip), %rdi     # 0x75fd3
leaq 0x1f408(%rip), %rsi     # 0x7e24a
movl $0x69e, %edx            # imm = 0x69E
leaq 0x21fd8(%rip), %rcx     # 0x80e26
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd0, (%rax)          # imm = 0xBD0
jne 0x5ee61
jmp 0x5ee80
leaq 0x17d7a(%rip), %rdi     # 0x76be2
leaq 0x1f3db(%rip), %rsi     # 0x7e24a
movl $0x69f, %edx            # imm = 0x69F
leaq 0x21fab(%rip), %rcx     # 0x80e26
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5ee8c
jmp 0x5eeab
leaq 0x2025d(%rip), %rdi     # 0x7f0f0
leaq 0x1f3b0(%rip), %rsi     # 0x7e24a
movl $0x6a0, %edx            # imm = 0x6A0
leaq 0x21f80(%rip), %rcx     # 0x80e26
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f680
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5f250
movq -0x18(%rbp), %rax
movzbl 0x60(%rax), %eax
cmpl $0xc, %eax
je 0x5ef0f
leaq -0x420(%rbp), %rdi
leaq 0x21f6d(%rip), %rsi     # 0x80e5c
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq *%rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_va_end
static void _stat_va_end(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_VA_END);
	assert(node->nchilds == 1);

	ParserASTNode *node_expr = node->childs[0];
	_expr_wrapper(ctx, node_expr);

	if (FE_EXPR_AST_NODE_GET_TYPE(node_expr) != FE_TYPE_VA_LIST) {
		_SYNERR_NODE(ctx, node, "__va_end parameter type must be '__va_list'.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ef3c
jmp 0x5ef5b
leaq 0x1d613(%rip), %rdi     # 0x7c556
leaq 0x1f300(%rip), %rsi     # 0x7e24a
movl $0x6b0, %edx            # imm = 0x6B0
leaq 0x22099(%rip), %rcx     # 0x80fef
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ef64
jmp 0x5ef83
leaq 0x17068(%rip), %rdi     # 0x75fd3
leaq 0x1f2d8(%rip), %rsi     # 0x7e24a
movl $0x6b1, %edx            # imm = 0x6B1
leaq 0x22071(%rip), %rcx     # 0x80fef
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd1, (%rax)          # imm = 0xBD1
jne 0x5ef91
jmp 0x5efb0
leaq 0x17cba(%rip), %rdi     # 0x76c52
leaq 0x1f2ab(%rip), %rsi     # 0x7e24a
movl $0x6b2, %edx            # imm = 0x6B2
leaq 0x22044(%rip), %rcx     # 0x80fef
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5efbc
jmp 0x5efdb
leaq 0x2012d(%rip), %rdi     # 0x7f0f0
leaq 0x1f280(%rip), %rsi     # 0x7e24a
movl $0x6b3, %edx            # imm = 0x6B3
leaq 0x22019(%rip), %rcx     # 0x80fef
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f680
movq -0x18(%rbp), %rax
movzbl 0x60(%rax), %eax
cmpl $0xc, %eax
je 0x5f032
leaq -0x420(%rbp), %rdi
leaq 0x22011(%rip), %rsi     # 0x81023
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq *%rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_va_copy
static void _stat_va_copy(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_VA_COPY);
	assert(node->nchilds == 2);

	ParserASTNode *node_expr_target = node->childs[0];
	_expr_wrapper(ctx, node_expr_target);

	ParserASTNode *node_expr_source = node->childs[1];
	_expr_wrapper(ctx, node_expr_source);

	if (FE_EXPR_AST_NODE_GET_TYPE(node_expr_target) != FE_TYPE_VA_LIST
			|| FE_EXPR_AST_NODE_GET_TYPE(node_expr_source) != FE_TYPE_VA_LIST) {
		_SYNERR_NODE(ctx, node, "__va_end first parameter type and second parameter type must be '__va_list'.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5f05c
jmp 0x5f07b
leaq 0x1d4f3(%rip), %rdi     # 0x7c556
leaq 0x1f1e0(%rip), %rsi     # 0x7e24a
movl $0x6c1, %edx            # imm = 0x6C1
leaq 0x21fda(%rip), %rcx     # 0x81050
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5f084
jmp 0x5f0a3
leaq 0x16f48(%rip), %rdi     # 0x75fd3
leaq 0x1f1b8(%rip), %rsi     # 0x7e24a
movl $0x6c2, %edx            # imm = 0x6C2
leaq 0x21fb2(%rip), %rcx     # 0x81050
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd2, (%rax)          # imm = 0xBD2
jne 0x5f0b1
jmp 0x5f0d0
leaq 0x17c07(%rip), %rdi     # 0x76cbf
leaq 0x1f18b(%rip), %rsi     # 0x7e24a
movl $0x6c3, %edx            # imm = 0x6C3
leaq 0x21f85(%rip), %rcx     # 0x81050
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5f0dc
jmp 0x5f0fb
leaq 0x1f591(%rip), %rdi     # 0x7e674
leaq 0x1f160(%rip), %rsi     # 0x7e24a
movl $0x6c4, %edx            # imm = 0x6C4
leaq 0x21f5a(%rip), %rcx     # 0x81050
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4f680
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4f680
movq -0x18(%rbp), %rax
movzbl 0x60(%rax), %eax
cmpl $0xc, %eax
jne 0x5f14e
movq -0x20(%rbp), %rax
movzbl 0x60(%rax), %eax
cmpl $0xc, %eax
je 0x5f17c
leaq -0x420(%rbp), %rdi
leaq 0x21f29(%rip), %rsi     # 0x81085
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq *%rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: search_node_along_parent
static ParserASTNode * _search_node_along_parent(
	ParserASTNode *node,
	...
) {
	assert(node);

	va_list arg_ptr;
	va_start(arg_ptr, node);
	
	return __search_node_along_parent(node, arg_ptr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
testb %al, %al
je 0x5f1c5
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0xb0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rsi, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5f1f5
jmp 0x5f214
leaq 0x16dd7(%rip), %rdi     # 0x75fd3
leaq 0x1f047(%rip), %rsi     # 0x7e24a
movl $0x582, %edx            # imm = 0x582
leaq 0x21822(%rip), %rcx     # 0x80a31
callq 0x30a0
leaq -0xd0(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x30, -0x1c(%rbp)
movl $0x8, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4da00
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_void_type
static bool _is_compatible_void_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	uint8_t target_type = _get_type_by_type_node(ctx, target);
	uint8_t source_type = _get_type_by_type_node(ctx, source);
	return target_type == FE_TYPE_VOID
			&& source_type == FE_TYPE_VOID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5f474
jmp 0x5f493
leaq 0x1d0db(%rip), %rdi     # 0x7c556
leaq 0x1edc8(%rip), %rsi     # 0x7e24a
movl $0x22c, %edx            # imm = 0x22C
leaq 0x21de1(%rip), %rcx     # 0x8126f
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5f49c
jmp 0x5f4bb
leaq 0x1c27f(%rip), %rdi     # 0x7b722
leaq 0x1eda0(%rip), %rsi     # 0x7e24a
movl $0x22d, %edx            # imm = 0x22D
leaq 0x21db9(%rip), %rcx     # 0x8126f
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5f4c4
jmp 0x5f4e3
leaq 0x120c6(%rip), %rdi     # 0x71591
leaq 0x1ed78(%rip), %rsi     # 0x7e24a
movl $0x22e, %edx            # imm = 0x22E
leaq 0x21d91(%rip), %rcx     # 0x8126f
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4d750
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d750
movb %al, -0x1b(%rbp)
movzbl -0x1a(%rbp), %ecx
xorl %eax, %eax
cmpl $0xff, %ecx
movb %al, -0x1c(%rbp)
jne 0x5f523
movzbl -0x1b(%rbp), %eax
cmpl $0xff, %eax
sete %al
movb %al, -0x1c(%rbp)
movb -0x1c(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_array_type
static bool _is_compatible_array_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_get_type_by_type_node(ctx, target) == FE_TYPE_ARRAY
			&& _get_type_by_type_node(ctx, source) == FE_TYPE_ARRAY) {
		ParserASTNode *target_dims = target->childs[0];
		ParserASTNode *target_type = target->childs[1];
		ParserASTNode *source_dims = source->childs[0];
		ParserASTNode *source_type = source->childs[1];

		return _is_compatible_array_type_dims(ctx, target_dims, source_dims)
				&& _is_compatible_type(ctx, target_type, source_type, same);
	} else {
		return false;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5f554
jmp 0x5f573
leaq 0x1cffb(%rip), %rdi     # 0x7c556
leaq 0x1ece8(%rip), %rsi     # 0x7e24a
movl $0x285, %edx            # imm = 0x285
leaq 0x21d5a(%rip), %rcx     # 0x812c8
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5f57c
jmp 0x5f59b
leaq 0x1c19f(%rip), %rdi     # 0x7b722
leaq 0x1ecc0(%rip), %rsi     # 0x7e24a
movl $0x286, %edx            # imm = 0x286
leaq 0x21d32(%rip), %rcx     # 0x812c8
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5f5a4
jmp 0x5f5c3
leaq 0x11fe6(%rip), %rdi     # 0x71591
leaq 0x1ec98(%rip), %rsi     # 0x7e24a
movl $0x287, %edx            # imm = 0x287
leaq 0x21d0a(%rip), %rcx     # 0x812c8
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0xe, %eax
jne 0x5f678
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4d750
movzbl %al, %eax
cmpl $0xe, %eax
jne 0x5f678
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x5f770
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x5f652
jmp 0x5f66e
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x4d570
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5f67c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)