LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: stat_neq
static void _stat_neq(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_NEQ, &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 $0xbee, %edx            # imm = 0xBEE
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e218
jmp 0x5e242
movzbl -0x40(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5e234
movzbl -0x40(%rbp), %edi
callq 0x4db90
testb $0x1, %al
jne 0x5e234
jmp 0x5e242
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e242
jmp 0x5e270
leaq -0x470(%rbp), %rdi
leaq 0x26a5a(%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_lt
static void _stat_lt(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_LT, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& _is_number_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 $0xbef, %edx            # imm = 0xBEF
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e2b8
jmp 0x5e2d5
movzbl -0x40(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5e2c7
jmp 0x5e2d5
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e2d5
jmp 0x5e303
leaq -0x470(%rbp), %rdi
leaq 0x269c7(%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_le
static void _stat_le(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_LE, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& _is_number_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 $0xbf0, %edx            # imm = 0xBF0
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e348
jmp 0x5e365
movzbl -0x40(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5e357
jmp 0x5e365
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e365
jmp 0x5e393
leaq -0x470(%rbp), %rdi
leaq 0x26937(%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_gt
static void _stat_gt(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_GT, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& _is_number_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 $0xbf1, %edx            # imm = 0xBF1
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e3d8
jmp 0x5e3f5
movzbl -0x40(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5e3e7
jmp 0x5e3f5
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e3f5
jmp 0x5e423
leaq -0x470(%rbp), %rdi
leaq 0x268a7(%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_ge
static void _stat_ge(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_GE, &check_result);

	if (_is_integer_type(check_result.type_target)
			&& _is_number_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 $0xbf2, %edx            # imm = 0xBF2
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e468
jmp 0x5e485
movzbl -0x40(%rbp), %edi
callq 0x4dbd0
testb $0x1, %al
jne 0x5e477
jmp 0x5e485
movzbl -0x40(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e485
jmp 0x5e4b3
leaq -0x470(%rbp), %rdi
leaq 0x26817(%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_band
static void _stat_band(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_BAND, &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 $0xbf3, %edx            # imm = 0xBF3
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e4f8
jmp 0x5e512
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e512
movzbl -0x60(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e512
jmp 0x5e540
leaq -0x470(%rbp), %rdi
leaq 0x2678a(%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_bor
static void _stat_bor(
	ParserContext *ctx,
	ParserASTNode *node
) {
	_ResultCheckStat_I_CI_CI check_result;
	_check_stat_i_ci_ci(ctx, node, BE_NODE_STAT_BOR, &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 $0xbf4, %edx            # imm = 0xBF4
leaq -0x70(%rbp), %rcx
callq 0x5fdf0
movzbl -0x60(%rbp), %edi
callq 0x4daa0
testb $0x1, %al
jne 0x5e588
jmp 0x5e5a2
movzbl -0x60(%rbp), %eax
movzbl -0x40(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e5a2
movzbl -0x60(%rbp), %eax
movzbl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5e5a2
jmp 0x5e5d0
leaq -0x470(%rbp), %rdi
leaq 0x266fa(%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_va_start
static void _stat_va_start(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_VA_START);
	assert(node->nchilds == 1);

	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);
	if (!_is_va_list_pointer(node_type_target)) {
		goto err;
	}

	return;
err:
	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e68c
jmp 0x5e6ab
leaq 0x21ace(%rip), %rdi     # 0x80161
leaq 0x241e6(%rip), %rsi     # 0x82880
movl $0x15f2, %edx           # imm = 0x15F2
leaq 0x270e6(%rip), %rcx     # 0x8578c
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5e6b4
jmp 0x5e6d3
leaq 0x17ea1(%rip), %rdi     # 0x7655c
leaq 0x241be(%rip), %rsi     # 0x82880
movl $0x15f3, %edx           # imm = 0x15F3
leaq 0x270be(%rip), %rcx     # 0x8578c
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb70, (%rax)          # imm = 0xB70
jne 0x5e6e1
jmp 0x5e700
leaq 0x1bae7(%rip), %rdi     # 0x7a1cf
leaq 0x24191(%rip), %rsi     # 0x82880
movl $0x15f4, %edx           # imm = 0x15F4
leaq 0x27091(%rip), %rcx     # 0x8578c
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5e70c
jmp 0x5e72b
leaq 0x18cfb(%rip), %rdi     # 0x7740e
leaq 0x24166(%rip), %rsi     # 0x82880
movl $0x15f5, %edx           # imm = 0x15F5
leaq 0x27066(%rip), %rcx     # 0x8578c
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 0x5e748
jmp 0x5e767
leaq 0x17c6e(%rip), %rdi     # 0x763bd
leaq 0x2412a(%rip), %rsi     # 0x82880
movl $0x15f8, %edx           # imm = 0x15F8
leaq 0x2702a(%rip), %rcx     # 0x8578c
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 -0x28(%rbp), %rdi
callq 0x602f0
testb $0x1, %al
jne 0x5e793
jmp 0x5e795
jmp 0x5e7c3
leaq -0x430(%rbp), %rdi
leaq 0x26507(%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 -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_va_end
static void _stat_va_end(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_VA_END);
	assert(node->nchilds == 1);

	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);
	if (!_is_va_list_pointer(node_type_target)) {
		goto err;
	}

	return;
err:
	_SYNERR_NODE(
		ctx,
		node,
		"invalid parameter combination."
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5e7ec
jmp 0x5e80b
leaq 0x2196e(%rip), %rdi     # 0x80161
leaq 0x24086(%rip), %rsi     # 0x82880
movl $0x160c, %edx           # imm = 0x160C
leaq 0x26fe7(%rip), %rcx     # 0x857ed
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5e814
jmp 0x5e833
leaq 0x17d41(%rip), %rdi     # 0x7655c
leaq 0x2405e(%rip), %rsi     # 0x82880
movl $0x160d, %edx           # imm = 0x160D
leaq 0x26fbf(%rip), %rcx     # 0x857ed
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb71, (%rax)          # imm = 0xB71
jne 0x5e841
jmp 0x5e860
leaq 0x1b9f2(%rip), %rdi     # 0x7a23a
leaq 0x24031(%rip), %rsi     # 0x82880
movl $0x160e, %edx           # imm = 0x160E
leaq 0x26f92(%rip), %rcx     # 0x857ed
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x1, 0x44(%rax)
jne 0x5e86c
jmp 0x5e88b
leaq 0x18b9b(%rip), %rdi     # 0x7740e
leaq 0x24006(%rip), %rsi     # 0x82880
movl $0x160f, %edx           # imm = 0x160F
leaq 0x26f67(%rip), %rcx     # 0x857ed
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 0x5e8a8
jmp 0x5e8c7
leaq 0x17b0e(%rip), %rdi     # 0x763bd
leaq 0x23fca(%rip), %rsi     # 0x82880
movl $0x1612, %edx           # imm = 0x1612
leaq 0x26f2b(%rip), %rcx     # 0x857ed
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 -0x28(%rbp), %rdi
callq 0x602f0
testb $0x1, %al
jne 0x5e8f3
jmp 0x5e8f5
jmp 0x5e923
leaq -0x430(%rbp), %rdi
leaq 0x263a7(%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 -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_dummy
static void _stat_dummy(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STAT_DUMMY);

	// 什么也不干。
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5ed39
jmp 0x5ed58
leaq 0x21421(%rip), %rdi     # 0x80161
leaq 0x23b39(%rip), %rsi     # 0x82880
movl $0x1674, %edx           # imm = 0x1674
leaq 0x26b37(%rip), %rcx     # 0x8588a
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ed61
jmp 0x5ed80
leaq 0x177f4(%rip), %rdi     # 0x7655c
leaq 0x23b11(%rip), %rsi     # 0x82880
movl $0x1675, %edx           # imm = 0x1675
leaq 0x26b0f(%rip), %rcx     # 0x8588a
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0xb60, (%rax)          # imm = 0xB60
jne 0x5ed8e
jmp 0x5edad
leaq 0x26b28(%rip), %rdi     # 0x858bd
leaq 0x23ae4(%rip), %rsi     # 0x82880
movl $0x1676, %edx           # imm = 0x1676
leaq 0x26ae2(%rip), %rcx     # 0x8588a
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: get_var_symbol_by_id_node
static ParserSymbol * _get_var_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5edd9
jmp 0x5edf8
leaq 0x21381(%rip), %rdi     # 0x80161
leaq 0x23a99(%rip), %rsi     # 0x82880
movl $0xfbd, %edx            # imm = 0xFBD
leaq 0x25c52(%rip), %rcx     # 0x84a45
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5ee01
jmp 0x5ee20
leaq 0x17754(%rip), %rdi     # 0x7655c
leaq 0x23a71(%rip), %rsi     # 0x82880
movl $0xfbe, %edx            # imm = 0xFBE
leaq 0x25c2a(%rip), %rcx     # 0x84a45
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x5ee2e
jmp 0x5ee4d
leaq 0x17610(%rip), %rdi     # 0x76445
leaq 0x23a44(%rip), %rsi     # 0x82880
movl $0xfbf, %edx            # imm = 0xFBF
leaq 0x25bfd(%rip), %rcx     # 0x84a45
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x1, %edx
callq 0x82f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5ee8f
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq 0x25c03(%rip), %rdx     # 0x84a90
callq *%rax
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: check_assignable
static ParserASTNode * _check_assignable(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserSymbol *symbol
) {
	assert(ctx);
	assert(node);
	assert(symbol);
	assert(symbol->type == BE_SYM_VAR);

	ParserASTNode *node_type = BE_VAR_SYMBOL_GET_TYPE_NODE(symbol);
	if (!_is_assignable_type(ctx, node_type)) {
		_SYNERR_NODE(ctx, node, "variable is not assignable.");
	}

	return node_type;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5eec0
jmp 0x5eedf
leaq 0x2129a(%rip), %rdi     # 0x80161
leaq 0x239b2(%rip), %rsi     # 0x82880
movl $0x102b, %edx           # imm = 0x102B
leaq 0x25bca(%rip), %rcx     # 0x84aa4
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5eee8
jmp 0x5ef07
leaq 0x1766d(%rip), %rdi     # 0x7655c
leaq 0x2398a(%rip), %rsi     # 0x82880
movl $0x102c, %edx           # imm = 0x102C
leaq 0x25ba2(%rip), %rcx     # 0x84aa4
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5ef10
jmp 0x5ef2f
leaq 0x17191(%rip), %rdi     # 0x760a8
leaq 0x23962(%rip), %rsi     # 0x82880
movl $0x102d, %edx           # imm = 0x102D
leaq 0x25b7a(%rip), %rcx     # 0x84aa4
callq 0x30a0
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5ef3a
jmp 0x5ef59
leaq 0x25bb6(%rip), %rdi     # 0x84af7
leaq 0x23938(%rip), %rsi     # 0x82880
movl $0x102e, %edx           # imm = 0x102E
leaq 0x25b50(%rip), %rcx     # 0x84aa4
callq 0x30a0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5f260
testb $0x1, %al
jne 0x5efa4
leaq -0x420(%rbp), %rdi
leaq 0x25b8e(%rip), %rsi     # 0x84b12
movb $0x0, %al
callq 0x3160
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
callq *%rax
movq -0x20(%rbp), %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: check_param_combination2
static void _check_param_combination2(
	ParserContext *ctx,
	ParserASTNode *node,		// 用来报错时提供错误位置。
	ParserASTNode *node_type1,
	ParserASTNode *node_type2
) {
	assert(ctx);
	assert(node);
	assert(node_type1);
	assert(node_type2);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5f174
jmp 0x5f193
leaq 0x20fe6(%rip), %rdi     # 0x80161
leaq 0x236fe(%rip), %rsi     # 0x82880
movl $0x103e, %edx           # imm = 0x103E
leaq 0x25aa3(%rip), %rcx     # 0x84c31
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5f19c
jmp 0x5f1bb
leaq 0x173b9(%rip), %rdi     # 0x7655c
leaq 0x236d6(%rip), %rsi     # 0x82880
movl $0x103f, %edx           # imm = 0x103F
leaq 0x25a7b(%rip), %rcx     # 0x84c31
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5f1c4
jmp 0x5f1e3
leaq 0x25ac9(%rip), %rdi     # 0x84c94
leaq 0x236ae(%rip), %rsi     # 0x82880
movl $0x1040, %edx           # imm = 0x1040
leaq 0x25a53(%rip), %rcx     # 0x84c31
callq 0x30a0
cmpq $0x0, -0x20(%rbp)
je 0x5f1ec
jmp 0x5f20b
leaq 0x25aac(%rip), %rdi     # 0x84c9f
leaq 0x23686(%rip), %rsi     # 0x82880
movl $0x1041, %edx           # imm = 0x1041
leaq 0x25a2b(%rip), %rcx     # 0x84c31
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
callq 0x50c90
testb $0x1, %al
jne 0x5f253
leaq -0x420(%rbp), %rdi
leaq 0x25a77(%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 -0x420(%rbp), %rdx
callq *%rax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_assignable_type
static bool _is_assignable_type(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	
	uint8_t type = _get_type_by_type_node(ctx, node);

	switch (type) {
		case BE_TYPE_CHAR:
		case BE_TYPE_INT8:
		case BE_TYPE_INT16:
		case BE_TYPE_INT32:
		case BE_TYPE_INT64:
		case BE_TYPE_UINT8:
		case BE_TYPE_UINT16:
		case BE_TYPE_UINT32:
		case BE_TYPE_UINT64:
		case BE_TYPE_FLOAT:
		case BE_TYPE_DOUBLE:
		case BE_TYPE_POINTER: {
			return true;
		}
		default: {
			return false;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5f279
jmp 0x5f298
leaq 0x20ee1(%rip), %rdi     # 0x80161
leaq 0x235f9(%rip), %rsi     # 0x82880
movl $0x100c, %edx           # imm = 0x100C
leaq 0x2589b(%rip), %rcx     # 0x84b2e
callq 0x30a0
cmpq $0x0, -0x18(%rbp)
je 0x5f2a1
jmp 0x5f2c0
leaq 0x172b4(%rip), %rdi     # 0x7655c
leaq 0x235d1(%rip), %rsi     # 0x82880
movl $0x100d, %edx           # imm = 0x100D
leaq 0x25873(%rip), %rcx     # 0x84b2e
callq 0x30a0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56560
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x20(%rbp)
decl %eax
subl $0xb, %eax
jb 0x5f2ea
jmp 0x5f2e0
movl -0x20(%rbp), %eax
subl $0x10, %eax
jne 0x5f2f0
jmp 0x5f2ea
movb $0x1, -0x1(%rbp)
jmp 0x5f2f4
movb $0x0, -0x1(%rbp)
movb -0x1(%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: get_symbol_by_id_node
static ParserSymbol * _get_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5f319
jmp 0x5f338
leaq 0x20e41(%rip), %rdi     # 0x80161
leaq 0x23559(%rip), %rsi     # 0x82880
movl $0xffa, %edx            # imm = 0xFFA
leaq 0x258b7(%rip), %rcx     # 0x84bea
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x5f341
jmp 0x5f360
leaq 0x17214(%rip), %rdi     # 0x7655c
leaq 0x23531(%rip), %rsi     # 0x82880
movl $0xffb, %edx            # imm = 0xFFB
leaq 0x2588f(%rip), %rcx     # 0x84bea
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x5f36e
jmp 0x5f38d
leaq 0x170d0(%rip), %rdi     # 0x76445
leaq 0x23504(%rip), %rsi     # 0x82880
movl $0xffc, %edx            # imm = 0xFFC
leaq 0x25862(%rip), %rcx     # 0x84bea
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
xorl %edx, %edx
callq 0x82f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5f3cc
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq 0x256c6(%rip), %rdx     # 0x84a90
callq *%rax
movq -0x18(%rbp), %rax
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_struct_symbol_by_id_node
static ParserSymbol * _get_struct_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x61279
jmp 0x61298
leaq 0x1eee1(%rip), %rdi     # 0x80161
leaq 0x215f9(%rip), %rsi     # 0x82880
movl $0xfcf, %edx            # imm = 0xFCF
leaq 0x2491e(%rip), %rcx     # 0x85bb1
callq 0x30a0
cmpq $0x0, -0x10(%rbp)
je 0x612a1
jmp 0x612c0
leaq 0x152b4(%rip), %rdi     # 0x7655c
leaq 0x215d1(%rip), %rsi     # 0x82880
movl $0xfd0, %edx            # imm = 0xFD0
leaq 0x248f6(%rip), %rcx     # 0x85bb1
callq 0x30a0
movq -0x10(%rbp), %rax
cmpl $0x200, (%rax)          # imm = 0x200
jne 0x612ce
jmp 0x612ed
leaq 0x15170(%rip), %rdi     # 0x76445
leaq 0x215a4(%rip), %rsi     # 0x82880
movl $0xfd1, %edx            # imm = 0xFD1
leaq 0x248c9(%rip), %rcx     # 0x85bb1
callq 0x30a0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movl $0x2, %edx
callq 0x82f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x6132f
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rsi
leaq 0x23763(%rip), %rdx     # 0x84a90
callq *%rax
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_init
OPTPARSE_API
void
optparse_init(struct optparse *options, char **argv)
{
    options->argv = argv;
    options->permute = 1;
    options->optind = 1;
    options->subopt = 0;
    options->optarg = 0;
    options->errmsg[0] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movb $0x0, 0x20(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_permute
static void
optparse_permute(struct optparse *options, int index)
{
    char *nonoption = options->argv[index];
    int i;
    for (i = index; i < options->optind - 1; i++)
        options->argv[i] = options->argv[i + 1];
    options->argv[options->optind - 1] = nonoption;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x28d3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2894
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_argtype
static int
optparse_argtype(const char *optstring, char c)
{
    int count = OPTPARSE_NONE;
    if (c == ':')
        return -1;
    for (; *optstring && c != *optstring; optstring++);
    if (!*optstring)
        return -1;
    if (optstring[1] == ':')
        count += optstring[2] == ':' ? 2 : 1;
    return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x3a, %eax
jne 0x292a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29ac
jmp 0x292c
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x2950
movsbl -0x11(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x2959
jmp 0x2969
jmp 0x295b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x292c
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x297b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x29ac
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x3a, %eax
jne 0x29a6
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x3a, %edx
cmovel %ecx, %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_error
static int
optparse_error(struct optparse *options, const char *msg, const char *data)
{
    unsigned p = 0;
    const char *sep = " -- '";
    while (*msg)
        options->errmsg[p++] = *msg++;
    while (*sep)
        options->errmsg[p++] = *sep++;
    while (p < sizeof(options->errmsg) - 2 && *data)
        options->errmsg[p++] = *data++;
    options->errmsg[p++] = '\'';
    options->errmsg[p++] = '\0';
    return '?';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq 0x88bb(%rip), %rax      # 0xb299
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2a13
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, 0x20(%rax,%rcx)
jmp 0x29e2
jmp 0x2a15
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x2a46
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, 0x20(%rax,%rcx)
jmp 0x2a15
jmp 0x2a48
movl -0x1c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq $0x3e, %rcx
movb %al, -0x29(%rbp)
jae 0x2a68
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2a71
jmp 0x2a99
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb (%rax), %dl
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x1c(%rbp)
movl %ecx, %ecx
movb %dl, 0x20(%rax,%rcx)
jmp 0x2a48
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl %ecx, %ecx
movb $0x27, 0x20(%rax,%rcx)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movl %ecx, %ecx
movb $0x0, 0x20(%rax,%rcx)
movl $0x3f, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_arg
OPTPARSE_API
char *
optparse_arg(struct optparse *options)
{
    char *option = options->argv[options->optind];
    options->subopt = 0;
    if (option != 0)
        options->optind++;
    return option;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movslq 0xc(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x2b0e
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_long_fallback
static int
optparse_long_fallback(struct optparse *options,
                       const struct optparse_long *longopts,
                       int *longindex)
{
    int result;
    char optstring[96 * 3 + 1]; /* 96 ASCII printable characters */
    optparse_from_long(longopts, optstring);
    result = optparse(options, optstring);
    if (longindex != 0) {
        *longindex = -1;
        if (result != -1) {
            int i;
            for (i = 0; !optparse_longopts_end(longopts, i); i++)
                if (longopts[i].shortname == options->optopt)
                    *longindex = i;
        }
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x4200
movq -0x8(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x24d0
movl %eax, -0x1c(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2e89
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
cmpl $-0x1, -0x1c(%rbp)
je 0x2e87
movl $0x0, -0x144(%rbp)
movq -0x10(%rbp), %rdi
movl -0x144(%rbp), %esi
callq 0x2f00
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2e48
jmp 0x2e85
movq -0x10(%rbp), %rax
movslq -0x144(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x2e72
movl -0x144(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
jmp 0x2e74
movl -0x144(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x144(%rbp)
jmp 0x2e2b
jmp 0x2e87
jmp 0x2e89
movl -0x1c(%rbp), %eax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_longopts_match
static int
optparse_longopts_match(const char *longname, const char *option)
{
    const char *a = option, *n = longname;
    if (longname == 0)
        return 0;
    for (; *a && *n && *a != '='; a++, n++)
        if (*a != *n)
            return 0;
    return *n == '\0' && (*a == '\0' || *a == '=');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2f7f
movl $0x0, -0x4(%rbp)
jmp 0x3036
jmp 0x2f81
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x2fb3
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x2fb3
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2fbc
jmp 0x2ff3
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
movq -0x28(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
je 0x2fd7
movl $0x0, -0x4(%rbp)
jmp 0x3036
jmp 0x2fd9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2f81
movq -0x28(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x2a(%rbp)
jne 0x302b
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x2b(%rbp)
je 0x3025
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
sete %al
movb %al, -0x2b(%rbp)
movb -0x2b(%rbp), %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_longopts_arg
static char *
optparse_longopts_arg(char *option)
{
    for (; *option && *option != '='; option++);
    if (*option == '=')
        return option + 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x3069
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x3072
jmp 0x3082
jmp 0x3074
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x3048
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x309c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x30a4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/enchive.c
// Function: fatal
static void
fatal(const char *fmt, ...)
{
    unsigned i;
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "enchive: ");
    vfprintf(stderr, fmt, ap);
    fputc('\n', stderr);
    for (i = 0; i < sizeof(cleanup) / sizeof(*cleanup); i++) {
        if (cleanup[i].file)
            fclose(cleanup[i].file);
        if (cleanup[i].name)
            remove(cleanup[i].name);
    }
    va_end(ap);
    exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x3378
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp)
movq %rcx, -0xc8(%rbp)
movq %rdx, -0xd0(%rbp)
movq %rsi, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xe0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xbc2e(%rip), %rax      # 0xeff8
movq (%rax), %rdi
leaq 0x7ecb(%rip), %rsi      # 0xb29f
movb $0x0, %al
callq 0x21f0
movq 0xbc16(%rip), %rax      # 0xeff8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdx
callq 0x22e0
movq 0xbbff(%rip), %rax      # 0xeff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2190
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x2, %rax
jae 0x348d
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xbe9e(%rip), %rax      # 0xf2c0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
je 0x344c
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xbe84(%rip), %rax      # 0xf2c0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2100
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xbe68(%rip), %rax      # 0xf2c0
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x3480
movl -0xc(%rbp), %eax
movl %eax, %ecx
leaq 0xbe4f(%rip), %rax      # 0xf2c0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x2090
jmp 0x3482
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x340d
leaq -0x30(%rbp), %rax
movl $0x1, %edi
callq 0x2310
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/enchive.c
// Function: parse_command
static enum command
parse_command(char *command)
{
    int found = COMMAND_UNKNOWN;
    size_t len = strlen(command);
    int ncommands = sizeof(command_names) / sizeof(*command_names);
    int i;
    for (i = 0; i < ncommands; i++) {
        if (strncmp(command, command_names[i], len) == 0) {
            if (found >= 0)
                return COMMAND_AMBIGUOUS;
            found = i;
        }
    }
    return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0xfffffffe, -0x14(%rbp) # imm = 0xFFFFFFFE
movq -0x10(%rbp), %rdi
callq 0x2110
movq %rax, -0x20(%rbp)
movl $0x4, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x356c
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rax
leaq 0x7c1b(%rip), %rsi      # 0xb150
imulq $0xc, %rax, %rax
addq %rax, %rsi
movq -0x20(%rbp), %rdx
callq 0x20a0
cmpl $0x0, %eax
jne 0x355f
cmpl $0x0, -0x14(%rbp)
jl 0x3559
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3572
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x3561
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x351e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/enchive.c
// Function: command_fingerprint
static void
command_fingerprint(struct optparse *options)
{
    static const struct optparse_long fingerprint[] = {
        {0, 0, 0}
    };

    char *pubfile = dupstr(global_pubkey);
    uint8_t public[32];

    int option;
    while ((option = optparse_long(options, fingerprint, 0)) != -1) {
        switch (option) {
            default:
                fatal("%s", options->errmsg);
        }
    }

    if (!pubfile)
        pubfile = default_pubfile();
    load_pubkey(pubfile, public);
    free(pubfile);

    print_fingerprint(public);
    putchar('\n');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0xb80d(%rip), %rdi      # 0xf2b0
callq 0x4320
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x7709(%rip), %rsi      # 0xb1c0
xorl %eax, %eax
movl %eax, %edx
callq 0x2b20
movl %eax, -0x34(%rbp)
cmpl $-0x1, %eax
je 0x3ae0
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
leaq 0x8347(%rip), %rdi      # 0xbe1e
movb $0x0, %al
callq 0x3340
jmp 0x3aac
cmpq $0x0, -0x10(%rbp)
jne 0x3af0
callq 0x4390
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x63f0
movq -0x10(%rbp), %rdi
callq 0x2040
leaq -0x30(%rbp), %rdi
callq 0x4c60
movl $0xa, %edi
callq 0x2050
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/optparse.h
// Function: optparse_from_long
static void
optparse_from_long(const struct optparse_long *longopts, char *optstring)
{
    char *p = optstring;
    int i;
    for (i = 0; !optparse_longopts_end(longopts, i); i++) {
        if (longopts[i].shortname) {
            int a;
            *p++ = longopts[i].shortname;
            for (a = 0; a < (int)longopts[i].argtype; a++)
                *p++ = ':';
        }
    }
    *p = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2f00
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x423c
jmp 0x42c3
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x0, 0x8(%rax)
je 0x42b3
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpl 0xc(%rcx), %eax
jge 0x42b1
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x3a, (%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x427d
jmp 0x42b3
jmp 0x42b5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x421f
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/enchive.c
// Function: dupstr
static char *
dupstr(const char *s)
{
    char *copy = 0;
    if (s) {
        size_t len = strlen(s) + 1;
        copy = malloc(len);
        if (!copy)
            fatal("out of memory");
        memcpy(copy, s, len);
    }
    return copy;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x437f
movq -0x8(%rbp), %rdi
callq 0x2110
addq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2240
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x436e
leaq 0x749b(%rip), %rdi      # 0xb802
movb $0x0, %al
callq 0x3340
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x2230
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/enchive.c
// Function: file_exists
static int
file_exists(char *filename)
{
    FILE *f = fopen(filename, "r");
    if (f) {
        fclose(f);
        return 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6fe2(%rip), %rsi      # 0xb3a9
callq 0x22d0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x43e9
movq -0x18(%rbp), %rdi
callq 0x2100
movl $0x1, -0x4(%rbp)
jmp 0x43f0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/enchive.c
// Function: generate_secret
static void
generate_secret(uint8_t *s)
{
    secure_entropy(s, 32);
    s[0] &= 248;
    s[31] &= 127;
    s[31] |= 64;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x20, %esi
callq 0x6210
movq -0x8(%rbp), %rax
movzbl (%rax), %ecx
andl $0xf8, %ecx
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movzbl 0x1f(%rax), %ecx
andl $0x7f, %ecx
movb %cl, 0x1f(%rax)
movq -0x8(%rbp), %rax
movzbl 0x1f(%rax), %ecx
orl $0x40, %ecx
movb %cl, 0x1f(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/skeeto[P]enchive/src/enchive.c
// Function: print_fingerprint
static void
print_fingerprint(const uint8_t *key)
{
    int i;
    uint8_t hash[32];
    SHA256_CTX sha[1];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0xa5d0
leaq -0xa0(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x20, %edx
callq 0xa650
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa6f0
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x4d43
movl -0xc(%rbp), %eax
addl $0x0, %eax
cltq
movzbl -0x30(%rbp,%rax), %eax
shlq $0x18, %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl -0x30(%rbp,%rcx), %ecx
shlq $0x10, %rcx
orq %rcx, %rax
movl -0xc(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movzbl -0x30(%rbp,%rcx), %ecx
shlq $0x8, %rcx
orq %rcx, %rax
movl -0xc(%rbp), %ecx
addl $0x3, %ecx
movslq %ecx, %rcx
movzbl -0x30(%rbp,%rcx), %ecx
shlq $0x0, %rcx
orq %rcx, %rax
movq %rax, -0xa8(%rbp)
movl -0xc(%rbp), %ecx
leaq 0x6ee6(%rip), %rsi      # 0xbbf8
leaq 0x6fb3(%rip), %rax      # 0xbccc
cmpl $0x0, %ecx
cmovneq %rax, %rsi
movq -0xa8(%rbp), %rdx
leaq 0x6f96(%rip), %rdi      # 0xbcc4
movb $0x0, %al
callq 0x2140
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
jmp 0x4ca7
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)