LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_store
static void _stat_store(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_STORE);
	assert(node->nchilds == 2);

	ParserASTNode *node_target = node->childs[0];
	_GetParamInfoResult result_target;
	_get_param_info(ctx, node_target, &result_target);

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

	if (!_is_pointer_type(result_target.type)) {
		_SYNERR_NODE(ctx, node_target, "target parameter type must be pointer type.");
	}

	_check_param_combination2(
		ctx,
		node,
		result_target.node_type->childs[0],
		result_source.node_type
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5c9dc
jmp 0x5c9fb
leaq 0x2377e(%rip), %rdi     # 0x80161
leaq 0x25e96(%rip), %rsi     # 0x82880
movl $0x1194, %edx           # imm = 0x1194
leaq 0x286b5(%rip), %rcx     # 0x850ab
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ca04
jmp 0x5ca23
leaq 0x19b51(%rip), %rdi     # 0x7655c
leaq 0x25e6e(%rip), %rsi     # 0x82880
movl $0x1195, %edx           # imm = 0x1195
leaq 0x2868d(%rip), %rcx     # 0x850ab
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb80, (%rax)          # imm = 0xB80
jne 0x5ca31
jmp 0x5ca50
leaq 0x1abb4(%rip), %rdi     # 0x775ec
leaq 0x25e41(%rip), %rsi     # 0x82880
movl $0x1196, %edx           # imm = 0x1196
leaq 0x28660(%rip), %rcx     # 0x850ab
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5ca5c
jmp 0x5ca7b
leaq 0x262e1(%rip), %rdi     # 0x82d44
leaq 0x25e16(%rip), %rsi     # 0x82880
movl $0x1197, %edx           # imm = 0x1197
leaq 0x28635(%rip), %rcx     # 0x850ab
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
leaq -0x28(%rbp), %rdx
callq 0x5efc0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x5efc0
movzbl -0x20(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5caf7
leaq -0x440(%rbp), %rdi
leaq 0x285a8(%rip), %rsi     # 0x8507f
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x440(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdx
movq -0x40(%rbp), %rcx
callq 0x5f150
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_load
static void _stat_load(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_LOAD);
	assert(node->nchilds == 2);

	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);

	if (!_is_pointer_type(result_source.type)) {
		_SYNERR_NODE(ctx, node_source, "source parameter type must be pointer type.");
	}

	_check_param_combination2(
		ctx,
		node,
		node_type_target,
		result_source.node_type->childs[0]
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5cb3c
jmp 0x5cb5b
leaq 0x2361e(%rip), %rdi     # 0x80161
leaq 0x25d36(%rip), %rsi     # 0x82880
movl $0x11b1, %edx           # imm = 0x11B1
leaq 0x28588(%rip), %rcx     # 0x850de
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5cb64
jmp 0x5cb83
leaq 0x199f1(%rip), %rdi     # 0x7655c
leaq 0x25d0e(%rip), %rsi     # 0x82880
movl $0x11b2, %edx           # imm = 0x11B2
leaq 0x28560(%rip), %rcx     # 0x850de
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb81, (%rax)          # imm = 0xB81
jne 0x5cb91
jmp 0x5cbb0
leaq 0x1aad5(%rip), %rdi     # 0x7766d
leaq 0x25ce1(%rip), %rsi     # 0x82880
movl $0x11b3, %edx           # imm = 0x11B3
leaq 0x28533(%rip), %rcx     # 0x850de
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5cbbc
jmp 0x5cbdb
leaq 0x26181(%rip), %rdi     # 0x82d44
leaq 0x25cb6(%rip), %rsi     # 0x82880
movl $0x11b4, %edx           # imm = 0x11B4
leaq 0x28508(%rip), %rcx     # 0x850de
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 0x5cbf8
jmp 0x5cc17
leaq 0x197be(%rip), %rdi     # 0x763bd
leaq 0x25c7a(%rip), %rsi     # 0x82880
movl $0x11b7, %edx           # imm = 0x11B7
leaq 0x284cc(%rip), %rcx     # 0x850de
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5edc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x5efc0
movzbl -0x38(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5cc90
leaq -0x440(%rbp), %rdi
leaq 0x284a0(%rip), %rsi     # 0x85110
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x440(%rbp), %rdx
callq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rcx
callq 0x5f150
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_trunc
static void _stat_trunc(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_TRUNC, &check_result);

	if (!_is_integer_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be integer type.");
	}
	if (!_is_integer_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be integer type.");
	}

	if (!(check_result.size_source > check_result.size_target)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter size must be larger than target parameter size.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc50, %rsp            # imm = 0xC50
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc0, %edx            # imm = 0xBC0
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5cd24
leaq -0x450(%rbp), %rdi
leaq 0x28438(%rip), %rsi     # 0x8513c
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5cd5f
leaq -0x850(%rbp), %rdi
leaq 0x28429(%rip), %rsi     # 0x85168
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
ja 0x5cd97
leaq -0xc50(%rbp), %rdi
leaq 0x2841d(%rip), %rsi     # 0x85194
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0xc50(%rbp), %rdx
callq *%rax
addq $0xc50, %rsp            # imm = 0xC50
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_sext
static void _stat_sext(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_SEXT, &check_result);

	if (!_is_integer_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be integer type.");
	}
	if (!_is_integer_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be integer type.");
	}

	if (!(check_result.size_source < check_result.size_target)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter size must be smaller than target parameter size.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc50, %rsp            # imm = 0xC50
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc1, %edx            # imm = 0xBC1
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5ce04
leaq -0x450(%rbp), %rdi
leaq 0x28358(%rip), %rsi     # 0x8513c
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5ce3f
leaq -0x850(%rbp), %rdi
leaq 0x28349(%rip), %rsi     # 0x85168
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x5ce77
leaq -0xc50(%rbp), %rdi
leaq 0x283f1(%rip), %rsi     # 0x85248
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0xc50(%rbp), %rdx
callq *%rax
addq $0xc50, %rsp            # imm = 0xC50
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_sitofp
static void _stat_sitofp(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_SITOFP, &check_result);

	if (!_is_float_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be float type.");
	}
	if (!_is_signed_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be signed integer type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc2, %edx            # imm = 0xBC2
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daf0
testb $0x1, %al
jne 0x5cee4
leaq -0x450(%rbp), %rdi
leaq 0x283c6(%rip), %rsi     # 0x8528a
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4da00
testb $0x1, %al
jne 0x5cf1f
leaq -0x850(%rbp), %rdi
leaq 0x283b5(%rip), %rsi     # 0x852b4
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_inttoptr
static void _stat_inttoptr(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_INTTOPTR, &check_result);

	if (!_is_pointer_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be pointer type.");
	}
	if (!_is_integer_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be integer type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc3, %edx            # imm = 0xBC3
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5cf94
leaq -0x450(%rbp), %rdi
leaq 0x2810b(%rip), %rsi     # 0x8507f
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5cfcf
leaq -0x850(%rbp), %rdi
leaq 0x281b9(%rip), %rsi     # 0x85168
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_zext
static void _stat_zext(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_ZEXT, &check_result);

	if (!_is_integer_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be integer type.");
	}
	if (!_is_integer_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be integer type.");
	}

	if (!(check_result.size_source < check_result.size_target)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter size must be smaller than target parameter size.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc50, %rsp            # imm = 0xC50
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc4, %edx            # imm = 0xBC4
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5d044
leaq -0x450(%rbp), %rdi
leaq 0x28118(%rip), %rsi     # 0x8513c
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5d07f
leaq -0x850(%rbp), %rdi
leaq 0x28109(%rip), %rsi     # 0x85168
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
movq -0x18(%rbp), %rax
cmpq -0x38(%rbp), %rax
jb 0x5d0b7
leaq -0xc50(%rbp), %rdi
leaq 0x281b1(%rip), %rsi     # 0x85248
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0xc50(%rbp), %rdx
callq *%rax
addq $0xc50, %rsp            # imm = 0xC50
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_uitofp
static void _stat_uitofp(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_UITOFP, &check_result);

	if (!_is_float_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be float type.");
	}
	if (!_is_unsigned_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be unsigned integer type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc5, %edx            # imm = 0xBC5
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daf0
testb $0x1, %al
jne 0x5d124
leaq -0x450(%rbp), %rdi
leaq 0x28186(%rip), %rsi     # 0x8528a
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4da50
testb $0x1, %al
jne 0x5d15f
leaq -0x850(%rbp), %rdi
leaq 0x281a8(%rip), %rsi     # 0x852e7
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_fptosi
static void _stat_fptosi(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_FPTOSI, &check_result);

	if (!_is_signed_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be signed integer type.");
	}
	if (!_is_float_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be float type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc6, %edx            # imm = 0xBC6
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4da00
testb $0x1, %al
jne 0x5d1d4
leaq -0x450(%rbp), %rdi
leaq 0x28168(%rip), %rsi     # 0x8531c
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4daf0
testb $0x1, %al
jne 0x5d20f
leaq -0x850(%rbp), %rdi
leaq 0x28160(%rip), %rsi     # 0x8534f
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_fptoui
static void _stat_fptoui(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_FPTOUI, &check_result);

	if (!_is_unsigned_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be unsigned integer type.");
	}
	if (!_is_float_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be float type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc7, %edx            # imm = 0xBC7
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4da50
testb $0x1, %al
jne 0x5d284
leaq -0x450(%rbp), %rdi
leaq 0x28115(%rip), %rsi     # 0x85379
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4daf0
testb $0x1, %al
jne 0x5d2bf
leaq -0x850(%rbp), %rdi
leaq 0x280b0(%rip), %rsi     # 0x8534f
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_fpext
static void _stat_fpext(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_FPEXT, &check_result);

	if (check_result.type_target != BE_TYPE_DOUBLE) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be double type.");
	}
	if (check_result.type_source != BE_TYPE_FLOAT) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be float type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc8, %edx            # imm = 0xBC8
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %eax
cmpl $0xb, %eax
je 0x5d330
leaq -0x450(%rbp), %rdi
leaq 0x2809e(%rip), %rsi     # 0x853ae
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %eax
cmpl $0xa, %eax
je 0x5d367
leaq -0x850(%rbp), %rdi
leaq 0x28008(%rip), %rsi     # 0x8534f
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_fptrunc
static void _stat_fptrunc(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_FPTRUNC, &check_result);

	if (check_result.type_target != BE_TYPE_FLOAT) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be float type.");
	}
	if (check_result.type_source != BE_TYPE_DOUBLE) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be double type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbc9, %edx            # imm = 0xBC9
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %eax
cmpl $0xa, %eax
je 0x5d3d0
leaq -0x450(%rbp), %rdi
leaq 0x27eda(%rip), %rsi     # 0x8528a
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %eax
cmpl $0xb, %eax
je 0x5d407
leaq -0x850(%rbp), %rdi
leaq 0x27ff2(%rip), %rsi     # 0x853d9
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_ptrtoint
static void _stat_ptrtoint(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_PTRTOINT, &check_result);

	if (!_is_integer_type(check_result.type_target)) {
		_SYNERR_NODE(ctx, check_result.node_target, "target parameter type must be integer type.");
	}
	if (!_is_pointer_type(check_result.type_source)) {
		_SYNERR_NODE(ctx, check_result.node_source, "source parameter type must be pointer type.");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x850, %rsp            # imm = 0x850
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbca, %edx            # imm = 0xBCA
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5d474
leaq -0x450(%rbp), %rdi
leaq 0x27ce8(%rip), %rsi     # 0x8513c
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5d4af
leaq -0x850(%rbp), %rdi
leaq 0x27c81(%rip), %rsi     # 0x85110
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
addq $0x850, %rsp            # imm = 0x850
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_bitcast
static void _stat_bitcast(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_BITCAST, &check_result);

	if (!_is_primitive_type(check_result.type_target)
			&& !_is_pointer_type(check_result.type_target)) {
		_SYNERR_NODE(
			ctx,
			check_result.node_target,
			"target parameter type must be primitive type or pointer type."
		);
	}
	if (!_is_primitive_type(check_result.type_source)
			&& !_is_pointer_type(check_result.type_source)) {
		_SYNERR_NODE(
			ctx,
			check_result.node_target,
			"source parameter type must be primitive type or pointer type."
		);
	}
	if (check_result.size_target != check_result.size_source) {
		_SYNERR_NODE(
			ctx,
			check_result.node_target,
			"target parameter size and source parameter size must be same."
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc50, %rsp            # imm = 0xC50
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbcb, %edx            # imm = 0xBCB
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4db40
testb $0x1, %al
jne 0x5d531
movzbl -0x40(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5d531
leaq -0x450(%rbp), %rdi
leaq 0x27899(%rip), %rsi     # 0x84daa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
movzbl -0x20(%rbp), %edi
callq 0x4db40
testb $0x1, %al
jne 0x5d579
movzbl -0x20(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5d579
leaq -0x850(%rbp), %rdi
leaq 0x277da(%rip), %rsi     # 0x84d33
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x850(%rbp), %rdx
callq *%rax
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0x5d5b1
leaq -0xc50(%rbp), %rdi
leaq 0x27e73(%rip), %rsi     # 0x85404
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0xc50(%rbp), %rdx
callq *%rax
addq $0xc50, %rsp            # imm = 0xC50
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_vcall
static void _stat_vcall(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_VCALL);
	assert(node->nchilds == 1);

	ParserASTNode *node_func_call = node->childs[0];
	ParserASTNode *node_ret_type = _stat_func_call(ctx, node_func_call);
	assert(node_ret_type);
	if (node_ret_type->type != BE_NODE_TYPE_VOID) {
		_SYNERR_NODE(
			ctx,
			node,
			"function have return value, maybe need to use 'call'."
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d5dc
jmp 0x5d5fb
leaq 0x22b7e(%rip), %rdi     # 0x80161
leaq 0x25296(%rip), %rsi     # 0x82880
movl $0x1376, %edx           # imm = 0x1376
leaq 0x27e4c(%rip), %rcx     # 0x85442
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5d604
jmp 0x5d623
leaq 0x18f51(%rip), %rdi     # 0x7655c
leaq 0x2526e(%rip), %rsi     # 0x82880
movl $0x1377, %edx           # imm = 0x1377
leaq 0x27e24(%rip), %rcx     # 0x85442
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd1, (%rax)          # imm = 0xBD1
jne 0x5d631
jmp 0x5d650
leaq 0x1b1c0(%rip), %rdi     # 0x787f8
leaq 0x25241(%rip), %rsi     # 0x82880
movl $0x1378, %edx           # imm = 0x1378
leaq 0x27df7(%rip), %rcx     # 0x85442
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5d65c
jmp 0x5d67b
leaq 0x19dab(%rip), %rdi     # 0x7740e
leaq 0x25216(%rip), %rsi     # 0x82880
movl $0x1379, %edx           # imm = 0x1379
leaq 0x27dcc(%rip), %rcx     # 0x85442
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 0x5f850
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5d6a4
jmp 0x5d6c3
leaq 0x27dca(%rip), %rdi     # 0x85475
leaq 0x251ce(%rip), %rsi     # 0x82880
movl $0x137d, %edx           # imm = 0x137D
leaq 0x27d84(%rip), %rcx     # 0x85442
callq 0x30a0
movq -0x20(%rbp), %rax
cmpl $0x4ff, (%rax)          # imm = 0x4FF
je 0x5d6fd
leaq -0x420(%rbp), %rdi
leaq 0x27da6(%rip), %rsi     # 0x85483
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/backend/semantics.c
// Function: stat_call
static void _stat_call(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_CALL);
	assert(node->nchilds == 2);

	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_func_call = node->childs[1];
	ParserASTNode *node_ret_type = _stat_func_call(ctx, node_func_call);

	_check_param_combination2(
		ctx,
		node,
		node_type_target,
		node_ret_type
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5d729
jmp 0x5d748
leaq 0x22a31(%rip), %rdi     # 0x80161
leaq 0x25149(%rip), %rsi     # 0x82880
movl $0x138b, %edx           # imm = 0x138B
leaq 0x27f1d(%rip), %rcx     # 0x85660
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5d751
jmp 0x5d770
leaq 0x18e04(%rip), %rdi     # 0x7655c
leaq 0x25121(%rip), %rsi     # 0x82880
movl $0x138c, %edx           # imm = 0x138C
leaq 0x27ef5(%rip), %rcx     # 0x85660
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xbd0, (%rax)          # imm = 0xBD0
jne 0x5d77e
jmp 0x5d79d
leaq 0x1b223(%rip), %rdi     # 0x789a8
leaq 0x250f4(%rip), %rsi     # 0x82880
movl $0x138d, %edx           # imm = 0x138D
leaq 0x27ec8(%rip), %rcx     # 0x85660
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5d7a9
jmp 0x5d7c8
leaq 0x25594(%rip), %rdi     # 0x82d44
leaq 0x250c9(%rip), %rsi     # 0x82880
movl $0x138e, %edx           # imm = 0x138E
leaq 0x27e9d(%rip), %rcx     # 0x85660
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 0x5d7e5
jmp 0x5d804
leaq 0x18bd1(%rip), %rdi     # 0x763bd
leaq 0x2508d(%rip), %rsi     # 0x82880
movl $0x1391, %edx           # imm = 0x1391
leaq 0x27e61(%rip), %rcx     # 0x85660
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5edc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x5f850
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x5f150
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_add
static void _stat_add(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_ADD, &check_result);

	if (_is_pointer_type(check_result.type_target)
			&& _is_pointer_type(check_result.type_source_left)
			&& _is_integer_type(check_result.type_source_right)) {
		goto ok;
	}

	if (_is_number_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source_left
			&& check_result.type_target == check_result.type_source_right) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe0, %edx            # imm = 0xBE0
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5d898
jmp 0x5d8b8
movzbl -0x40(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5d8a7
jmp 0x5d8b8
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5d8b6
jmp 0x5d8b8
jmp 0x5d90f
movzbl -0x60(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5d8c7
jmp 0x5d8e1
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5d8e1
movzbl -0x60(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5d8e1
jmp 0x5d90f
leaq -0x470(%rbp), %rdi
leaq 0x273bb(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_sub
static void _stat_sub(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_SUB, &check_result);

	if (_is_pointer_type(check_result.type_target)
			&& _is_pointer_type(check_result.type_source_left)
			&& _is_integer_type(check_result.type_source_right)) {
		goto ok;
	}

	if (_is_number_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source_left
			&& check_result.type_target == check_result.type_source_right) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe1, %edx            # imm = 0xBE1
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5d958
jmp 0x5d978
movzbl -0x40(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5d967
jmp 0x5d978
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5d976
jmp 0x5d978
jmp 0x5d9cf
movzbl -0x60(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5d987
jmp 0x5d9a1
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5d9a1
movzbl -0x60(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5d9a1
jmp 0x5d9cf
leaq -0x470(%rbp), %rdi
leaq 0x272fb(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_mul
static void _stat_mul(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_MUL, &check_result);

	if (_is_number_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source_left
			&& check_result.type_target == check_result.type_source_right) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe2, %edx            # imm = 0xBE2
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5da18
jmp 0x5da32
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5da32
movzbl -0x60(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5da32
jmp 0x5da60
leaq -0x470(%rbp), %rdi
leaq 0x2726a(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_div
static void _stat_div(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_DIV, &check_result);

	if (_is_number_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source_left
			&& check_result.type_target == check_result.type_source_right) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe3, %edx            # imm = 0xBE3
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5daa8
jmp 0x5dac2
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5dac2
movzbl -0x60(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5dac2
jmp 0x5daf0
leaq -0x470(%rbp), %rdi
leaq 0x271da(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_rem
static void _stat_rem(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_REM, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source_left
			&& check_result.type_target == check_result.type_source_right) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe4, %edx            # imm = 0xBE4
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5db38
jmp 0x5db52
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5db52
movzbl -0x60(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5db52
jmp 0x5db80
leaq -0x470(%rbp), %rdi
leaq 0x2714a(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_idx
static void _stat_idx(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_IDX, &check_result);

	if (_is_pointer_type(check_result.type_target)
			&& _is_pointer_type(check_result.type_source_left)
			&& check_result.node_type_source_left->childs[0]->type == BE_NODE_TYPE_ARRAY
			&& _check_stat_idx_params(ctx, node, &check_result)
			&& _is_integer_type(check_result.type_source_right)
	) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe6, %edx            # imm = 0xBE6
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5de18
jmp 0x5de62
movzbl -0x40(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5de27
jmp 0x5de62
movq -0x48(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
cmpl $0x420, (%rax)          # imm = 0x420
jne 0x5de62
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x60040
testb $0x1, %al
jne 0x5de51
jmp 0x5de62
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5de60
jmp 0x5de62
jmp 0x5de90
leaq -0x470(%rbp), %rdi
leaq 0x26e3a(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_not
static void _stat_not(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_NOT, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe7, %edx            # imm = 0xBE7
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5ded8
jmp 0x5dee6
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5dee6
jmp 0x5df14
leaq -0x450(%rbp), %rdi
leaq 0x26db6(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_neg
static void _stat_neg(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_NEG, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe8, %edx            # imm = 0xBE8
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5df58
jmp 0x5df66
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5df66
jmp 0x5df94
leaq -0x450(%rbp), %rdi
leaq 0x26d36(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_bnot
static void _stat_bnot(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI check_result;
	_check_stat_i_ci(ctx, node, BE_NODE_STAT_BNOT, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbe9, %edx            # imm = 0xBE9
leaq -0x50(%rbp), %rcx
callq 0x5f660
movzbl -0x40(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5dfd8
jmp 0x5dfe6
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5dfe6
jmp 0x5e014
leaq -0x450(%rbp), %rdi
leaq 0x26cb6(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x450(%rbp), %rdx
callq *%rax
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_shl
static void _stat_shl(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_SHL, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source_left
			&& _is_integer_type(check_result.type_source_right)) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbeb, %edx            # imm = 0xBEB
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e058
jmp 0x5e075
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e075
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e073
jmp 0x5e075
jmp 0x5e0a3
leaq -0x470(%rbp), %rdi
leaq 0x26c27(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_shr
static void _stat_shr(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_SHR, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& check_result.type_target == check_result.type_source_left
			&& _is_integer_type(check_result.type_source_right)) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbec, %edx            # imm = 0xBEC
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e0e8
jmp 0x5e105
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e105
movzbl -0x20(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e103
jmp 0x5e105
jmp 0x5e133
leaq -0x470(%rbp), %rdi
leaq 0x26b97(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_eq
static void _stat_eq(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_EQ, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& (_is_number_type(check_result.type_source_left) || _is_pointer_type(check_result.type_source_left))
			&& check_result.type_source_left == check_result.type_source_right) {
		goto ok;
	}

	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);

ok:
	return;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x470, %rsp            # imm = 0x470
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0xbed, %edx            # imm = 0xBED
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e178
jmp 0x5e1a2
movzbl -0x40(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5e194
movzbl -0x40(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5e194
jmp 0x5e1a2
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e1a2
jmp 0x5e1d0
leaq -0x470(%rbp), %rdi
leaq 0x26afa(%rip), %rsi     # 0x84caa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x470(%rbp), %rdx
callq *%rax
addq $0x470, %rsp            # imm = 0x470
popq %rbp
retq
nopl (%rax)