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

	return _get_primitive_type_weight(
		BE_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 0x50e59
jmp 0x50e78
leaq 0x2f301(%rip), %rdi     # 0x80161
leaq 0x31a19(%rip), %rsi     # 0x82880
movl $0x163, %edx            # imm = 0x163
leaq 0x33560(%rip), %rcx     # 0x843d3
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x50e81
jmp 0x50ea0
leaq 0x256d4(%rip), %rdi     # 0x7655c
leaq 0x319f1(%rip), %rsi     # 0x82880
movl $0x164, %edx            # imm = 0x164
leaq 0x33538(%rip), %rcx     # 0x843d3
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x5a290
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: expr_bor
static void _expr_bor(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

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

	uint32_t node_type = node->type;

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

			const char *operator = "|";

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

			BE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (BE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_bxor(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 0x53399
jmp 0x533b8
leaq 0x2cdc1(%rip), %rdi     # 0x80161
leaq 0x2f4d9(%rip), %rsi     # 0x82880
movl $0xd73, %edx            # imm = 0xD73
leaq 0x2fd8c(%rip), %rcx     # 0x8313f
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x533c1
jmp 0x533e0
leaq 0x23194(%rip), %rdi     # 0x7655c
leaq 0x2f4b1(%rip), %rsi     # 0x82880
movl $0xd74, %edx            # imm = 0xD74
leaq 0x2fd64(%rip), %rcx     # 0x8313f
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0xe40, %eax            # imm = 0xE40
jne 0x534d1
jmp 0x533f9
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x53405
jmp 0x53424
leaq 0x2f938(%rip), %rdi     # 0x82d44
leaq 0x2f46d(%rip), %rsi     # 0x82880
movl $0xd7f, %edx            # imm = 0xD7F
leaq 0x2fd20(%rip), %rcx     # 0x8313f
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 0x534f0
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x534f0
leaq 0x2bba3(%rip), %rax     # 0x7f007
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 0x53660
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x70(%rcx)
movb %al, -0x31(%rbp)
je 0x534a0
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 0x534cf
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x513e0
jmp 0x534de
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x534f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: expr_bxor
static void _expr_bxor(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

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

	uint32_t node_type = node->type;

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

			const char *operator = "^";

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

			BE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (BE_EXPR_AST_NODE_GET_CONSTANT(node)) {
				_calc_binary_constexpr(ctx, node_type, node, node_oprd1, node_oprd2);
			}
			break;
		}
		default: {
			_expr_band(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 0x53509
jmp 0x53528
leaq 0x2cc51(%rip), %rdi     # 0x80161
leaq 0x2f369(%rip), %rsi     # 0x82880
movl $0xd25, %edx            # imm = 0xD25
leaq 0x2fc4d(%rip), %rcx     # 0x83170
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x53531
jmp 0x53550
leaq 0x23024(%rip), %rdi     # 0x7655c
leaq 0x2f341(%rip), %rsi     # 0x82880
movl $0xd26, %edx            # imm = 0xD26
leaq 0x2fc25(%rip), %rcx     # 0x83170
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0xe50, %eax            # imm = 0xE50
jne 0x53641
jmp 0x53569
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x53575
jmp 0x53594
leaq 0x2f7c8(%rip), %rdi     # 0x82d44
leaq 0x2f2fd(%rip), %rsi     # 0x82880
movl $0xd31, %edx            # imm = 0xD31
leaq 0x2fbe1(%rip), %rcx     # 0x83170
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 0x53820
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x53820
leaq 0x2b5cc(%rip), %rax     # 0x7eba0
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 0x53990
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x70(%rcx)
movb %al, -0x31(%rbp)
je 0x53610
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 0x5363f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x513e0
jmp 0x5364e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x53820
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/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 BE_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
			);

			BE_EXPR_AST_NODE_COPY_CONSTANT2(node, node_oprd1, node_oprd2);

			if (BE_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 0x53839
jmp 0x53858
leaq 0x2c921(%rip), %rdi     # 0x80161
leaq 0x2f039(%rip), %rsi     # 0x82880
movl $0xcd7, %edx            # imm = 0xCD7
leaq 0x2f94f(%rip), %rcx     # 0x831a2
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x53861
jmp 0x53880
leaq 0x22cf4(%rip), %rdi     # 0x7655c
leaq 0x2f011(%rip), %rsi     # 0x82880
movl $0xcd8, %edx            # imm = 0xCD8
leaq 0x2f927(%rip), %rcx     # 0x831a2
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
subl $0xe60, %eax            # imm = 0xE60
jne 0x53971
jmp 0x53899
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x538a5
jmp 0x538c4
leaq 0x2f498(%rip), %rdi     # 0x82d44
leaq 0x2efcd(%rip), %rsi     # 0x82880
movl $0xce3, %edx            # imm = 0xCE3
leaq 0x2f8e3(%rip), %rcx     # 0x831a2
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 0x53b50
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x53b50
leaq 0x2b73a(%rip), %rax     # 0x7f03e
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 0x53db0
movq -0x20(%rbp), %rcx
xorl %eax, %eax
testb $0x1, 0x70(%rcx)
movb %al, -0x31(%rbp)
je 0x53940
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 0x5396f
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x513e0
jmp 0x5397e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x53b50
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: expr_parenthesis
static void _expr_parenthesis(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);

	if (node->type == BE_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 0x55c79
jmp 0x55c98
leaq 0x2a4e1(%rip), %rdi     # 0x80161
leaq 0x2cbf9(%rip), %rsi     # 0x82880
movl $0x9f9, %edx            # imm = 0x9F9
leaq 0x2d817(%rip), %rcx     # 0x834aa
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x55ca1
jmp 0x55cc0
leaq 0x208b4(%rip), %rdi     # 0x7655c
leaq 0x2cbd1(%rip), %rsi     # 0x82880
movl $0x9fa, %edx            # imm = 0x9FA
leaq 0x2d7ef(%rip), %rcx     # 0x834aa
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xee0, (%rax)          # imm = 0xEE0
jne 0x55cdb
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x58210
jmp 0x55ce8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4f400
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_number_type_node
static bool _is_number_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_number_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x564c9
jmp 0x564e8
leaq 0x29c91(%rip), %rdi     # 0x80161
leaq 0x2c3a9(%rip), %rsi     # 0x82880
movl $0x1f6, %edx            # imm = 0x1F6
leaq 0x2d0ee(%rip), %rcx     # 0x835d1
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x564f1
jmp 0x56510
leaq 0x20064(%rip), %rdi     # 0x7655c
leaq 0x2c381(%rip), %rsi     # 0x82880
movl $0x1f7, %edx            # imm = 0x1F7
leaq 0x2d0c6(%rip), %rcx     # 0x835d1
callq 0x30a0
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0xff00, %eax           # imm = 0xFF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x56524
jmp 0x56543
leaq 0x2d0e3(%rip), %rdi     # 0x8360e
leaq 0x2c34e(%rip), %rsi     # 0x82880
movl $0x1f8, %edx            # imm = 0x1F8
leaq 0x2d093(%rip), %rcx     # 0x835d1
callq 0x30a0
movq -0x10(%rbp), %rax
movzbl 0x60(%rax), %edi
callq 0x4dbd0
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: calc_pointer_type_increment_size
static size_t _calc_pointer_type_increment_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);
	assert(node_type->type == BE_NODE_TYPE_POINTER);
	assert(node_type->nchilds == 1);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5a19d
jmp 0x5a1bc
leaq 0x25fbd(%rip), %rdi     # 0x80161
leaq 0x286d5(%rip), %rsi     # 0x82880
movl $0x543, %edx            # imm = 0x543
leaq 0x29dc3(%rip), %rcx     # 0x83f7a
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5a1c5
jmp 0x5a1e4
leaq 0x1c390(%rip), %rdi     # 0x7655c
leaq 0x286ad(%rip), %rsi     # 0x82880
movl $0x544, %edx            # imm = 0x544
leaq 0x29d9b(%rip), %rcx     # 0x83f7a
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5a1ed
jmp 0x5a20c
leaq 0x2b04a(%rip), %rdi     # 0x8523e
leaq 0x28685(%rip), %rsi     # 0x82880
movl $0x545, %edx            # imm = 0x545
leaq 0x29d73(%rip), %rcx     # 0x83f7a
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x440, (%rax)          # imm = 0x440
jne 0x5a21a
jmp 0x5a239
leaq 0x1f193(%rip), %rdi     # 0x793b4
leaq 0x28658(%rip), %rsi     # 0x82880
movl $0x546, %edx            # imm = 0x546
leaq 0x29d46(%rip), %rcx     # 0x83f7a
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5a245
jmp 0x5a264
leaq 0x28c10(%rip), %rdi     # 0x82e5c
leaq 0x2862d(%rip), %rsi     # 0x82880
movl $0x547, %edx            # imm = 0x547
leaq 0x29d1b(%rip), %rcx     # 0x83f7a
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rdx
callq 0x4d5a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_primitive_type_weight
static int32_t _get_primitive_type_weight(
	uint8_t type
) {
	switch (type) {
		case BE_TYPE_CHAR: {
			return 1;
		}
		case BE_TYPE_INT8: {
			return 2;
		}
		case BE_TYPE_UINT8: {
			return 3;
		}
		case BE_TYPE_INT16: {
			return 4;
		}
		case BE_TYPE_UINT16: {
			return 5;
		}
		case BE_TYPE_INT32: {
			return 6;
		}
		case BE_TYPE_UINT32: {
			return 7;
		}
		case BE_TYPE_INT64: {
			return 8;
		}
		case BE_TYPE_UINT64: {
			return 9;
		}
		case BE_TYPE_FLOAT: {
			return 10;
		}
		case BE_TYPE_DOUBLE: {
			return 11;
		}
		default: {
			assert(0);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0xa, %eax
ja 0x5a326
movq -0x10(%rbp), %rax
leaq 0x28162(%rip), %rcx     # 0x8241c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rbp)
jmp 0x5a345
movl $0x2, -0x4(%rbp)
jmp 0x5a345
movl $0x3, -0x4(%rbp)
jmp 0x5a345
movl $0x4, -0x4(%rbp)
jmp 0x5a345
movl $0x5, -0x4(%rbp)
jmp 0x5a345
movl $0x6, -0x4(%rbp)
jmp 0x5a345
movl $0x7, -0x4(%rbp)
jmp 0x5a345
movl $0x8, -0x4(%rbp)
jmp 0x5a345
movl $0x9, -0x4(%rbp)
jmp 0x5a345
movl $0xa, -0x4(%rbp)
jmp 0x5a345
movl $0xb, -0x4(%rbp)
jmp 0x5a345
leaq 0x1912d(%rip), %rdi     # 0x7345a
leaq 0x2854c(%rip), %rsi     # 0x82880
movl $0x14e, %edx            # imm = 0x14E
leaq 0x29a65(%rip), %rcx     # 0x83da5
callq 0x30a0
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/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 == BE_TYPE_VOID
			&& source_type == BE_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 0x5a374
jmp 0x5a393
leaq 0x25de6(%rip), %rdi     # 0x80161
leaq 0x284fe(%rip), %rsi     # 0x82880
movl $0x236, %edx            # imm = 0x236
leaq 0x29d58(%rip), %rcx     # 0x840e6
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5a39c
jmp 0x5a3bb
leaq 0x24f91(%rip), %rdi     # 0x7f334
leaq 0x284d6(%rip), %rsi     # 0x82880
movl $0x237, %edx            # imm = 0x237
leaq 0x29d30(%rip), %rcx     # 0x840e6
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5a3c4
jmp 0x5a3e3
leaq 0x21e69(%rip), %rdi     # 0x7c234
leaq 0x284ae(%rip), %rsi     # 0x82880
movl $0x238, %edx            # imm = 0x238
leaq 0x29d08(%rip), %rcx     # 0x840e6
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x56560
movb %al, -0x1a(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56560
movb %al, -0x1b(%rbp)
movzbl -0x1a(%rbp), %ecx
xorl %eax, %eax
cmpl $0xff, %ecx
movb %al, -0x1c(%rbp)
jne 0x5a423
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/backend/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) == BE_TYPE_ARRAY
			&& _get_type_by_type_node(ctx, source) == BE_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 0x5a694
jmp 0x5a6b3
leaq 0x25ac6(%rip), %rdi     # 0x80161
leaq 0x281de(%rip), %rsi     # 0x82880
movl $0x28f, %edx            # imm = 0x28F
leaq 0x29b4a(%rip), %rcx     # 0x841f8
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5a6bc
jmp 0x5a6db
leaq 0x24c71(%rip), %rdi     # 0x7f334
leaq 0x281b6(%rip), %rsi     # 0x82880
movl $0x290, %edx            # imm = 0x290
leaq 0x29b22(%rip), %rcx     # 0x841f8
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5a6e4
jmp 0x5a703
leaq 0x21b49(%rip), %rdi     # 0x7c234
leaq 0x2818e(%rip), %rsi     # 0x82880
movl $0x291, %edx            # imm = 0x291
leaq 0x29afa(%rip), %rcx     # 0x841f8
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56560
movzbl %al, %eax
cmpl $0xe, %eax
jne 0x5a7b8
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x56560
movzbl %al, %eax
cmpl $0xe, %eax
jne 0x5a7b8
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 0x5ac90
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x5a792
jmp 0x5a7ae
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x50c90
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5a7bc
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_compatible_pointer_type
static bool _is_compatible_pointer_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
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 0x5aa54
jmp 0x5aa73
leaq 0x25706(%rip), %rdi     # 0x80161
leaq 0x27e1e(%rip), %rsi     # 0x82880
movl $0x2e1, %edx            # imm = 0x2E1
leaq 0x298ad(%rip), %rcx     # 0x8431b
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5aa7c
jmp 0x5aa9b
leaq 0x248b1(%rip), %rdi     # 0x7f334
leaq 0x27df6(%rip), %rsi     # 0x82880
movl $0x2e2, %edx            # imm = 0x2E2
leaq 0x29885(%rip), %rcx     # 0x8431b
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5aaa4
jmp 0x5aac3
leaq 0x21789(%rip), %rdi     # 0x7c234
leaq 0x27dce(%rip), %rsi     # 0x82880
movl $0x2e3, %edx            # imm = 0x2E3
leaq 0x2985d(%rip), %rcx     # 0x8431b
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56560
movzbl %al, %eax
cmpl $0x10, %eax
jne 0x5ab95
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x56560
movzbl %al, %eax
cmpl $0x10, %eax
jne 0x5ab95
testb $0x1, -0x21(%rbp)
je 0x5ab36
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 0x50c90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5ab99
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rsi
callq 0x56560
movzbl %al, %eax
cmpl $0xff, %eax
jne 0x5ab5a
movb $0x1, -0x1(%rbp)
jmp 0x5ab99
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 0x50c90
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5ab99
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/backend/semantics.c
// Function: is_compatible_va_list_type
static bool _is_compatible_va_list_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

	if (_get_type_by_type_node(ctx, target) == BE_TYPE_VA_LIST
			&& _get_type_by_type_node(ctx, source) == BE_TYPE_VA_LIST) {
		return true;
	} 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 0x5abd4
jmp 0x5abf3
leaq 0x25586(%rip), %rdi     # 0x80161
leaq 0x27c9e(%rip), %rsi     # 0x82880
movl $0x2ff, %edx            # imm = 0x2FF
leaq 0x29789(%rip), %rcx     # 0x84377
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5abfc
jmp 0x5ac1b
leaq 0x24731(%rip), %rdi     # 0x7f334
leaq 0x27c76(%rip), %rsi     # 0x82880
movl $0x300, %edx            # imm = 0x300
leaq 0x29761(%rip), %rcx     # 0x84377
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5ac24
jmp 0x5ac43
leaq 0x21609(%rip), %rdi     # 0x7c234
leaq 0x27c4e(%rip), %rsi     # 0x82880
movl $0x301, %edx            # imm = 0x301
leaq 0x29739(%rip), %rcx     # 0x84377
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56560
movzbl %al, %eax
cmpl $0xc, %eax
jne 0x5ac73
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x56560
movzbl %al, %eax
cmpl $0xc, %eax
jne 0x5ac73
movb $0x1, -0x1(%rbp)
jmp 0x5ac77
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/backend/semantics.c
// Function: is_compatible_array_type_dims
static bool _is_compatible_array_type_dims(
	ParserContext *ctx,
	ParserASTNode *target_dims,
	ParserASTNode *source_dims
) {
	assert(ctx);
	assert(target_dims);
	assert(source_dims);

	if (target_dims->nchilds != source_dims->nchilds) {
		return false;
	}

	for (int32_t i = 0; i < target_dims->nchilds; i++) {
		ParserASTNode *target_dim = target_dims->childs[i];
		ParserASTNode *source_dim = source_dims->childs[i];
		if (be_parser_get_uint_val(ctx, target_dim) != be_parser_get_uint_val(ctx, source_dim)) {
			return false;
		}
	}
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5acad
jmp 0x5accc
leaq 0x254ad(%rip), %rdi     # 0x80161
leaq 0x27bc5(%rip), %rsi     # 0x82880
movl $0x26f, %edx            # imm = 0x26F
leaq 0x2958b(%rip), %rcx     # 0x84252
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5acd5
jmp 0x5acf4
leaq 0x295ce(%rip), %rdi     # 0x842aa
leaq 0x27b9d(%rip), %rsi     # 0x82880
movl $0x270, %edx            # imm = 0x270
leaq 0x29563(%rip), %rcx     # 0x84252
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5acfd
jmp 0x5ad1c
leaq 0x295b2(%rip), %rdi     # 0x842b6
leaq 0x27b75(%rip), %rsi     # 0x82880
movl $0x271, %edx            # imm = 0x271
leaq 0x2953b(%rip), %rcx     # 0x84252
callq 0x30a0
movq -0x18(%rbp), %rax
movl 0x44(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x44(%rcx), %eax
je 0x5ad32
movb $0x0, -0x1(%rbp)
jmp 0x5adae
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x5adaa
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3e290
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3e290
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
je 0x5ad9d
movb $0x0, -0x1(%rbp)
jmp 0x5adae
jmp 0x5ad9f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5ad39
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: func_process_label
static void _func_process_label(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_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 0x5b4b9
jmp 0x5b4d8
leaq 0x24ca1(%rip), %rdi     # 0x80161
leaq 0x273b9(%rip), %rsi     # 0x82880
movl $0x1799, %edx           # imm = 0x1799
leaq 0x293fa(%rip), %rcx     # 0x848cd
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5b4e1
jmp 0x5b500
leaq 0x1b074(%rip), %rdi     # 0x7655c
leaq 0x27391(%rip), %rsi     # 0x82880
movl $0x179a, %edx           # imm = 0x179A
leaq 0x293d2(%rip), %rcx     # 0x848cd
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb00, (%rax)          # imm = 0xB00
jne 0x5b50e
jmp 0x5b52d
leaq 0x293f3(%rip), %rdi     # 0x84908
leaq 0x27364(%rip), %rsi     # 0x82880
movl $0x179b, %edx           # imm = 0x179B
leaq 0x293a5(%rip), %rcx     # 0x848cd
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5b630
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stats_block
static void _stats_block(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_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 0x5b569
jmp 0x5b588
leaq 0x24bf1(%rip), %rdi     # 0x80161
leaq 0x27309(%rip), %rsi     # 0x82880
movl $0x176f, %edx           # imm = 0x176F
leaq 0x293fc(%rip), %rcx     # 0x8497f
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5b591
jmp 0x5b5b0
leaq 0x1afc4(%rip), %rdi     # 0x7655c
leaq 0x272e1(%rip), %rsi     # 0x82880
movl $0x1770, %edx           # imm = 0x1770
leaq 0x293d4(%rip), %rcx     # 0x8497f
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb00, (%rax)          # imm = 0xB00
jne 0x5b5be
jmp 0x5b5dd
leaq 0x29343(%rip), %rdi     # 0x84908
leaq 0x272b4(%rip), %rsi     # 0x82880
movl $0x1771, %edx           # imm = 0x1771
leaq 0x293a7(%rip), %rcx     # 0x8497f
callq 0x30a0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x44(%rcx), %eax
jge 0x5b61c
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 0x5b770
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5b5e4
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: _func_process_label
static void __func_process_label(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *current
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STATS_BLOCK);
	assert(current);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5b64d
jmp 0x5b66c
leaq 0x24b0d(%rip), %rdi     # 0x80161
leaq 0x27225(%rip), %rsi     # 0x82880
movl $0x177f, %edx           # imm = 0x177F
leaq 0x292c3(%rip), %rcx     # 0x8492a
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5b675
jmp 0x5b694
leaq 0x1aee0(%rip), %rdi     # 0x7655c
leaq 0x271fd(%rip), %rsi     # 0x82880
movl $0x1780, %edx           # imm = 0x1780
leaq 0x2929b(%rip), %rcx     # 0x8492a
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb00, (%rax)          # imm = 0xB00
jne 0x5b6a2
jmp 0x5b6c1
leaq 0x2925f(%rip), %rdi     # 0x84908
leaq 0x271d0(%rip), %rsi     # 0x82880
movl $0x1781, %edx           # imm = 0x1781
leaq 0x2926e(%rip), %rcx     # 0x8492a
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5b6ca
jmp 0x5b6e9
leaq 0x292a6(%rip), %rdi     # 0x84977
leaq 0x271a8(%rip), %rsi     # 0x82880
movl $0x1782, %edx           # imm = 0x1782
leaq 0x29246(%rip), %rcx     # 0x8492a
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0xb30, (%rax)          # imm = 0xB30
jne 0x5b71e
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 0x5b761
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 0x5b630
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x5b725
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_var
static void _stat_var(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_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 0x5bbd9
jmp 0x5bbf8
leaq 0x24581(%rip), %rdi     # 0x80161
leaq 0x26c99(%rip), %rsi     # 0x82880
movl $0xfb2, %edx            # imm = 0xFB2
leaq 0x28ded(%rip), %rcx     # 0x849e0
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5bc01
jmp 0x5bc20
leaq 0x1a954(%rip), %rdi     # 0x7655c
leaq 0x26c71(%rip), %rsi     # 0x82880
movl $0xfb3, %edx            # imm = 0xFB3
leaq 0x28dc5(%rip), %rcx     # 0x849e0
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xc00, (%rax)          # imm = 0xC00
jne 0x5bc2e
jmp 0x5bc4d
leaq 0x272d9(%rip), %rdi     # 0x82f0e
leaq 0x26c44(%rip), %rsi     # 0x82880
movl $0xfb4, %edx            # imm = 0xFB4
leaq 0x28d98(%rip), %rcx     # 0x849e0
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4df60
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_assign
static void _stat_assign(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_ASSIGN);
	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_target_type = _check_assignable(ctx, node_target, symbol_target);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5bc79
jmp 0x5bc98
leaq 0x244e1(%rip), %rdi     # 0x80161
leaq 0x26bf9(%rip), %rsi     # 0x82880
movl $0x1081, %edx           # imm = 0x1081
leaq 0x28d7e(%rip), %rcx     # 0x84a11
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5bca1
jmp 0x5bcc0
leaq 0x1a8b4(%rip), %rdi     # 0x7655c
leaq 0x26bd1(%rip), %rsi     # 0x82880
movl $0x1082, %edx           # imm = 0x1082
leaq 0x28d56(%rip), %rcx     # 0x84a11
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb90, (%rax)          # imm = 0xB90
jne 0x5bcce
jmp 0x5bced
leaq 0x1a6c6(%rip), %rdi     # 0x7639b
leaq 0x26ba4(%rip), %rsi     # 0x82880
movl $0x1083, %edx           # imm = 0x1083
leaq 0x28d29(%rip), %rcx     # 0x84a11
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5bcf9
jmp 0x5bd18
leaq 0x27044(%rip), %rdi     # 0x82d44
leaq 0x26b79(%rip), %rsi     # 0x82880
movl $0x1084, %edx           # imm = 0x1084
leaq 0x28cfe(%rip), %rcx     # 0x84a11
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 0x5bd35
jmp 0x5bd54
leaq 0x1a681(%rip), %rdi     # 0x763bd
leaq 0x26b3d(%rip), %rsi     # 0x82880
movl $0x1087, %edx           # imm = 0x1087
leaq 0x28cc2(%rip), %rcx     # 0x84a11
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5edc0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x5eea0
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
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x40(%rbp), %rcx
callq 0x5f150
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_asm
static void _stat_asm(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_ASM);

	// 什么也不干。
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5bdd9
jmp 0x5bdf8
leaq 0x24381(%rip), %rdi     # 0x80161
leaq 0x26a99(%rip), %rsi     # 0x82880
movl $0x1095, %edx           # imm = 0x1095
leaq 0x28ed6(%rip), %rcx     # 0x84cc9
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5be01
jmp 0x5be20
leaq 0x1a754(%rip), %rdi     # 0x7655c
leaq 0x26a71(%rip), %rsi     # 0x82880
movl $0x1096, %edx           # imm = 0x1096
leaq 0x28eae(%rip), %rcx     # 0x84cc9
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb40, (%rax)          # imm = 0xB40
jne 0x5be2e
jmp 0x5be4d
leaq 0x1adb0(%rip), %rdi     # 0x76be5
leaq 0x26a44(%rip), %rsi     # 0x82880
movl $0x1097, %edx           # imm = 0x1097
leaq 0x28e81(%rip), %rcx     # 0x84cc9
callq 0x30a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_asm_set_reg
static void _stat_asm_set_reg(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_ASM_SET_REG);
	assert(node->nchilds == 2);

	ParserASTNode *node_target = node->childs[0];
	assert(node_target->type == BE_NODE_LITERAL_STRING);

	ParserASTNode *node_source = node->childs[1];
	_GetParamInfoResult result_source;
	_get_param_info(ctx, node_source, &result_source);
	if (!_is_primitive_type(result_source.type)
			&& !_is_pointer_type(result_source.type)) {
		_SYNERR_NODE(
			ctx,
			node_source,
			"source parameter type must be primitive type or pointer type."
		);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5be7c
jmp 0x5be9b
leaq 0x242de(%rip), %rdi     # 0x80161
leaq 0x269f6(%rip), %rsi     # 0x82880
movl $0x10a0, %edx           # imm = 0x10A0
leaq 0x28e64(%rip), %rcx     # 0x84cfa
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5bea4
jmp 0x5bec3
leaq 0x1a6b1(%rip), %rdi     # 0x7655c
leaq 0x269ce(%rip), %rsi     # 0x82880
movl $0x10a1, %edx           # imm = 0x10A1
leaq 0x28e3c(%rip), %rcx     # 0x84cfa
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb41, (%rax)          # imm = 0xB41
jne 0x5bed1
jmp 0x5bef0
leaq 0x1ae20(%rip), %rdi     # 0x76cf8
leaq 0x269a1(%rip), %rsi     # 0x82880
movl $0x10a2, %edx           # imm = 0x10A2
leaq 0x28e0f(%rip), %rcx     # 0x84cfa
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5befc
jmp 0x5bf1b
leaq 0x26e41(%rip), %rdi     # 0x82d44
leaq 0x26976(%rip), %rsi     # 0x82880
movl $0x10a3, %edx           # imm = 0x10A3
leaq 0x28de4(%rip), %rcx     # 0x84cfa
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x303, (%rax)          # imm = 0x303
jne 0x5bf38
jmp 0x5bf57
leaq 0x1ade0(%rip), %rdi     # 0x76d1f
leaq 0x2693a(%rip), %rsi     # 0x82880
movl $0x10a6, %edx           # imm = 0x10A6
leaq 0x28da8(%rip), %rcx     # 0x84cfa
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x5efc0
movzbl -0x28(%rbp), %edi
callq 0x4db40
testb $0x1, %al
jne 0x5bfc0
movzbl -0x28(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5bfc0
leaq -0x430(%rbp), %rdi
leaq 0x28d93(%rip), %rsi     # 0x84d33
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x430(%rbp), %rdx
callq *%rax
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_asm_get_reg
static void _stat_asm_get_reg(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_ASM_GET_REG);
	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);
	uint8_t type_target = BE_VAR_SYMBOL_GET_TYPE(symbol_target);
	if (!_is_primitive_type(type_target)
			&& !_is_pointer_type(type_target)) {
		_SYNERR_NODE(ctx, node_target, "target parameter type must be primitive type or pointer type.");
	}

	ParserASTNode *node_source = node->childs[1];
	assert(node_source->type == BE_NODE_LITERAL_STRING);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5bfec
jmp 0x5c00b
leaq 0x2416e(%rip), %rdi     # 0x80161
leaq 0x26886(%rip), %rsi     # 0x82880
movl $0x10b9, %edx           # imm = 0x10B9
leaq 0x28d6b(%rip), %rcx     # 0x84d71
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5c014
jmp 0x5c033
leaq 0x1a541(%rip), %rdi     # 0x7655c
leaq 0x2685e(%rip), %rsi     # 0x82880
movl $0x10ba, %edx           # imm = 0x10BA
leaq 0x28d43(%rip), %rcx     # 0x84d71
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb42, (%rax)          # imm = 0xB42
jne 0x5c041
jmp 0x5c060
leaq 0x1aea4(%rip), %rdi     # 0x76eec
leaq 0x26831(%rip), %rsi     # 0x82880
movl $0x10bb, %edx           # imm = 0x10BB
leaq 0x28d16(%rip), %rcx     # 0x84d71
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x44(%rax)
jne 0x5c06c
jmp 0x5c08b
leaq 0x26cd1(%rip), %rdi     # 0x82d44
leaq 0x26806(%rip), %rsi     # 0x82880
movl $0x10bc, %edx           # imm = 0x10BC
leaq 0x28ceb(%rip), %rcx     # 0x84d71
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 0x5c0a8
jmp 0x5c0c7
leaq 0x1a30e(%rip), %rdi     # 0x763bd
leaq 0x267ca(%rip), %rsi     # 0x82880
movl $0x10bf, %edx           # imm = 0x10BF
leaq 0x28caf(%rip), %rcx     # 0x84d71
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5edc0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb 0x30(%rax), %al
movb %al, -0x21(%rbp)
movzbl -0x21(%rbp), %edi
callq 0x4db40
testb $0x1, %al
jne 0x5c12a
movzbl -0x21(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5c12a
leaq -0x430(%rbp), %rdi
leaq 0x28ca0(%rip), %rsi     # 0x84daa
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq -0x430(%rbp), %rdx
callq *%rax
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x438(%rbp)
movq -0x438(%rbp), %rax
cmpl $0x303, (%rax)          # imm = 0x303
jne 0x5c14e
jmp 0x5c16d
leaq 0x1adbe(%rip), %rdi     # 0x76f13
leaq 0x26724(%rip), %rsi     # 0x82880
movl $0x10c8, %edx           # imm = 0x10C8
leaq 0x28c09(%rip), %rcx     # 0x84d71
callq 0x30a0
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_label
static void _stat_label(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_LABEL);
	assert(node->nchilds == 1);
	assert(node->childs[0]->type == BE_NODE_IDENTIFIER);

	// 什么也不做。
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5c199
jmp 0x5c1b8
leaq 0x23fc1(%rip), %rdi     # 0x80161
leaq 0x266d9(%rip), %rsi     # 0x82880
movl $0x10cf, %edx           # imm = 0x10CF
leaq 0x28c35(%rip), %rcx     # 0x84de8
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5c1c1
jmp 0x5c1e0
leaq 0x1a394(%rip), %rdi     # 0x7655c
leaq 0x266b1(%rip), %rsi     # 0x82880
movl $0x10d0, %edx           # imm = 0x10D0
leaq 0x28c0d(%rip), %rcx     # 0x84de8
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb30, (%rax)          # imm = 0xB30
jne 0x5c1ee
jmp 0x5c20d
leaq 0x1ad8c(%rip), %rdi     # 0x76f81
leaq 0x26684(%rip), %rsi     # 0x82880
movl $0x10d1, %edx           # imm = 0x10D1
leaq 0x28be0(%rip), %rcx     # 0x84de8
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5c219
jmp 0x5c238
leaq 0x1b1ee(%rip), %rdi     # 0x7740e
leaq 0x26659(%rip), %rsi     # 0x82880
movl $0x10d2, %edx           # imm = 0x10D2
leaq 0x28bb5(%rip), %rcx     # 0x84de8
callq 0x30a0
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq (%rax), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x5c24d
jmp 0x5c26c
leaq 0x28bc7(%rip), %rdi     # 0x84e1b
leaq 0x26625(%rip), %rsi     # 0x82880
movl $0x10d3, %edx           # imm = 0x10D3
leaq 0x28b81(%rip), %rcx     # 0x84de8
callq 0x30a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_br
static void _stat_br(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_BR);
	assert(node->nchilds == 1);

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

	if (!parser_get_symbol_from_node(ctx, node, BE_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 0x5c299
jmp 0x5c2b8
leaq 0x23ec1(%rip), %rdi     # 0x80161
leaq 0x265d9(%rip), %rsi     # 0x82880
movl $0x10dc, %edx           # imm = 0x10DC
leaq 0x28b94(%rip), %rcx     # 0x84e47
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5c2c1
jmp 0x5c2e0
leaq 0x1a294(%rip), %rdi     # 0x7655c
leaq 0x265b1(%rip), %rsi     # 0x82880
movl $0x10dd, %edx           # imm = 0x10DD
leaq 0x28b6c(%rip), %rcx     # 0x84e47
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb10, (%rax)          # imm = 0xB10
jne 0x5c2ee
jmp 0x5c30d
leaq 0x1ad76(%rip), %rdi     # 0x7706b
leaq 0x26584(%rip), %rsi     # 0x82880
movl $0x10de, %edx           # imm = 0x10DE
leaq 0x28b3f(%rip), %rcx     # 0x84e47
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5c319
jmp 0x5c338
leaq 0x1b0ee(%rip), %rdi     # 0x7740e
leaq 0x26559(%rip), %rsi     # 0x82880
movl $0x10df, %edx           # imm = 0x10DF
leaq 0x28b14(%rip), %rcx     # 0x84e47
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 0x5c355
jmp 0x5c374
leaq 0x1ac46(%rip), %rdi     # 0x76fa2
leaq 0x2651d(%rip), %rsi     # 0x82880
movl $0x10e2, %edx           # imm = 0x10E2
leaq 0x28ad8(%rip), %rcx     # 0x84e47
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 0x5c3b1
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq 0x28ac8(%rip), %rdx     # 0x84e77
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)