LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_struct_member_symbol
static ParserSymbol * _get_struct_member_symbol(
	ParserContext *ctx,
	ParserASTNode *node_struct_id,
	ParserASTNode *node_struct_member_id
) {
	assert(ctx);
	assert(node_struct_id);
	assert(node_struct_id->type == BE_NODE_IDENTIFIER);
	assert(node_struct_member_id);
	assert(node_struct_member_id->type == BE_NODE_IDENTIFIER);

	ParserSymbol *symbol_struct = _get_struct_symbol_by_id_node(
		ctx, node_struct_id
	);

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

	return symbol_struct_member;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x28150
movq %rsi, %r15
testq %rsi, %rsi
je 0x2816f
cmpl $0x200, (%r15)          # imm = 0x200
jne 0x2818e
movq %rdx, %r14
testq %rdx, %rdx
je 0x281ad
cmpl $0x200, (%r14)          # imm = 0x200
jne 0x281cc
movq %rdi, %rbx
movq 0x10(%r15), %rcx
pushq $0x2
popq %rdx
movq %r15, %rsi
callq 0x6779
movq %rax, %r12
testq %rax, %rax
jne 0x28119
movq 0x10(%r15), %rsi
leaq 0x22f5a(%rip), %rdx     # 0x4b06d
movq %rbx, %rdi
callq *0x50(%rbx)
movq 0x10(%r14), %rcx
pushq $0x5
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6ca6
movq %rax, %r15
testq %rax, %rax
jne 0x28144
movq 0x10(%r14), %rsi
leaq 0x22f2f(%rip), %rdx     # 0x4b06d
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14c7d(%rip), %rdi     # 0x3cdd4
leaq 0x21012(%rip), %rsi     # 0x49170
leaq 0x23e60(%rip), %rcx     # 0x4bfc5
movl $0xfe2, %edx            # imm = 0xFE2
callq 0x30a0
leaq 0x23eaa(%rip), %rdi     # 0x4c020
leaq 0x20ff3(%rip), %rsi     # 0x49170
leaq 0x23e41(%rip), %rcx     # 0x4bfc5
movl $0xfe3, %edx            # imm = 0xFE3
callq 0x30a0
leaq 0x23e9a(%rip), %rdi     # 0x4c02f
leaq 0x20fd4(%rip), %rsi     # 0x49170
leaq 0x23e22(%rip), %rcx     # 0x4bfc5
movl $0xfe4, %edx            # imm = 0xFE4
callq 0x30a0
leaq 0x23ea6(%rip), %rdi     # 0x4c05a
leaq 0x20fb5(%rip), %rsi     # 0x49170
leaq 0x23e03(%rip), %rcx     # 0x4bfc5
movl $0xfe5, %edx            # imm = 0xFE5
callq 0x30a0
leaq 0x23e9d(%rip), %rdi     # 0x4c070
leaq 0x20f96(%rip), %rsi     # 0x49170
leaq 0x23de4(%rip), %rcx     # 0x4bfc5
movl $0xfe6, %edx            # imm = 0xFE6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: expr_wrapper
static void _expr_wrapper(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_EXPR);

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

	_expr(ctx, child);

	BE_EXPR_AST_NODE_COPY(node, child);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x2b11b
movq %rsi, %rbx
cmpl $0xe00, (%rsi)          # imm = 0xE00
jne 0x2b13a
movq 0x48(%rbx), %rax
movq (%rax), %r14
movq %r14, %rsi
callq 0x2acf8
movups 0x60(%r14), %xmm0
movups 0x70(%r14), %xmm1
movups 0x80(%r14), %xmm2
movups %xmm2, 0x80(%rbx)
movups %xmm1, 0x70(%rbx)
movups %xmm0, 0x60(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x12de8(%rip), %rdi     # 0x3df0a
leaq 0x1e047(%rip), %rsi     # 0x49170
leaq 0x1fa31(%rip), %rcx     # 0x4ab61
movl $0xe64, %edx            # imm = 0xE64
callq 0x30a0
leaq 0x1fa55(%rip), %rdi     # 0x4ab96
leaq 0x1e028(%rip), %rsi     # 0x49170
leaq 0x1fa12(%rip), %rcx     # 0x4ab61
movl $0xe65, %edx            # imm = 0xE65
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_integer_type_node
static bool _is_integer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_integer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2ba48
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2ba67
movb 0x60(%rdi), %al
decb %al
cmpb $0x9, %al
setb %al
popq %rbp
retq
leaq 0x124bb(%rip), %rdi     # 0x3df0a
leaq 0x1d71a(%rip), %rsi     # 0x49170
leaq 0x1ee02(%rip), %rcx     # 0x4a85f
movl $0x1bc, %edx            # imm = 0x1BC
callq 0x30a0
leaq 0x1e428(%rip), %rdi     # 0x49e96
leaq 0x1d6fb(%rip), %rsi     # 0x49170
leaq 0x1ede3(%rip), %rcx     # 0x4a85f
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_pointer_type_node
static bool _is_pointer_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_pointer_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2baa6
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2bac5
cmpb $0x10, 0x60(%rdi)
sete %al
popq %rbp
retq
leaq 0x1245d(%rip), %rdi     # 0x3df0a
leaq 0x1d6bc(%rip), %rsi     # 0x49170
leaq 0x1ede2(%rip), %rcx     # 0x4a89d
movl $0x208, %edx            # imm = 0x208
callq 0x30a0
leaq 0x1e3ca(%rip), %rdi     # 0x49e96
leaq 0x1d69d(%rip), %rsi     # 0x49170
leaq 0x1edc3(%rip), %rcx     # 0x4a89d
movl $0x209, %edx            # imm = 0x209
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_primitive_type_node
static bool _is_primitive_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_primitive_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2bb07
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2bb26
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0x123fc(%rip), %rdi     # 0x3df0a
leaq 0x1d65b(%rip), %rsi     # 0x49170
leaq 0x1edbf(%rip), %rcx     # 0x4a8db
movl $0x22a, %edx            # imm = 0x22A
callq 0x30a0
leaq 0x1e369(%rip), %rdi     # 0x49e96
leaq 0x1d63c(%rip), %rsi     # 0x49170
leaq 0x1eda0(%rip), %rcx     # 0x4a8db
movl $0x22b, %edx            # imm = 0x22B
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_number_type_node
static bool _is_number_type_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));

	return _is_number_type(BE_EXPR_AST_NODE_GET_TYPE(node));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2f17f
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2f19e
movb 0x60(%rdi), %al
decb %al
cmpb $0xb, %al
setb %al
popq %rbp
retq
leaq 0xed84(%rip), %rdi      # 0x3df0a
leaq 0x19fe3(%rip), %rsi     # 0x49170
leaq 0x1acc5(%rip), %rcx     # 0x49e59
movl $0x1f7, %edx            # imm = 0x1F7
callq 0x30a0
leaq 0x1acf1(%rip), %rdi     # 0x49e96
leaq 0x19fc4(%rip), %rsi     # 0x49170
leaq 0x1aca6(%rip), %rcx     # 0x49e59
movl $0x1f8, %edx            # imm = 0x1F8
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_int64
static int64_t _get_constexpr_int64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

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

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

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2f9e6
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2fa05
cmpb $0x0, 0x70(%rdi)
je 0x2fa24
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x2fa43
leaq 0x19501(%rip), %rcx     # 0x48e88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x2f9e4
movsbq 0x88(%rdi), %rax
jmp 0x2f9e4
cvttsd2si 0x88(%rdi), %rax
jmp 0x2f9e4
movl 0x88(%rdi), %eax
jmp 0x2f9e4
cvttss2si 0x88(%rdi), %rax
jmp 0x2f9e4
movzwl 0x88(%rdi), %eax
jmp 0x2f9e4
movswq 0x88(%rdi), %rax
jmp 0x2f9e4
movslq 0x88(%rdi), %rax
jmp 0x2f9e4
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0xe51d(%rip), %rdi      # 0x3df0a
leaq 0x1977c(%rip), %rsi     # 0x49170
leaq 0x1a9a9(%rip), %rcx     # 0x4a3a4
movl $0x69f, %edx            # imm = 0x69F
callq 0x30a0
leaq 0x1a48a(%rip), %rdi     # 0x49e96
leaq 0x1975d(%rip), %rsi     # 0x49170
leaq 0x1a98a(%rip), %rcx     # 0x4a3a4
movl $0x6a0, %edx            # imm = 0x6A0
callq 0x30a0
leaq 0x1a9b8(%rip), %rdi     # 0x4a3e3
leaq 0x1973e(%rip), %rsi     # 0x49170
leaq 0x1a96b(%rip), %rcx     # 0x4a3a4
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x30a0
leaq 0xb91f(%rip), %rdi      # 0x3b369
leaq 0x1971f(%rip), %rsi     # 0x49170
leaq 0x1a94c(%rip), %rcx     # 0x4a3a4
movl $0x6b6, %edx            # imm = 0x6B6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_uint64
static uint64_t _get_constexpr_uint64(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

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

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

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2fd35
cmpb $0x0, 0x70(%rdi)
je 0x2fd54
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x2fd73
leaq 0x1926b(%rip), %rcx     # 0x48f08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x88(%rdi), %rax
jmp 0x2fd33
movsbq 0x88(%rdi), %rax
jmp 0x2fd33
movsd 0x88(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x19460(%rip), %xmm0    # 0x49138
cvttsd2si %xmm0, %rax
jmp 0x2fd08
movl 0x88(%rdi), %eax
jmp 0x2fd33
movss 0x88(%rdi), %xmm0
cvttss2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subss 0x19441(%rip), %xmm0    # 0x49144
cvttss2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
jmp 0x2fd33
movzwl 0x88(%rdi), %eax
jmp 0x2fd33
movswq 0x88(%rdi), %rax
jmp 0x2fd33
movslq 0x88(%rdi), %rax
jmp 0x2fd33
movzbl 0x88(%rdi), %eax
popq %rbp
retq
leaq 0x1a15a(%rip), %rdi     # 0x49e96
leaq 0x1942d(%rip), %rsi     # 0x49170
leaq 0x1a95e(%rip), %rcx     # 0x4a6a8
movl $0x6d9, %edx            # imm = 0x6D9
callq 0x30a0
leaq 0x1a688(%rip), %rdi     # 0x4a3e3
leaq 0x1940e(%rip), %rsi     # 0x49170
leaq 0x1a93f(%rip), %rcx     # 0x4a6a8
movl $0x6da, %edx            # imm = 0x6DA
callq 0x30a0
leaq 0xb5ef(%rip), %rdi      # 0x3b369
leaq 0x193ef(%rip), %rsi     # 0x49170
leaq 0x1a920(%rip), %rcx     # 0x4a6a8
movl $0x6ef, %edx            # imm = 0x6EF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_constexpr_float
static float _get_constexpr_float(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(BE_IS_EXPR_NODE(node->type));
	assert(BE_EXPR_AST_NODE_GET_CONSTANT(node));

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

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

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x2ff0e
cmpb $0x0, 0x70(%rdi)
je 0x2ff2d
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xa, %eax
ja 0x2ff4c
leaq 0x19106(%rip), %rcx     # 0x48f88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl 0x88(%rdi), %eax
jmp 0x2fed4
cvtsi2ssq 0x88(%rdi), %xmm0
jmp 0x2ff0c
movss 0x88(%rdi), %xmm0
jmp 0x2ff0c
movswl 0x88(%rdi), %eax
jmp 0x2fed4
cvtsi2ssl 0x88(%rdi), %xmm0
jmp 0x2ff0c
movl 0x88(%rdi), %eax
jmp 0x2fef0
movzbl 0x88(%rdi), %eax
jmp 0x2fed4
movzwl 0x88(%rdi), %eax
cvtsi2ss %eax, %xmm0
jmp 0x2ff0c
cvtsd2ss 0x88(%rdi), %xmm0
jmp 0x2ff0c
movq 0x88(%rdi), %rax
testq %rax, %rax
js 0x2fef7
cvtsi2ss %rax, %xmm0
jmp 0x2ff0c
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
popq %rbp
retq
leaq 0x19f81(%rip), %rdi     # 0x49e96
leaq 0x19254(%rip), %rsi     # 0x49170
leaq 0x1a816(%rip), %rcx     # 0x4a739
movl $0x712, %edx            # imm = 0x712
callq 0x30a0
leaq 0x1a4af(%rip), %rdi     # 0x4a3e3
leaq 0x19235(%rip), %rsi     # 0x49170
leaq 0x1a7f7(%rip), %rcx     # 0x4a739
movl $0x713, %edx            # imm = 0x713
callq 0x30a0
leaq 0xb416(%rip), %rdi      # 0x3b369
leaq 0x19216(%rip), %rsi     # 0x49170
leaq 0x1a7d8(%rip), %rcx     # 0x4a739
movl $0x727, %edx            # imm = 0x727
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: calc_pointer_type_increment_size
static size_t _calc_pointer_type_increment_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);
	assert(node_type->type == BE_NODE_TYPE_POINTER);
	assert(node_type->nchilds == 1);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdx, %rdx
je 0x3017e
cmpl $0x440, (%rdx)          # imm = 0x440
jne 0x3019d
cmpl $0x1, 0x44(%rdx)
jne 0x301bc
movq 0x48(%rdx), %rax
movq (%rax), %rdx
popq %rbp
jmp 0x27acb
leaq 0x1b664(%rip), %rdi     # 0x4b7e9
leaq 0x18fe4(%rip), %rsi     # 0x49170
leaq 0x1a670(%rip), %rcx     # 0x4a803
movl $0x545, %edx            # imm = 0x545
callq 0x30a0
leaq 0x10461(%rip), %rdi     # 0x40605
leaq 0x18fc5(%rip), %rsi     # 0x49170
leaq 0x1a651(%rip), %rcx     # 0x4a803
movl $0x546, %edx            # imm = 0x546
callq 0x30a0
leaq 0x19533(%rip), %rdi     # 0x496f6
leaq 0x18fa6(%rip), %rsi     # 0x49170
leaq 0x1a632(%rip), %rcx     # 0x4a803
movl $0x547, %edx            # imm = 0x547
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: is_compatible_pointer_type
static bool _is_compatible_pointer_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

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

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

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

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

	#undef	_A
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0x1(%rdi), %eax
shll $0x8, %eax
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x30514
cmpb $0x0, 0x70(%rdi)
je 0x30533
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xf, %eax
ja 0x30552
leaq 0x18b67(%rip), %rcx     # 0x49020
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x0, 0x88(%rdi)
jmp 0x304e6
cmpq $0x0, 0x88(%rdi)
jmp 0x304e6
cmpw $0x0, 0x88(%rdi)
jmp 0x304e6
cmpl $0x0, 0x88(%rdi)
setne %al
popq %rbp
retq
xorpd %xmm0, %xmm0
cmpneqsd 0x88(%rdi), %xmm0
movq %xmm0, %rax
jmp 0x3050f
xorps %xmm0, %xmm0
cmpneqss 0x88(%rdi), %xmm0
movd %xmm0, %eax
andl $0x1, %eax
jmp 0x304e9
leaq 0x1997b(%rip), %rdi     # 0x49e96
leaq 0x18c4e(%rip), %rsi     # 0x49170
leaq 0x1a5be(%rip), %rcx     # 0x4aae7
movl $0x758, %edx            # imm = 0x758
callq 0x30a0
leaq 0x19ea9(%rip), %rdi     # 0x4a3e3
leaq 0x18c2f(%rip), %rsi     # 0x49170
leaq 0x1a59f(%rip), %rcx     # 0x4aae7
movl $0x759, %edx            # imm = 0x759
callq 0x30a0
leaq 0xae10(%rip), %rdi      # 0x3b369
leaq 0x18c10(%rip), %rsi     # 0x49170
leaq 0x1a580(%rip), %rcx     # 0x4aae7
movl $0x76e, %edx            # imm = 0x76E
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: _func_process_label
static void __func_process_label(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *current
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_STATS_BLOCK);
	assert(current);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0xb00, (%rsi)          # imm = 0xB00
jne 0x3090d
movq %rdx, %rbx
testq %rdx, %rdx
je 0x3092c
movq %rsi, %r14
movq %rdi, %r15
cmpl $0xb30, (%rbx)          # imm = 0xB30
jne 0x308e0
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
pushq $0x4
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6820
xorl %r12d, %r12d
movslq 0x44(%rbx), %rax
cmpq %rax, %r12
jge 0x30904
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x30898
incq %r12
jmp 0x308e3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a602(%rip), %rdi     # 0x4af16
leaq 0x18855(%rip), %rsi     # 0x49170
leaq 0x1a616(%rip), %rcx     # 0x4af38
movl $0x1781, %edx           # imm = 0x1781
callq 0x30a0
leaq 0x1a652(%rip), %rdi     # 0x4af85
leaq 0x18836(%rip), %rsi     # 0x49170
leaq 0x1a5f7(%rip), %rcx     # 0x4af38
movl $0x1782, %edx           # imm = 0x1782
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_var_symbol_by_id_node
static ParserSymbol * _get_var_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x3099e
movq %rsi, %r14
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x309bd
movq %rdi, %rbx
movq 0x10(%r14), %rcx
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x6779
movq %rax, %r15
testq %rax, %rax
jne 0x30990
movq 0x10(%r14), %rsi
leaq 0x1a6e3(%rip), %rdx     # 0x4b06d
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd565(%rip), %rdi      # 0x3df0a
leaq 0x187c4(%rip), %rsi     # 0x49170
leaq 0x1a66f(%rip), %rcx     # 0x4b022
movl $0xfbe, %edx            # imm = 0xFBE
callq 0x30a0
leaq 0xd42f(%rip), %rdi      # 0x3ddf3
leaq 0x187a5(%rip), %rsi     # 0x49170
leaq 0x1a650(%rip), %rcx     # 0x4b022
movl $0xfbf, %edx            # imm = 0xFBF
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_param_info
static void _get_param_info(
	ParserContext *ctx,
	ParserASTNode *node_param,
	_GetParamInfoResult *result
) {
	assert(ctx);
	assert(node_param);
	assert(result);

	ParserASTNode *node_type = NULL;
	uint8_t type = BE_TYPE_UNKNOWN;

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
testq %rsi, %rsi
je 0x30aa2
movq %rdx, %rbx
testq %rdx, %rdx
je 0x30ac1
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %eax
cmpl $0xe00, %eax            # imm = 0xE00
je 0x30a38
cmpl $0x200, %eax            # imm = 0x200
jne 0x30ae0
movq %r15, %rdi
movq %r14, %rsi
callq 0x30ba0
movl (%rax), %ecx
cmpl $0x3, %ecx
je 0x30a49
cmpl $0x1, %ecx
jne 0x30a4f
movq 0x38(%rax), %r14
jmp 0x30a86
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b0cf
movq 0x68(%r14), %r14
jmp 0x30a86
movq 0x48(%rax), %r14
jmp 0x30a86
movups 0x1a761(%rip), %xmm0    # 0x4b1b7
leaq -0x420(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movups 0x1a73f(%rip), %xmm0    # 0x4b1a7
movaps %xmm0, (%rdx)
movabsq $0x2e656d616e206e, %rax # imm = 0x2E656D616E206E
movq %rax, 0x1f(%rdx)
movq %r15, %rdi
movq %r14, %rsi
callq *0x58(%r15)
xorl %r14d, %r14d
movq %r14, %rdi
callq 0x2f1bd
movq %r14, (%rbx)
movb %al, 0x8(%rbx)
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a6ec(%rip), %rdi     # 0x4b195
leaq 0x186c0(%rip), %rsi     # 0x49170
leaq 0x1a690(%rip), %rcx     # 0x4b147
movl $0x105e, %edx           # imm = 0x105E
callq 0x30a0
leaq 0x1a6d8(%rip), %rdi     # 0x4b1a0
leaq 0x186a1(%rip), %rsi     # 0x49170
leaq 0x1a671(%rip), %rcx     # 0x4b147
movl $0x105f, %edx           # imm = 0x105F
callq 0x30a0
leaq 0xa882(%rip), %rdi      # 0x3b369
leaq 0x18682(%rip), %rsi     # 0x49170
leaq 0x1a652(%rip), %rcx     # 0x4b147
movl $0x1075, %edx           # imm = 0x1075
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: check_param_combination2
static void _check_param_combination2(
	ParserContext *ctx,
	ParserASTNode *node,		// 用来报错时提供错误位置。
	ParserASTNode *node_type1,
	ParserASTNode *node_type2
) {
	assert(ctx);
	assert(node);
	assert(node_type1);
	assert(node_type2);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
testq %rdx, %rdx
je 0x30b62
testq %rcx, %rcx
je 0x30b81
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x1
popq %rax
movq %rdx, %rsi
movq %rcx, %rdx
movl %eax, %ecx
callq 0x2bb45
testb %al, %al
jne 0x30b56
movups 0x1a765(%rip), %xmm0    # 0x4b29d
leaq -0x410(%rbp), %rdx
movups %xmm0, 0xf(%rdx)
movups 0x1a744(%rip), %xmm0    # 0x4b28e
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x58(%rbx)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a70f(%rip), %rdi     # 0x4b278
leaq 0x18600(%rip), %rsi     # 0x49170
leaq 0x1a69e(%rip), %rcx     # 0x4b215
movl $0x1040, %edx           # imm = 0x1040
callq 0x30a0
leaq 0x1a6fb(%rip), %rdi     # 0x4b283
leaq 0x185e1(%rip), %rsi     # 0x49170
leaq 0x1a67f(%rip), %rcx     # 0x4b215
movl $0x1041, %edx           # imm = 0x1041
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: get_symbol_by_id_node
static ParserSymbol * _get_symbol_by_id_node(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == BE_NODE_IDENTIFIER);

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

	return symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x30bf2
movq %rsi, %r14
cmpl $0x200, (%rsi)          # imm = 0x200
jne 0x30c11
movq %rdi, %rbx
movq 0x10(%r14), %rcx
movq %r14, %rsi
xorl %edx, %edx
callq 0x6779
movq %rax, %r15
testq %rax, %rax
jne 0x30be4
movq 0x10(%r14), %rsi
leaq 0x1a48f(%rip), %rdx     # 0x4b06d
movq %rbx, %rdi
callq *0x50(%rbx)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd311(%rip), %rdi      # 0x3df0a
leaq 0x18570(%rip), %rsi     # 0x49170
leaq 0x1a5c7(%rip), %rcx     # 0x4b1ce
movl $0xffb, %edx            # imm = 0xFFB
callq 0x30a0
leaq 0xd1db(%rip), %rdi      # 0x3ddf3
leaq 0x18551(%rip), %rsi     # 0x49170
leaq 0x1a5a8(%rip), %rcx     # 0x4b1ce
movl $0xffc, %edx            # imm = 0xFFC
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/Ihsoh[P]ilang/compiler/backend/semantics.c
// Function: check_stat_i_ci
static void _check_stat_i_ci(
	ParserContext *ctx,
	ParserASTNode *node,
	uint32_t node_type,
	_ResultCheckStat_I_CI *result
) {
	assert(ctx);
	assert(node);
	assert(node->type == node_type);
	assert(node->nchilds == 2);
	assert(result);

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl %edx, (%rsi)
jne 0x30e26
movq %rsi, %r14
cmpl $0x2, 0x44(%rsi)
jne 0x30e45
movq %rcx, %rbx
testq %rcx, %rcx
je 0x30e64
movq 0x48(%r14), %rax
movq (%rax), %r12
cmpl $0x200, (%r12)          # imm = 0x200
jne 0x30e83
movq %rdi, %r15
movq %r12, %rsi
callq 0x3094b
movq 0x38(%rax), %r13
movq 0x48(%r14), %rax
movq 0x8(%rax), %rsi
movq %rsi, -0x30(%rbp)
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x309dc
movq %r12, (%rbx)
movq %r13, 0x8(%rbx)
movq %r13, %rdi
callq 0x2f1bd
movb %al, 0x10(%rbx)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x27acb
movq %rax, 0x18(%rbx)
movq -0x30(%rbp), %rax
movq %rax, 0x20(%rbx)
leaq -0x40(%rbp), %rax
movq (%rax), %rdx
movq %rdx, 0x28(%rbx)
movb 0x8(%rax), %al
movb %al, 0x30(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x27acb
movq %rax, 0x38(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1a9ae(%rip), %rdi     # 0x4b7db
leaq 0x1833c(%rip), %rsi     # 0x49170
leaq 0x1a945(%rip), %rcx     # 0x4b780
movl $0x11df, %edx           # imm = 0x11DF
callq 0x30a0
leaq 0x187b9(%rip), %rdi     # 0x49605
leaq 0x1831d(%rip), %rsi     # 0x49170
leaq 0x1a926(%rip), %rcx     # 0x4b780
movl $0x11e0, %edx           # imm = 0x11E0
callq 0x30a0
leaq 0x1a335(%rip), %rdi     # 0x4b1a0
leaq 0x182fe(%rip), %rsi     # 0x49170
leaq 0x1a907(%rip), %rcx     # 0x4b780
movl $0x11e1, %edx           # imm = 0x11E1
callq 0x30a0
leaq 0xcee1(%rip), %rdi      # 0x3dd6b
leaq 0x182df(%rip), %rsi     # 0x49170
leaq 0x1a8e8(%rip), %rcx     # 0x4b780
movl $0x11e4, %edx           # imm = 0x11E4
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O2/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:
movq (%rdi), %rax
movslq %esi, %rdx
movq (%rax,%rdx,8), %rax
movslq 0xc(%rdi), %rcx
leaq -0x1(%rcx), %rsi
movq (%rdi), %r8
cmpq %rsi, %rdx
jge 0x267f
movq 0x8(%r8,%rdx,8), %r9
movq %r9, (%r8,%rdx,8)
incq %rdx
jmp 0x2669
movq %rax, -0x8(%r8,%rcx,8)
retq
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
movb (%rsi,%rax), %cl
testb %cl, %cl
je 0x269b
movl %eax, %r8d
movb %cl, 0x20(%rdi,%r8)
incq %rax
jmp 0x2687
xorl %esi, %esi
leaq 0x4b15(%rip), %r8       # 0x71b9
movl %eax, %ecx
cmpq $0x5, %rsi
je 0x26cc
movb (%rsi,%r8), %r9b
incq %rsi
incl %eax
movb %r9b, 0x20(%rdi,%rcx)
jmp 0x26a4
movb (%rdx), %al
testb %al, %al
je 0x26d2
incq %rdx
movb %al, 0x20(%rdi,%rcx)
incq %rcx
cmpq $0x3d, %rcx
jbe 0x26bc
leal 0x1(%rcx), %eax
movb $0x27, 0x20(%rdi,%rcx)
movb $0x0, 0x20(%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/optparse.h
// Function: optparse_arg
OPTPARSE_API
char *
optparse_arg(struct optparse *options)
{
    char *option = options->argv[options->optind];
    options->subopt = 0;
    if (option != 0)
        options->optind++;
    return option;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x3b54
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x747d(%rip), %r15      # 0xaff8
movq (%r15), %rcx
leaq 0x363a(%rip), %rdi      # 0x71bf
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x2330
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x22e0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x2190
xorl %ebx, %ebx
leaq 0x764e(%rip), %r14      # 0xb200
cmpq $0x20, %rbx
je 0x3bdb
movq 0x8(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3bc7
callq 0x2100
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3bd5
callq 0x2090
addq $0x10, %rbx
jmp 0x3bb2
pushq $0x1
popq %rdi
callq 0x2310
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: dupstr
static char *
dupstr(const char *s)
{
    char *copy = 0;
    if (s) {
        size_t len = strlen(s) + 1;
        copy = malloc(len);
        if (!copy)
            fatal("out of memory");
        memcpy(copy, s, len);
    }
    return copy;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3c5e
movq %rdi, %rbx
callq 0x2110
movq %rax, %r14
incq %r14
movq %r14, %rdi
callq 0x2230
testq %rax, %rax
je 0x3c68
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2220
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x3ab3(%rip), %rdi      # 0x7722
xorl %eax, %eax
callq 0x3af1
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
pushq $0x20
popq %rsi
callq 0x4d97
andb $-0x8, (%rbx)
movb 0x1f(%rbx), %al
andb $0x3f, %al
orb $0x40, %al
movb %al, 0x1f(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: print_fingerprint
static void
print_fingerprint(const uint8_t *key)
{
    int i;
    uint8_t hash[32];
    SHA256_CTX sha[1];

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6aa8
pushq $0x20
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6ac8
movq %rsp, %rsi
movq %r14, %rdi
callq 0x6b28
leaq 0x32ba(%rip), %r14      # 0x7b0d
leaq 0x3387(%rip), %r15      # 0x7be1
leaq 0x3378(%rip), %rbx      # 0x7bd9
xorl %r12d, %r12d
cmpq $0xf, %r12
ja 0x488a
movl (%rsp,%r12), %edx
bswapl %edx
testq %r12, %r12
movq %r15, %rsi
cmoveq %r14, %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2140
addq $0x4, %r12
jmp 0x4864
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: storage_directory
static char *
storage_directory(char *file)
{
    static const char enchive[] = "/enchive/";
    static const char config[] = "/.config";
    char *xdg_config_home = getenv("XDG_CONFIG_HOME");
    char *path, *s;

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

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

    return path;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x2e8a(%rip), %rdi      # 0x773c
callq 0x2030
testq %rax, %rax
je 0x48de
cmpb $0x2f, (%rax)
jne 0x49b7
leaq 0x27d4(%rip), %rdx      # 0x70a0
pushq $0x3
popq %rdi
movq %rax, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x49d7
jmp 0x491a
leaq 0x2e62(%rip), %rdi      # 0x7747
callq 0x2030
testq %rax, %rax
je 0x49c0
cmpb $0x2f, (%rax)
jne 0x49c9
leaq 0x27a7(%rip), %rdx      # 0x70aa
leaq 0x2796(%rip), %rcx      # 0x70a0
pushq $0x4
popq %rdi
movq %rax, %rsi
movq %rbx, %r8
xorl %eax, %eax
callq 0x49d7
movq %rax, %rbx
leaq 0x1(%rax), %rdi
pushq $0x2f
popq %rbp
movl %ebp, %esi
callq 0x2130
movq %rax, %r15
movq %rsp, %r14
movl $0xf000, %r12d          # imm = 0xF000
testq %r15, %r15
je 0x4984
movb $0x0, (%r15)
movq %rbx, %rdi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x20b0
testl %eax, %eax
je 0x496e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
testl %eax, %eax
jne 0x4997
movl 0x18(%rsp), %eax
andl %r12d, %eax
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4997
movb $0x2f, (%r15)
incq %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x2130
movq %rax, %r15
jmp 0x4937
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2070
movl (%rax), %edi
callq 0x2350
leaq 0x2e01(%rip), %rdi      # 0x77ab
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3af1
leaq 0x2dcc(%rip), %rdi      # 0x778a
jmp 0x49d0
leaq 0x2d85(%rip), %rdi      # 0x774c
jmp 0x49d0
leaq 0x2da4(%rip), %rdi      # 0x7774
xorl %eax, %eax
callq 0x3af1
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: joinstr
static char *
joinstr(int n, ...)
{
    int i;
    va_list ap;
    char *p, *str;
    size_t len = 1;

    va_start(ap, n);
    for (i = 0; i < n; i++) {
        char *s = va_arg(ap, char *);
        len += strlen(s);
    }
    va_end(ap);

    p = str = malloc(len);
    if (!str)
        fatal("out of memory");

    va_start(ap, n);
    for (i = 0; i < n; i++) {
        char *s = va_arg(ap, char *);
        size_t slen = strlen(s);
        memcpy(p, s, slen);
        p += slen;
    }
    va_end(ap);

    *p = 0;
    return str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
leaq 0x20(%rsp), %r10
movq %rsi, 0x8(%r10)
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0x4a3c
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %r10, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movabsq $0x3000000008, %r14     # imm = 0x3000000008
movq %r14, (%rsp)
pushq $0x8
popq %r15
xorl %ebp, %ebp
testl %edi, %edi
cmovgl %edi, %ebp
pushq $0x1
popq %rbx
movl %ebp, %r12d
subl $0x1, %r12d
jb 0x4aaa
cmpl $0x28, %r15d
ja 0x4a91
movq %rax, %r13
movl %r15d, %eax
leaq 0x20(%rsp), %rcx
addq %rcx, %rax
addl $0x8, %r15d
movl %r15d, (%rsp)
jmp 0x4a9a
leaq 0x8(%rax), %r13
movq %r13, 0x8(%rsp)
movq (%rax), %rdi
callq 0x2110
addq %rax, %rbx
movq %r13, %rax
jmp 0x4a6d
movq %rbx, %rdi
callq 0x2230
testq %rax, %rax
je 0x4b4e
movq %rax, %rcx
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r14, (%rsp)
pushq $0x8
popq %rbx
movq %rcx, %r14
movq %rcx, 0x18(%rsp)
subl $0x1, %ebp
jb 0x4b35
cmpl $0x28, %ebx
ja 0x4b03
movq %rax, %r13
movl %ebx, %eax
leaq 0x20(%rsp), %rcx
addq %rcx, %rax
addl $0x8, %ebx
movl %ebx, (%rsp)
jmp 0x4b0c
leaq 0x8(%rax), %r13
movq %r13, 0x8(%rsp)
movq (%rax), %r15
movq %r15, %rdi
callq 0x2110
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2220
addq %r12, %r14
movq %r13, %rax
movq 0x18(%rsp), %rcx
jmp 0x4ae4
movb $0x0, (%r14)
movq %rcx, %rax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2bcd(%rip), %rdi      # 0x7722
xorl %eax, %eax
callq 0x3af1
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: agent_addr
static int
agent_addr(struct sockaddr_un *addr, const uint8_t *iv)
{
    char *dir = getenv("XDG_RUNTIME_DIR");
    if (!dir) {
        dir = getenv("TMPDIR");
        if (!dir)
            dir = "/tmp";
    }

    addr->sun_family = AF_UNIX;
    if (strlen(dir) + 1 + 16 + 1 > sizeof(addr->sun_path)) {
        warning("agent socket path too long -- %s", dir);
        return 0;
    } else {
        sprintf(addr->sun_path, "%s/%02x%02x%02x%02x%02x%02x%02x%02x", dir,
                iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]);
        return 1;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2ce9(%rip), %rdi      # 0x785b
callq 0x2030
movq %rax, %r15
testq %rax, %rax
jne 0x4b99
leaq 0x2ce5(%rip), %rdi      # 0x786b
callq 0x2030
testq %rax, %rax
leaq 0x2cdd(%rip), %r15      # 0x7872
cmovneq %rax, %r15
movw $0x1, (%rbx)
movq %r15, %rdi
callq 0x2110
addq $-0x5b, %rax
cmpq $-0x6e, %rax
ja 0x4bc5
leaq 0x2cc0(%rip), %rdi      # 0x7877
xorl %ebx, %ebx
movq %r15, %rsi
xorl %eax, %eax
callq 0x4c25
jmp 0x4c19
addq $0x2, %rbx
movzbl (%r14), %ecx
movzbl 0x1(%r14), %r8d
movzbl 0x2(%r14), %r9d
movzbl 0x3(%r14), %r10d
movzbl 0x4(%r14), %r11d
movzbl 0x5(%r14), %r12d
movzbl 0x6(%r14), %r13d
movzbl 0x7(%r14), %r14d
subq $0x8, %rsp
leaq 0x2c9d(%rip), %rsi      # 0x7898
movq %rbx, %rdi
movq %r15, %rdx
xorl %eax, %eax
pushq %r14
pushq %r13
pushq %r12
pushq %r11
pushq %r10
callq 0x2300
addq $0x30, %rsp
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: warning
static void
warning(const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    fprintf(stderr, "warning: ");
    vfprintf(stderr, fmt, ap);
    fputc('\n', stderr);
    va_end(ap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x4c88
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x6349(%rip), %r15      # 0xaff8
movq (%r15), %rcx
leaq 0x2c03(%rip), %rdi      # 0x78bc
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x2330
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x22e0
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x2190
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: hmac_init
static void
hmac_init(SHA256_CTX *ctx, const uint8_t *key)
{
    int i;
    uint8_t pad[SHA256_BLOCK_SIZE];
    sha256_init(ctx);
    for (i = 0; i < SHA256_BLOCK_SIZE; i++)
        pad[i] = key[i] ^ 0x36U;
    sha256_update(ctx, pad, sizeof(pad));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x6aa8
xorl %eax, %eax
cmpq $0x20, %rax
je 0x4d13
movb (%r14,%rax), %cl
xorb $0x36, %cl
movb %cl, (%rsp,%rax)
incq %rax
jmp 0x4cfe
movq %rsp, %rsi
pushq $0x20
popq %rdx
movq %rbx, %rdi
callq 0x6ac8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: hmac_final
static void
hmac_final(SHA256_CTX *ctx, const uint8_t *key, uint8_t *hash)
{
    int i;
    uint8_t pad[SHA256_BLOCK_SIZE];
    sha256_final(ctx, hash);
    sha256_init(ctx);
    for (i = 0; i < SHA256_BLOCK_SIZE; i++)
        pad[i] = key[i] ^ 0x5cU;
    sha256_update(ctx, pad, sizeof(pad));
    sha256_update(ctx, hash, SHA256_BLOCK_SIZE);
    sha256_final(ctx, hash);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x6b28
movq %r14, %rdi
callq 0x6aa8
xorl %eax, %eax
cmpq $0x20, %rax
je 0x4d62
movb (%r15,%rax), %cl
xorb $0x5c, %cl
movb %cl, (%rsp,%rax)
incq %rax
jmp 0x4d4d
movq %rsp, %rsi
pushq $0x20
popq %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x6ac8
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x6ac8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6b28
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: secure_entropy
static void
secure_entropy(void *buf, size_t len)
{
    FILE *r = fopen("/dev/urandom", "rb");
    if (!r)
        fatal("failed to open %s", "/dev/urandom");
    if (!fread(buf, len, 1, r))
        fatal("failed to gather entropy");
    fclose(r);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2df8(%rip), %rdi      # 0x7ba1
leaq 0x2a17(%rip), %rsi      # 0x77c7
callq 0x22d0
testq %rax, %rax
je 0x4de0
movq %rax, %rbx
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rcx
callq 0x20e0
testq %rax, %rax
je 0x4df5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2100
leaq 0x2dc7(%rip), %rdi      # 0x7bae
leaq 0x2db3(%rip), %rsi      # 0x7ba1
xorl %eax, %eax
callq 0x3af1
leaq 0x2dc4(%rip), %rdi      # 0x7bc0
xorl %eax, %eax
callq 0x3af1
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: cleanup_register
static void
cleanup_register(FILE *file, char *name)
{
    if (file) {
        unsigned i;
        for (i = 0; i < sizeof(cleanup) / sizeof(*cleanup); i++) {
            if (!cleanup[i].name) {
                cleanup[i].name = name;
                cleanup[i].file = file;
                return;
            }
        }
    }
    abort();
}

// Assembly:
testq %rdi, %rdi
je 0x4e34
cmpq $0x0, 0x63f0(%rip)      # 0xb200
je 0x4e25
cmpq $0x0, 0x63f6(%rip)      # 0xb210
jne 0x4e34
leaq 0x63ed(%rip), %rax      # 0xb210
jmp 0x4e2c
leaq 0x63d4(%rip), %rax      # 0xb200
movq %rsi, (%rax)
movq %rdi, 0x8(%rax)
retq
pushq %rax
callq 0x2060
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: cleanup_closed
static void
cleanup_closed(FILE *file)
{
    unsigned i;
    for (i = 0; i < sizeof(cleanup) / sizeof(*cleanup); i++) {
        if (file == cleanup[i].file) {
            cleanup[i].file = 0;
            return;
        }
    }
    abort();
}

// Assembly:
pushq $0x8
popq %rcx
leaq 0x63bc(%rip), %rax      # 0xb200
leaq 0x10(%rcx), %rdx
cmpq $0x38, %rdx
je 0x4e5e
cmpq %rdi, (%rcx,%rax)
movq %rdx, %rcx
jne 0x4e44
andq $0x0, -0x10(%rdx,%rax)
retq
pushq %rax
callq 0x2060
// File: /workspace/github_c_makefile_star2_O2/skeeto[P]enchive/src/enchive.c
// Function: load_pubkey
static void
load_pubkey(const char *file, uint8_t *key)
{
    FILE *f = fopen(file, "rb");
    if (!f)
        fatal("failed to open key file for reading '%s' -- %s",
              file, strerror(errno));
    if (!fread(key, 32, 1, f))
        fatal("failed to read key file '%s'", file);
    fclose(f);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x2951(%rip), %rsi      # 0x77c7
callq 0x22d0
testq %rax, %rax
je 0x4ea6
movq %rax, %r14
pushq $0x20
popq %rsi
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %rax, %rcx
callq 0x20e0
testq %rax, %rax
je 0x4ec6
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2100
callq 0x2070
movl (%rax), %edi
callq 0x2350
leaq 0x2911(%rip), %rdi      # 0x77ca
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3af1
leaq 0x2e20(%rip), %rdi      # 0x7ced
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3af1
nop