LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_constexpr_float
static float _get_constexpr_float(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));
	assert(FE_EXPR_AST_NODE_GET_CONSTANT(node));

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

	switch (FE_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 0x324c1
cmpb $0x0, 0x70(%rdi)
je 0x324e0
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xa, %eax
ja 0x324ff
leaq 0x182e3(%rip), %rcx     # 0x4a718
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl 0x88(%rdi), %eax
jmp 0x32487
cvtsi2ssq 0x88(%rdi), %xmm0
jmp 0x324bf
movss 0x88(%rdi), %xmm0
jmp 0x324bf
movswl 0x88(%rdi), %eax
jmp 0x32487
cvtsi2ssl 0x88(%rdi), %xmm0
jmp 0x324bf
movl 0x88(%rdi), %eax
jmp 0x324a3
movzbl 0x88(%rdi), %eax
jmp 0x32487
movzwl 0x88(%rdi), %eax
cvtsi2ss %eax, %xmm0
jmp 0x324bf
cvtsd2ss 0x88(%rdi), %xmm0
jmp 0x324bf
movq 0x88(%rdi), %rax
testq %rax, %rax
js 0x324aa
cvtsi2ss %rax, %xmm0
jmp 0x324bf
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
popq %rbp
retq
leaq 0x195cf(%rip), %rdi     # 0x4ba97
leaq 0x1842b(%rip), %rsi     # 0x4a8fa
leaq 0x19a44(%rip), %rcx     # 0x4bf1a
movl $0x9fa, %edx            # imm = 0x9FA
callq 0x30a0
leaq 0x19870(%rip), %rdi     # 0x4bd57
leaq 0x1840c(%rip), %rsi     # 0x4a8fa
leaq 0x19a25(%rip), %rcx     # 0x4bf1a
movl $0x9fb, %edx            # imm = 0x9FB
callq 0x30a0
leaq 0xce5a(%rip), %rdi      # 0x3f360
leaq 0x183ed(%rip), %rsi     # 0x4a8fa
leaq 0x19a06(%rip), %rcx     # 0x4bf1a
movl $0xa0f, %edx            # imm = 0xA0F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: get_constexpr_double
static double _get_constexpr_double(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(FE_IS_EXPR_NODE(node->type));
	assert(FE_EXPR_AST_NODE_GET_CONSTANT(node));

	#define	_A(type)	\
		case FE_TYPE_##type: {	\
			return (double) FE_EXPR_AST_NODE_GET_CONSTEXPR_RESULT_##type##_VAL(node);	\
		}

	switch (FE_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 0x325e0
cmpb $0x0, 0x70(%rdi)
je 0x325ff
movzbl 0x71(%rdi), %eax
decl %eax
cmpl $0xa, %eax
ja 0x3261e
leaq 0x181f0(%rip), %rcx     # 0x4a744
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsbl 0x88(%rdi), %eax
jmp 0x325ab
cvtsi2sdq 0x88(%rdi), %xmm0
jmp 0x325af
cvtss2sd 0x88(%rdi), %xmm0
jmp 0x325af
movswl 0x88(%rdi), %eax
jmp 0x325ab
cvtsi2sdl 0x88(%rdi), %xmm0
jmp 0x325af
movl 0x88(%rdi), %eax
cvtsi2sd %rax, %xmm0
jmp 0x325af
movzbl 0x88(%rdi), %eax
jmp 0x325ab
movzwl 0x88(%rdi), %eax
cvtsi2sd %eax, %xmm0
popq %rbp
retq
movsd 0x88(%rdi), %xmm0
jmp 0x325af
movsd 0x88(%rdi), %xmm1
unpcklps 0x18306(%rip), %xmm1    # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1830e(%rip), %xmm1    # 0x4a8e0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x325af
leaq 0x194b0(%rip), %rdi     # 0x4ba97
leaq 0x1830c(%rip), %rsi     # 0x4a8fa
leaq 0x19962(%rip), %rcx     # 0x4bf57
movl $0xa1d, %edx            # imm = 0xA1D
callq 0x30a0
leaq 0x19751(%rip), %rdi     # 0x4bd57
leaq 0x182ed(%rip), %rsi     # 0x4a8fa
leaq 0x19943(%rip), %rcx     # 0x4bf57
movl $0xa1e, %edx            # imm = 0xA1E
callq 0x30a0
leaq 0xcd3b(%rip), %rdi      # 0x3f360
leaq 0x182ce(%rip), %rsi     # 0x4a8fa
leaq 0x19924(%rip), %rcx     # 0x4bf57
movl $0xa32, %edx            # imm = 0xA32
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: set_constexpr_double
static void _set_constexpr_double(
	ParserContext *ctx,
	ParserASTNode *node,
	uint8_t target_type,
	double value
) {
	assert(ctx);
	assert(node);

	#define	_A(type)	\
		case FE_TYPE_##type: {	\
			FE_EXPR_AST_NODE_SET_CONSTEXPR_RESULT_##type##_VAL(node, value);	\
			break;	\
		}

	switch (target_type) {
		_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);
		}
	}

	#undef	_A
}

// Assembly:
leal -0x1(%rsi), %eax
cmpl $0xf, %eax
ja 0x326dc
leaq 0x18120(%rip), %rcx     # 0x4a770
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvttsd2si %xmm0, %eax
movb %al, 0x88(%rdi)
jmp 0x326d7
cvttsd2si %xmm0, %eax
movw %ax, 0x88(%rdi)
jmp 0x326d7
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x1823e(%rip), %xmm0    # 0x4a8c0
cvttsd2si %xmm0, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movq %rdx, 0x88(%rdi)
jmp 0x326d7
movsd %xmm0, 0x88(%rdi)
jmp 0x326d7
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x88(%rdi)
jmp 0x326d7
cvttsd2si %xmm0, %eax
movl %eax, 0x88(%rdi)
jmp 0x326d7
cvttsd2si %xmm0, %rax
movl %eax, 0x88(%rdi)
jmp 0x326d7
cvttsd2si %xmm0, %rax
movq %rax, 0x88(%rdi)
movb %sil, 0x71(%rdi)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0xcc79(%rip), %rdi      # 0x3f360
leaq 0x1820c(%rip), %rsi     # 0x4a8fa
leaq 0x198a1(%rip), %rcx     # 0x4bf96
movl $0x96f, %edx            # imm = 0x96F
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: calc_pointer_type_increment_size
static size_t _calc_pointer_type_increment_size(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *node_type
) {
	assert(ctx);
	assert(node);
	assert(node_type);
	assert(node_type->type == FE_NODE_TYPE_POINTER);
	assert(node_type->nchilds == 1);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdx, %rdx
je 0x32723
cmpl $0x440, (%rdx)          # imm = 0x440
jne 0x32742
cmpl $0x1, 0x44(%rdx)
jne 0x32761
movq 0x48(%rdx), %rax
movq (%rax), %rdx
popq %rbp
jmp 0x307ca
leaq 0xefd9(%rip), %rdi      # 0x41703
leaq 0x181c9(%rip), %rsi     # 0x4a8fa
leaq 0x198ac(%rip), %rcx     # 0x4bfe4
movl $0x830, %edx            # imm = 0x830
callq 0x30a0
leaq 0xf7c2(%rip), %rdi      # 0x41f0b
leaq 0x181aa(%rip), %rsi     # 0x4a8fa
leaq 0x1988d(%rip), %rcx     # 0x4bfe4
movl $0x831, %edx            # imm = 0x831
callq 0x30a0
leaq 0xefdc(%rip), %rdi      # 0x41744
leaq 0x1818b(%rip), %rsi     # 0x4a8fa
leaq 0x1986e(%rip), %rcx     # 0x4bfe4
movl $0x832, %edx            # imm = 0x832
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_primitive_type
static bool _is_compatible_primitive_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %rbx
movq %rdi, %r15
callq 0x2a712
movl %eax, %r14d
testl %r12d, %r12d
je 0x328aa
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a712
leal -0x1(%r14), %ecx
cmpb $0xb, %cl
setb %cl
cmpb %al, %r14b
sete %al
andb %cl, %al
jmp 0x328c9
decb %r14b
cmpb $0xa, %r14b
ja 0x328c7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a712
decb %al
cmpb $0xb, %al
setb %al
jmp 0x328c9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_struct_type
static bool _is_compatible_struct_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x2a712
cmpb $0xd, %al
jne 0x32922
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a712
cmpb $0xd, %al
jne 0x32922
movq 0x48(%r14), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4ad9
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: is_compatible_pointer_type
static bool _is_compatible_pointer_type(
	ParserContext *ctx,
	ParserASTNode *target,
	ParserASTNode *source,
	bool same
) {
	assert(ctx);
	assert(target);
	assert(source);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2a712
cmpb $0x10, %al
jne 0x32afc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a712
cmpb $0x10, %al
jne 0x32afc
movq 0x48(%r15), %rax
movq (%rax), %rsi
testb %r12b, %r12b
jne 0x32ae0
movq %rbx, %rdi
callq 0x2a712
cmpb $-0x1, %al
je 0x32b07
movq 0x48(%r15), %rax
movq (%rax), %rsi
movq 0x48(%r14), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2a4b9
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x32afe
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: _func_process_label
static void __func_process_label(
	ParserContext *ctx,
	ParserASTNode *node,
	ParserASTNode *current
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STATS_BLOCK);
	assert(current);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0xb00, (%rsi)          # imm = 0xB00
jne 0x336af
movq %rdx, %rbx
testq %rdx, %rdx
je 0x336ce
movq %rsi, %r14
movq %rdi, %r15
cmpl $0xb90, (%rbx)          # imm = 0xB90
jne 0x3367e
movq 0x48(%rbx), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl $0x4, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x6d30
cmpl $0x0, 0x44(%rbx)
jle 0x336a6
xorl %r12d, %r12d
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x33634
incq %r12
movslq 0x44(%rbx), %rax
cmpq %rax, %r12
jl 0x33687
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1942c(%rip), %rdi     # 0x4cae2
leaq 0x1723d(%rip), %rsi     # 0x4a8fa
leaq 0x19440(%rip), %rcx     # 0x4cb04
movl $0x14b5, %edx           # imm = 0x14B5
callq 0x30a0
leaq 0x1947c(%rip), %rdi     # 0x4cb51
leaq 0x1721e(%rip), %rsi     # 0x4a8fa
leaq 0x19421(%rip), %rcx     # 0x4cb04
movl $0x14b6, %edx           # imm = 0x14B6
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: stat_va_start
static void _stat_va_start(
	ParserContext *ctx,
	ParserASTNode *node
) {
	assert(ctx);
	assert(node);
	assert(node->type == FE_NODE_STAT_VA_START);
	assert(node->nchilds == 1);

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
cmpl $0xbd0, (%rsi)          # imm = 0xBD0
jne 0x33f7f
movq %rsi, %r14
cmpl $0x1, 0x44(%rsi)
jne 0x33f9e
movq %rdi, %rbx
movq 0x48(%r14), %rax
movq (%rax), %r15
movq %r15, %rsi
callq 0x2bd91
movl (%r14), %eax
leal -0xbd0(%rax), %ecx
cmpl $0x3, %ecx
jb 0x33e7a
cmpl $0xece, %eax            # imm = 0xECE
jne 0x33fdc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a971
movq 0x30(%rax), %r12
movslq 0x44(%r12), %rax
testq %rax, %rax
je 0x33ea5
movq 0x48(%r12), %rcx
movq -0x8(%rcx,%rax,8), %rcx
cmpl $0xa03, (%rcx)          # imm = 0xA03
je 0x33eda
movups 0x1947b(%rip), %xmm0    # 0x4d327
leaq -0x420(%rbp), %rdx
movups %xmm0, 0x19(%rdx)
movups 0x19460(%rip), %xmm0    # 0x4d31e
movaps %xmm0, 0x10(%rdx)
movups 0x19445(%rip), %xmm0    # 0x4d30e
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x58(%rbx)
movl 0x44(%r12), %eax
cmpl $0x1, %eax
jle 0x33fbd
movq 0x48(%r12), %rcx
movl %eax, %eax
movq -0x10(%rcx,%rax,8), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x2a712
leal -0x1(%rax), %ecx
cmpb $0xb, %cl
setb %cl
cmpb $0x10, %al
sete %al
orb %cl, %al
jne 0x33f38
leaq 0x1941f(%rip), %rsi     # 0x4d337
leaq -0x420(%rbp), %r12
movl $0x76, %edx
movq %r12, %rdi
callq 0x3110
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq *0x58(%rbx)
cmpb $0xc, 0x60(%r15)
je 0x33f6f
movups 0x192f3(%rip), %xmm0    # 0x4d239
leaq -0x420(%rbp), %rdx
movups %xmm0, 0x1f(%rdx)
movups 0x192d2(%rip), %xmm0    # 0x4d22a
movaps %xmm0, 0x10(%rdx)
movups 0x192b7(%rip), %xmm0    # 0x4d21a
movaps %xmm0, (%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq *0x58(%rbx)
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x19270(%rip), %rdi     # 0x4d1f6
leaq 0x1696d(%rip), %rsi     # 0x4a8fa
leaq 0x1922c(%rip), %rcx     # 0x4d1c0
movl $0x69f, %edx            # imm = 0x69F
callq 0x30a0
leaq 0x177eb(%rip), %rdi     # 0x4b790
leaq 0x1694e(%rip), %rsi     # 0x4a8fa
leaq 0x1920d(%rip), %rcx     # 0x4d1c0
movl $0x6a0, %edx            # imm = 0x6A0
callq 0x30a0
leaq 0x1076d(%rip), %rdi     # 0x44731
leaq 0x1692f(%rip), %rsi     # 0x4a8fa
leaq 0x19277(%rip), %rcx     # 0x4d249
movl $0x688, %edx            # imm = 0x688
callq 0x30a0
leaq 0x19297(%rip), %rdi     # 0x4d27a
leaq 0x16910(%rip), %rsi     # 0x4a8fa
leaq 0x19258(%rip), %rcx     # 0x4d249
movl $0x678, %edx            # imm = 0x678
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/Ihsoh[P]ilang/compiler/frontend/semantics.c
// Function: search_node_along_parent
static ParserASTNode * _search_node_along_parent(
	ParserASTNode *node,
	...
) {
	assert(node);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdx, -0xc0(%rbp)
movq %rcx, -0xb8(%rbp)
movq %r8, -0xb0(%rbp)
movq %r9, -0xa8(%rbp)
testb %al, %al
je 0x34053
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
testq %rdi, %rdi
je 0x3408a
leaq -0xd0(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq %rax, 0x10(%rsi)
leaq 0x10(%rbp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x2a8b3
addq $0xd0, %rsp
popq %rbp
retq
leaq 0xed51(%rip), %rdi      # 0x42de2
leaq 0x16862(%rip), %rsi     # 0x4a8fa
leaq 0x18e17(%rip), %rcx     # 0x4ceb6
movl $0x582, %edx            # imm = 0x582
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/oreparaz[P]dudect/examples/aes32/dut_aes32.c
// Function: do_one_computation
uint8_t do_one_computation(uint8_t *data) {
  uint8_t in[16] = {0};
  uint8_t out[16] = {0};
  uint8_t ret = 0;

  memcpy(in, data, 16);

  rijndaelEncrypt(rk, 10, in, out);

  ret ^= out[0];
  /* return some computation output to try to tame a clever optimizing compiler */
  return ret;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
xorps %xmm0, %xmm0
movq %rsp, %rbx
movaps %xmm0, (%rbx)
movups (%rdi), %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
leaq 0x761f(%rip), %rdi      # 0x90a0
movl $0xa, %esi
movq %rbx, %rcx
callq 0x2035
movb (%rbx), %al
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/bdf.h
// Function: shift_glyph
void shift_glyph(struct bdf_header_t *bdf_header, struct bdf_char_t *bdf_char)
{
	int i, byte, shift;
	bitmap_width_t bitmap;

	for (i = 0; i < bdf_char->bbh; i++) {
		bitmap  = bdf_char->bitmap[i];
		byte    = bit2byte(bdf_char->bbw);
		bitmap <<= (bit2byte(bdf_char->dwidth) - byte) * BITS_PER_BYTE;
		if (bdf_char->bbx >= 0)
			bitmap >>= bdf_char->bbx;
		else {
			logging(ERROR, "maybe overlapping (glpyh:%X bbx:%d)\n", bdf_char->encoding, bdf_char->bbx);
			bitmap <<= abs(bdf_char->bbx);
		}
		bdf_char->bitmap[i] = bitmap;
	}

	shift = bdf_header->ascent - (bdf_char->bbh + bdf_char->bby);
	if (shift >= 0) {
		memmove(bdf_char->bitmap + shift, bdf_char->bitmap, sizeof(bitmap_width_t) * bdf_char->bbh);
		memset(bdf_char->bitmap, 0, sizeof(bitmap_width_t) * shift);
	}
	else {
		logging(ERROR, "maybe overlapping (glpyh:%X vertical shift:%d)\n", bdf_char->encoding, shift);
		memmove(bdf_char->bitmap, bdf_char->bitmap + abs(shift), sizeof(bitmap_width_t) * bdf_char->bbh);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x4(%rsi), %edx
testl %edx, %edx
jle 0x154b
movl 0x8(%rbx), %eax
leaq 0x1bcc(%rip), %r15      # 0x30a7
xorl %r12d, %r12d
movq 0x18(%rbx,%r12,8), %r13
movl (%rbx), %esi
movl 0x10(%rbx), %ecx
leal 0x7(%rsi), %edi
addl $0xe, %esi
testl %edi, %edi
cmovnsl %edi, %esi
shrl $0x3, %esi
leal 0x7(%rcx), %edi
addl $0xe, %ecx
testl %edi, %edi
cmovnsl %edi, %ecx
shrl $0x3, %ecx
subl %esi, %ecx
shll $0x3, %ecx
shlq %cl, %r13
testl %eax, %eax
js 0x1517
movl %eax, %ecx
shrq %cl, %r13
jmp 0x153b
movl 0x14(%rbx), %edx
movl $0x2, %edi
movq %r15, %rsi
movl %eax, %ecx
xorl %eax, %eax
callq 0x129c
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
shlq %cl, %r13
movq %r13, 0x18(%rbx,%r12,8)
incq %r12
movslq %edx, %rcx
cmpq %rcx, %r12
jl 0x14de
movl 0x10(%r14), %r14d
movl 0xc(%rbx), %eax
addl %edx, %eax
subl %eax, %r14d
js 0x1591
movl %r14d, %r14d
leaq (%rbx,%r14,8), %rdi
addq $0x18, %rdi
addq $0x18, %rbx
movslq %edx, %rdx
shlq $0x3, %rdx
movq %rbx, %rsi
callq 0x1130
shlq $0x3, %r14
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x10b0
movl 0x14(%rbx), %edx
leaq 0x1b31(%rip), %rsi      # 0x30cc
movl $0x2, %edi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x129c
leaq 0x18(%rbx), %rdi
negl %r14d
leaq (%rbx,%r14,8), %rsi
addq $0x18, %rsi
movslq 0x4(%rbx), %rdx
shlq $0x3, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/bdf.h
// Function: load_table
void load_table(char *path, enum encode_t encode)
{
	int i;
	char buf[BUFSIZE], *cp;
	FILE *fp;
	uint32_t from, to;

	fp = efopen(path, "r");

	for (i = 0; i < UCS2_CHARS; i++) {
		if (encode == ISO10646)
			convert_table[i] = i;
		else
			convert_table[i] = -1;
	}

	while (fgets(buf, BUFSIZE, fp) != NULL) {
		if (strlen(buf) == 0 || buf[0] == '#')
			continue;

		if ((cp = strchr(buf, '\n')) != NULL)
			*cp = '\0';

		sscanf(buf, "%X %X", (unsigned int *) &from, (unsigned int *) &to);
		convert_table[from] = to;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movl %esi, %ebp
leaq 0x1a53(%rip), %rsi      # 0x303c
callq 0x1364
movq %rax, %rbx
movdqa 0x1a17(%rip), %xmm0     # 0x3010
xorl %eax, %eax
leaq 0x3b0e(%rip), %r15      # 0x5110
movdqa 0x1a16(%rip), %xmm1     # 0x3020
movdqa %xmm0, %xmm2
cmpl $0x4, %ebp
je 0x1617
pcmpeqd %xmm2, %xmm2
movdqa %xmm2, (%rax,%r15)
paddd %xmm1, %xmm0
addq $0x10, %rax
cmpq $0x40000, %rax          # imm = 0x40000
jne 0x160a
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x10c0
testq %rax, %rax
je 0x16b1
leaq 0x10(%rsp), %r14
leaq 0x1aac(%rip), %rbp      # 0x30fc
leaq 0xc(%rsp), %r12
leaq 0x8(%rsp), %r13
movzbl 0x10(%rsp), %eax
testl %eax, %eax
je 0x169c
cmpl $0x23, %eax
je 0x169c
movq %r14, %rdi
movl $0xa, %esi
callq 0x10a0
testq %rax, %rax
je 0x167d
movb $0x0, (%rax)
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
xorl %eax, %eax
callq 0x1110
movl 0x8(%rsp), %eax
movl 0xc(%rsp), %ecx
movl %eax, (%r15,%rcx,4)
movq %r14, %rdi
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x10c0
testq %rax, %rax
jne 0x165a
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/bdf.h
// Function: read_char
int read_char(char *buf, struct bdf_char_t *bdf_char)
{
	if (pre_match(buf, "BBX "))
		sscanf(buf + strlen("BBX "), "%d %d %d %d",
			&bdf_char->bbw, &bdf_char->bbh, &bdf_char->bbx, &bdf_char->bby);
	else if (pre_match(buf, "DWIDTH "))
		bdf_char->dwidth = atoi(buf + strlen("DWIDTH "));
	else if (pre_match(buf, "ENCODING ")) {
		bdf_char->encoding = atoi(buf + strlen("ENCODING "));
		//logging(DEBUG, "reading char:%d\n", bdf_char->encoding);
	}
	else if (pre_match(buf, "BITMAP")) {
		return BDF_BITMAP;
	}

	return BDF_CHAR;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18a4(%rip), %rsi      # 0x31e0
movl $0x4, %edx
callq 0x1060
testl %eax, %eax
je 0x1999
leaq 0x1894(%rip), %rsi      # 0x31e5
movl $0x7, %edx
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
je 0x19bf
leaq 0x1884(%rip), %rsi      # 0x31ed
movl $0x9, %edx
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
je 0x19d0
leaq 0x1876(%rip), %rsi      # 0x31f7
movl $0x6, %edx
movq %r14, %rdi
callq 0x1060
testl %eax, %eax
jne 0x19df
movl $0x2, %eax
jmp 0x19e4
addq $0x4, %r14
leaq 0x4(%rbx), %rcx
leaq 0x8(%rbx), %r8
leaq 0xc(%rbx), %r9
leaq 0x1763(%rip), %rsi      # 0x3113
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1110
jmp 0x19df
addq $0x7, %r14
movq %r14, %rdi
callq 0x1160
movl %eax, 0x10(%rbx)
jmp 0x19df
addq $0x9, %r14
movq %r14, %rdi
callq 0x1160
movl %eax, 0x14(%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/bdf.h
// Function: load_bdf_glyph
bool load_bdf_glyph(struct glyph_list_t **glist_head, struct glyph_t *default_glyph, char *path)
{
	int mode = BDF_HEADER;
	char lbuf[BUFSIZE], *cp;
	FILE *fp;
	struct bdf_header_t bdf_header;
	struct bdf_char_t bdf_char;

	if ((fp = efopen(path, "r")) == NULL)
		return false;

	memset(&bdf_header, 0, sizeof(struct bdf_header_t));
	memset(&bdf_char, 0, sizeof(struct bdf_char_t));

	logging(DEBUG, "read bdf: %s\n", path);

	while (fgets(lbuf, BUFSIZE, fp) != NULL) {
		if ((cp = strchr(lbuf, '\n')) != NULL)
			*cp = '\0';

		//fprintf(stderr, "%s\n", lbuf);

		if (mode == BDF_HEADER)
			mode = read_header(lbuf, &bdf_header);
		else if (mode == BDF_CHAR)
			mode = read_char(lbuf, &bdf_char);
		else if (mode == BDF_BITMAP)
			mode = read_bitmap(glist_head, default_glyph, lbuf, &bdf_header, &bdf_char);
	}
	efclose(fp);
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa48, %rsp            # imm = 0xA48
movq %rsi, (%rsp)
movq %rdi, %r14
leaq 0x14b0(%rip), %rsi      # 0x303c
movq %rdx, %rdi
callq 0x1364
movq %rax, %r15
testq %rax, %rax
je 0x1c60
leaq 0x624(%rsp), %rdi
xorl %ebp, %ebp
movl $0x424, %edx            # imm = 0x424
xorl %esi, %esi
callq 0x10b0
leaq 0x8(%rsp), %rdi
movl $0x218, %edx            # imm = 0x218
xorl %esi, %esi
callq 0x10b0
leaq 0x220(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdx
callq 0x10c0
testq %rax, %rax
je 0x1c58
leaq 0x220(%rsp), %r12
leaq 0x624(%rsp), %r13
leaq 0x8(%rsp), %rbx
movq %r12, %rdi
movl $0xa, %esi
callq 0x10a0
testq %rax, %rax
je 0x1c0b
movb $0x0, (%rax)
cmpl $0x2, %ebp
je 0x1c22
movq %r12, %rdi
cmpl $0x1, %ebp
jne 0x1c39
movq %rbx, %rsi
callq 0x192b
jmp 0x1c41
movq %r14, %rdi
movq (%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x19ec
jmp 0x1c41
movq %r13, %rsi
callq 0x16c3
movl %eax, %ebp
movq %r12, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r15, %rdx
callq 0x10c0
testq %rax, %rax
jne 0x1bf6
movq %r15, %rdi
callq 0x13cd
testq %r15, %r15
setne %al
addq $0xa48, %rsp            # imm = 0xA48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: map_glyph
bool map_glyph(struct glyph_t *font[],
	struct glyph_list_t *glist_head, struct glyph_t *default_glyph)
{
	int width, cell_width = 0, cell_height = 0;
	struct glyph_t *glyph;
	struct glyph_list_t *listp;

	if (default_glyph->width == 0 || default_glyph->height == 0) {
		logging(ERROR, "default glyph(U+%.4X) not found\n", DEFAULT_CHAR);
		return false;
	}

	cell_width  = default_glyph->width;
	cell_height = default_glyph->height;
	logging(DEBUG, "default glyph width:%d height:%d\n",
		default_glyph->width, default_glyph->height);

	for (listp = glist_head; listp != NULL; listp = listp->next) {
		if (listp->code >= UCS2_CHARS)
			continue;

		width = wcwidth(listp->code);
		glyph = listp->glyph;
		if ((width <= 0)                                /* not printable */
			|| (glyph->height != cell_height)           /* invalid font height */
			|| (glyph->width  != (cell_width * width))) /* invalid font width */
			continue;

		font[listp->code] = glyph;
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl (%rdx), %ebp
testl %ebp, %ebp
je 0x1cd7
movb 0x1(%rdx), %r12b
testb %r12b, %r12b
je 0x1cd7
movq %rsi, %r14
movb $0x1, %bl
testq %rsi, %rsi
je 0x1cf1
movq %rdi, %r15
movl (%r14), %edi
cmpl $0xffff, %edi           # imm = 0xFFFF
ja 0x1ccc
callq 0x1100
testl %eax, %eax
jle 0x1ccc
movq 0x8(%r14), %rcx
cmpb %r12b, 0x1(%rcx)
jne 0x1ccc
movzbl (%rcx), %edx
imull %ebp, %eax
cmpl %edx, %eax
jne 0x1ccc
movl (%r14), %eax
movq %rcx, (%r15,%rax,8)
movq 0x10(%r14), %r14
testq %r14, %r14
jne 0x1c9d
jmp 0x1cf1
leaq 0x1528(%rip), %rsi      # 0x3206
xorl %ebx, %ebx
movl $0x2, %edi
movl $0x20, %edx
xorl %eax, %eax
callq 0x129c
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: load_alias
bool load_alias(struct glyph_t *font[], char *alias)
{
	unsigned int dst, src;
	char buf[BUFSIZE];
	FILE *fp;

	if ((fp = efopen(alias, "r")) == NULL)
		return false;

	while (fgets(buf, BUFSIZE, fp) != NULL) {
		if (strlen(buf) == 0 || buf[0] == '#')
			continue;

		sscanf(buf, "%X %X", &dst, &src);
		if ((dst >= UCS2_CHARS) || (src >= UCS2_CHARS))
			continue;

		//if (font[src] != NULL && font[dst] != NULL) {
		if (font[src] != NULL) {
			logging(DEBUG, "swapped: use U+%.4X for U+%.4X\n", src, dst);
			font[dst] = font[src];

			//free(font[dst]->bitmap);
			//font[dst]->width  = font[src]->width;
			//font[dst]->height = font[src]->height;
			//font[dst]->bitmap = font[src]->bitmap;
			//memcpy(font[dst]->bitmap, font[src]->bitmap, sizeof(bitmap_width_t) * font[src]->height);
		}
	}
	efclose(fp);
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x1322(%rip), %rsi      # 0x303c
movq %rax, %rdi
callq 0x1364
movq %rax, %r14
testq %rax, %rax
je 0x1dc8
leaq 0x10(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x10c0
testq %rax, %rax
je 0x1dc0
leaq 0x10(%rsp), %r15
leaq 0x13ab(%rip), %r12      # 0x30fc
leaq 0xc(%rsp), %r13
leaq 0x8(%rsp), %rbp
movzbl 0x10(%rsp), %eax
testl %eax, %eax
je 0x1dab
cmpl $0x23, %eax
je 0x1dab
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
xorl %eax, %eax
callq 0x1110
movl 0xc(%rsp), %eax
cmpq $0x10000, %rax          # imm = 0x10000
setae %dl
movl 0x8(%rsp), %ecx
cmpl $0x10000, %ecx          # imm = 0x10000
setae %sil
orb %dl, %sil
jne 0x1dab
movl %ecx, %ecx
movq (%rbx,%rcx,8), %rcx
testq %rcx, %rcx
je 0x1dab
movq %rcx, (%rbx,%rax,8)
movq %r15, %rdi
movl $0x400, %esi            # imm = 0x400
movq %r14, %rdx
callq 0x10c0
testq %rax, %rax
jne 0x1d5b
movq %r14, %rdi
callq 0x13cd
testq %r14, %r14
setne %al
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: check_font
bool check_font(struct glyph_t **font, struct glyph_t *empty_half, struct glyph_t *empty_wide)
{
	empty_half->bitmap = (bitmap_width_t *) ecalloc(font[DEFAULT_CHAR]->height, sizeof(bitmap_width_t));
	empty_wide->bitmap = (bitmap_width_t *) ecalloc(font[DEFAULT_CHAR]->height, sizeof(bitmap_width_t));

	if (!empty_half->bitmap || !empty_wide->bitmap)
		return false;

	empty_half->width  = font[DEFAULT_CHAR]->width;
	empty_wide->width  = font[DEFAULT_CHAR]->width * WIDE;
	empty_half->height = font[DEFAULT_CHAR]->height;
	empty_wide->height = font[DEFAULT_CHAR]->height;

	if (font[SUBSTITUTE_HALF] == NULL) {
		logging(WARN, "half substitute glyph(U+%.4X) not found, use empty glyph\n", SUBSTITUTE_HALF);
		font[SUBSTITUTE_HALF] = empty_half;
	}
	if (font[SUBSTITUTE_WIDE] == NULL) {
		logging(WARN, "wide substitute glyph(U+%.4X) not found, use empty glyph\n", SUBSTITUTE_WIDE);
		font[SUBSTITUTE_WIDE] = empty_wide;
	}
	if (font[REPLACEMENT_CHAR] == NULL) {
		logging(WARN, "replacement glyph(U+%.4X) not found, use empty glyph\n", REPLACEMENT_CHAR);
		font[REPLACEMENT_CHAR] = empty_half;
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x100(%rdi), %rax
movzbl 0x1(%rax), %edi
movl $0x8, %esi
callq 0x1418
movq %rax, 0x8(%rbx)
movq 0x100(%r14), %rax
movzbl 0x1(%rax), %edi
movl $0x8, %esi
callq 0x1418
movq %rax, 0x8(%r15)
cmpq $0x0, 0x8(%rbx)
setne %cl
testq %rax, %rax
setne %bpl
andb %cl, %bpl
cmpb $0x1, %bpl
jne 0x1ea6
movq 0x100(%r14), %rax
movb (%rax), %cl
movb %cl, (%rbx)
addb %cl, %cl
movb %cl, (%r15)
movb 0x1(%rax), %al
movb %al, 0x1(%rbx)
movb %al, 0x1(%r15)
cmpq $0x0, 0x18000(%r14)
jne 0x1e7d
leaq 0x13c2(%rip), %rsi      # 0x3227
movl $0x1, %edi
movl $0x3000, %edx           # imm = 0x3000
xorl %eax, %eax
callq 0x129c
movq %r15, 0x18000(%r14)
cmpq $0x0, 0x1f8(%r14)
jne 0x1ea6
leaq 0x13d3(%rip), %rsi      # 0x3261
movl $0x1, %edi
movl $0x3f, %edx
xorl %eax, %eax
callq 0x129c
movq %rbx, 0x1f8(%r14)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: cleanup
void cleanup(struct glyph_list_t *glist_head, struct glyph_t *empty_half, struct glyph_t *empty_wide)
{
	struct glyph_list_t *listp, *next;

	for (listp = glist_head; listp != NULL; listp = next) {
		next = listp->next;

		free(listp->glyph->bitmap);
		free(listp->glyph);
		free(listp);
	}
	free(empty_half->bitmap);
	free(empty_wide->bitmap);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
testq %rdi, %rdi
je 0x20a2
movq %rdi, %r15
movq 0x8(%r15), %rax
movq 0x10(%r15), %r12
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x8(%r15), %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
movq %r12, %r15
testq %r12, %r12
jne 0x2078
movq 0x8(%r14), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/uobikiemukot[P]yaft/tools/mkfont_bdf.c
// Function: main
int main(int argc, char *argv[])
{
	struct glyph_list_t *glist_head = NULL;
	struct glyph_t *font[UCS2_CHARS], default_glyph, empty_wide, empty_half;

	if (!setlocale(LC_ALL, "")) /* set current locale for wcwidth() */
		logging(WARN, "setlocale() failed\n");

	if (argc < 3) {
		logging(FATAL, "usage: ./mkfont ALIAS BDF1 [BDF2] [BDF3] ...\n");
		return EXIT_FAILURE;
	}

	for (int i = 0; i < UCS2_CHARS; i++)
		font[i] = NULL;

	for (int i = 2; i < argc; i++)
		load_bdf_glyph(&glist_head, &default_glyph, argv[i]);

	if (!map_glyph(font, glist_head, &default_glyph)) {
		logging(FATAL, "map_glyph() failed\n");
		goto err_occurred;
	}

	if (!load_alias(font, argv[1]))
		logging(WARN, "font alias does not work\n");

	if (!check_font(font, &empty_half, &empty_wide)) {
		logging(FATAL, "check_font() failed\n");
		goto err_occurred;
	}

	if (!dump_font(font)) {
		logging(FATAL, "dump_font() failed\n");
		goto err_occurred;
	}

	cleanup(glist_head, &empty_half, &empty_wide);
	return EXIT_SUCCESS;

err_occurred:
	cleanup(glist_head, &empty_half, &empty_wide);
	return EXIT_FAILURE;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80040, %rsp          # imm = 0x80040
movq %rsi, %r14
movl %edi, %ebx
movq $0x0, 0x8(%rsp)
leaq 0xf8b(%rip), %rsi       # 0x306f
movl $0x6, %edi
callq 0x1120
testq %rax, %rax
jne 0x2106
leaq 0x1291(%rip), %rsi      # 0x338b
movl $0x1, %edi
xorl %eax, %eax
callq 0x129c
cmpl $0x2, %ebx
jg 0x2123
leaq 0x128d(%rip), %rsi      # 0x339f
movl $0x3, %edi
xorl %eax, %eax
callq 0x129c
jmp 0x2211
leaq 0x40(%rsp), %rdi
movl $0x80000, %edx          # imm = 0x80000
xorl %esi, %esi
callq 0x10b0
movl %ebx, %r12d
movl $0x2, %r13d
leaq 0x8(%rsp), %rbx
leaq 0x30(%rsp), %r15
movq (%r14,%r13,8), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b6d
incq %r13
cmpq %r13, %r12
jne 0x2147
movq 0x8(%rsp), %rbx
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0x1c78
testb %al, %al
je 0x21da
movq 0x8(%r14), %rsi
leaq 0x40(%rsp), %rdi
callq 0x1cfc
testb %al, %al
jne 0x219e
leaq 0x124f(%rip), %rsi      # 0x33e1
movl $0x1, %edi
xorl %eax, %eax
callq 0x129c
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x1de0
testb %al, %al
je 0x21e3
leaq 0x40(%rsp), %rdi
callq 0x1eb3
testb %al, %al
je 0x21ec
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2062
xorl %eax, %eax
jmp 0x2216
leaq 0x11ec(%rip), %rsi      # 0x33cd
jmp 0x21f3
leaq 0x1211(%rip), %rsi      # 0x33fb
jmp 0x21f3
leaq 0x121d(%rip), %rsi      # 0x3410
movl $0x3, %edi
xorl %eax, %eax
callq 0x129c
leaq 0x10(%rsp), %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x2062
movl $0x1, %eax
addq $0x80040, %rsp          # imm = 0x80040
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pipde[P]deos-songlib/utils/identify/identifyz2.c
// Function: closestNote
char *
closestNote(double freq)
    {
    int i,index = -1;
    for (i = 0; index < 0 && i < 120; ++i)
        {
        if (freq >= freqs[i] && freq < freqs[i+1])
            {
            if (freq - freqs[i] >= freqs[i+1] - freq)
                index = i+1;
            else
                index = i;
            }
        }

    return notes[index];
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %eax, %eax
leaq 0x5b82(%rip), %rcx      # 0x8150
movsd (%rcx,%rax,8), %xmm1
ucomisd %xmm1, %xmm0
jb 0x25fa
movsd 0x8(%rcx,%rax,8), %xmm2
ucomisd %xmm0, %xmm2
jbe 0x25fa
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
subsd %xmm0, %xmm2
ucomisd %xmm2, %xmm3
movl %eax, %edx
sbbl $-0x1, %edx
testl %edx, %edx
jns 0x260b
leaq 0x1(%rax), %rsi
cmpq $0x77, %rax
movq %rsi, %rax
jb 0x25ce
movslq %edx, %rax
leaq 0x5e9b(%rip), %rcx      # 0x84b0
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: fopen_output_stream
FILE *fopen_output_stream(const char *filename) {
	int fd ;
	if (strncmp(filename,"-", 1)==0 || !strcmp(filename,"")) {
		fd = STDOUT_FILENO;
	} else {
		fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666 );
		if (fd==-1) err(1, "Failed to create output file (%s)", filename);
	}
	FILE *out = fdopen(fd,"wb");
	return out;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
movl $0x1, %edi
testl %eax, %eax
je 0x48cc
cmpl $0x2d, %eax
je 0x48cc
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x3530
movl %eax, %edi
cmpl $-0x1, %eax
je 0x48d9
leaq 0x16761(%rip), %rsi     # 0x1b034
popq %rbx
jmp 0x34c0
leaq 0x16732(%rip), %rsi     # 0x1b012
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3430
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: open_output_stream
gzFile open_output_stream(char* filename) {
	int fd ;
	if (strncmp(filename,"-", 1)==0 || !strcmp(filename,"")) {
		fd = STDOUT_FILENO;
	} else {
		fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666 );
		if (fd==-1) err(1, "Failed to create output file (%s)", filename);
	}
	gzFile out = gzdopen(fd,"wb");
	return out;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
movl $0x1, %edi
testl %eax, %eax
je 0x4973
cmpl $0x2d, %eax
je 0x4973
movq %rbx, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x3530
movl %eax, %edi
cmpl $-0x1, %eax
je 0x4980
leaq 0x166ba(%rip), %rsi     # 0x1b034
popq %rbx
jmp 0x31b0
leaq 0x1668b(%rip), %rsi     # 0x1b012
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3430
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/./IO_stream.h
// Function: open_input_stream
gzFile open_input_stream(const char *filename){
	int fd ;
	if (strncmp(filename,"-", 1)==0 || !strcmp(filename,"")) {
		fd = STDIN_FILENO;
	} else {
		fd = open(filename, O_CREAT | O_RDONLY , 0666 );
		if (fd==-1) err(1, "Failed to create input file (%s)", filename);
	}
	gzFile in = gzdopen(fd,"rb");
	return in;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movzbl (%rdi), %eax
xorl %edi, %edi
testl %eax, %eax
je 0x4a17
cmpl $0x2d, %eax
je 0x4a17
movq %rbx, %rdi
movl $0x40, %esi
movl $0x1b6, %edx            # imm = 0x1B6
xorl %eax, %eax
callq 0x3530
movl %eax, %edi
cmpl $-0x1, %eax
je 0x4a24
leaq 0x1663f(%rip), %rsi     # 0x1b05d
popq %rbx
jmp 0x31b0
leaq 0x16611(%rip), %rsi     # 0x1b03c
movl $0x1, %edi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3430
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: display_usage
void display_usage(char * argv[]){
	char *buffer=(char* )malloc(8092*sizeof(char));
	const char* usage=
"\nCopyright (c) 2012-2013\n" \
"Contact: XiongXu <xuxiong19880610@163.com> <xiongxu@me.com> \n" \
"Usage: %s [-o OUTFILE] [-r chr1:1-2000000] [-h] bamFile1 bamFile2 ..\n" \
"Discription:\n  This program is used for converting a bam file to wig file format, the bamfile should be samtools indexed. If you don't specify the -r parameter ,the program will convert the whole .bam file by chromosomes\n" \
"Example1:\n  %s -o out -r chr1:1-100000 /share/work1/staff/xuxiong/twins/batch2/test_20131224/RT144FD_L1_I001.R1.clean.fastq.gz_1224/accepted_hits.bam\n" \
"Example2:\n  %s -o out /share/work1/staff/xuxiong/twins/batch2/test_20131224/RT144FD_L1_I001.R1.clean.fastq.gz_1224/accepted_hits.bam\n" \
"\n" \
"   [-o OUTPUT_FILE]  = OUTPUT file.                                   [required]\n" \
"   [-r]              = region, default is whole genome.(chr1:1-20000) [option]\n" \
"   [-h]              = This helpful help screen.                      [option]\n" \
"   Infiles           = bam format input file(s),at least 1 bam file.  [required]\n" \
"\n";
	sprintf(buffer,usage,argv[0],argv[0],argv[0]);
	fprintf(stderr,"%s",buffer);
	exit(1);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1f9c, %edi           # imm = 0x1F9C
callq 0x3440
movq %rax, %r14
movq (%rbx), %rcx
leaq 0x16608(%rip), %rsi     # 0x1b060
movq %rax, %rdi
movq %rcx, %rdx
movq %rcx, %r8
xorl %eax, %eax
callq 0x35c0
movq 0x1f589(%rip), %rax     # 0x23ff8
movq (%rax), %rsi
movq %r14, %rdi
callq 0x3270
movl $0x1, %edi
callq 0x35d0
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: load_bam_index
bam_index_t *load_bam_index(char *filename){
	bam_index_t *idx;
	if ((idx = bam_index_load(filename)) == 0) {
		fprintf(stderr, "bam2bed: BAM indexing file is not available.\n");
		exit(1);
	}
	return idx;
}

// Assembly:
pushq %rax
callq 0x11ed0
testq %rax, %rax
je 0x4a91
popq %rcx
retq
callq 0x36e0
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: bam_fetch_chr
int bam_fetch_chr(bam_index_t *idx,const char *region,DataBuf *databuf){
	int ref, beg, end;
	bam_parse_region(databuf->fp->header,region, &ref, &beg, &end);
	if (ref < 0) {
		fprintf(stderr, "bam2bed: Invalid region %s\n", globalArgs.region);
		exit(1);
	}
//	fprintf(stderr,"%s\t%d\t%d\n",databuf->fp->header->target_name[ref],beg,end);
	bam_fetch(databuf->fp->x.bam, idx, ref, beg, end, databuf, fetch_func);
	return ref;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq (%rdx), %rax
movq 0x10(%rax), %rdi
leaq 0x1c(%rsp), %r15
leaq 0x18(%rsp), %rcx
leaq 0x14(%rsp), %r8
movq %r15, %rdx
callq 0xaba4
movl (%r15), %edx
testl %edx, %edx
js 0x4afe
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movl 0x18(%rsp), %ecx
movl 0x14(%rsp), %r8d
leaq 0x22(%rip), %rax        # 0x4b03
movq %rax, (%rsp)
movq %r14, %rsi
movq %rbx, %r9
callq 0x12c16
movl 0x1c(%rsp), %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x3705
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: union_hashed_keys
sds *union_hashed_keys(dict *hashtbl_a,dict *hashtbl_b){
	sds *keys=(sds *)calloc((hashtbl_a->used+hashtbl_b->used),sizeof(sds));
	int j=0;
	dictIterator *iter=dictGetIterator(hashtbl_a);
	dictEntry *entry=dictNext(iter);
	for (;entry;entry=dictNext(iter) ){
		keys[j++]=(sds)(entry->key);
	}
	dictReleaseIterator(iter);

	iter=dictGetIterator(hashtbl_b);
	entry=dictNext(iter);
	for (;entry;entry=dictNext(iter) ){
		keys[j++]=(sds)(entry->key);
	}
	dictReleaseIterator(iter);
	qsort(keys,j,sizeof(sds),cmpInt);
	return keys;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movq 0x20(%rsi), %rdi
addq 0x20(%r15), %rdi
movl $0x8, %esi
callq 0x3330
movq %rax, %rbx
movq %r15, %rdi
callq 0x6c0e
movq %rax, %r15
movq %rax, %rdi
callq 0x6c2f
xorl %r12d, %r12d
testq %rax, %rax
je 0x4ddc
movq (%rax), %rax
movq %rax, (%rbx,%r12,8)
incq %r12
movq %r15, %rdi
callq 0x6c2f
jmp 0x4dc3
movq %r15, %rdi
callq 0x6c6d
movq %r14, %rdi
callq 0x6c0e
movq %rax, %r14
movq %rax, %rdi
callq 0x6c2f
testq %rax, %rax
je 0x4e1d
movl %r12d, %ecx
leaq (%rbx,%rcx,8), %r15
movq (%rax), %rax
movq %rax, (%r15)
movq %r14, %rdi
callq 0x6c2f
addq $0x8, %r15
incl %r12d
testq %rax, %rax
jne 0x4e03
movq %r14, %rdi
callq 0x6c6d
movl %r12d, %esi
leaq -0xf3(%rip), %rcx       # 0x4d3c
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3110
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/bam2bedGraph.c
// Function: region_sam2wig
void region_sam2wig(DataBuf *databuf ,bam_index_t *idx,const char *region,FILE *bedGraph,dictType *mydictType){
	databuf->Start=dictCreate(mydictType,NULL);
	databuf->End=dictCreate(mydictType,NULL);
	int ref=bam_fetch_chr(idx,region,databuf);
	hash2BedGraph(databuf,ref,bedGraph);
	dictRelease(databuf->Start);
	dictRelease(databuf->End);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
xorl %esi, %esi
callq 0x6744
movq %rax, 0x8(%rbx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x6744
movq %rax, 0x10(%rbx)
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x4a96
movq %rbx, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0x4e4b
movq 0x8(%rbx), %rdi
callq 0x6b6f
movq 0x10(%rbx), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x6b6f
// File: /workspace/github_c_makefile_star2_O3/xiongxu[P]bam2bedGraph2/hiredis/./dict.c
// Function: dictExpand
int dictExpand(dict *ht, unsigned long size) {
    dict n; /* the new hashtable */
    unsigned long realsize = _dictNextPower(size), i;

    /* the size is invalid if it is smaller than the number of
     * elements already inside the hashtable */
    if (ht->used > size)
        return DICT_ERR;

    _dictInit(&n, ht->type, ht->privdata);
    n.size = realsize;
    n.sizemask = realsize-1;
    n.table = calloc(realsize,sizeof(dictEntry*));

    /* Copy all the elements from the old to the new table:
     * note that if the old hash table is empty ht->size is zero,
     * so dictExpand just creates an hash table. */
    n.used = ht->used;
    for (i = 0; i < ht->size && ht->used > 0; i++) {
        dictEntry *he, *nextHe;

        if (ht->table[i] == NULL) continue;

        /* For each hash entry on this slot... */
        he = ht->table[i];
        while(he) {
            unsigned int h;

            nextHe = he->next;
            /* Get the new element index */
            h = dictHashKey(ht, he->key) & n.sizemask;
            he->next = n.table[h];
            n.table[h] = he;
            ht->used--;
            /* Pass to the next element */
            he = nextHe;
        }
    }
    assert(ht->used == 0);
    free(ht->table);

    /* Remap the new hashtable in the old */
    *ht = n;
    return DICT_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movabsq $0x7ffffffffffffffe, %r14 # imm = 0x7FFFFFFFFFFFFFFE
cmpq %r14, %rsi
jbe 0x679d
incq %r14
jmp 0x67ad
movl $0x4, %eax
movq %rax, %r14
addq %rax, %rax
cmpq %rsi, %r14
jb 0x67a2
movq 0x20(%rbx), %r12
movl $0x1, %eax
cmpq %rsi, %r12
ja 0x688b
movq 0x8(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rbx), %rax
movq %rax, 0x18(%rsp)
leaq -0x1(%r14), %r13
movl $0x8, %esi
movq %r14, %rdi
callq 0x3330
movq %rax, %r15
movq 0x10(%rbx), %rcx
movq %r12, 0x8(%rsp)
movq %r12, %rax
testq %rcx, %rcx
je 0x6856
xorl %esi, %esi
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x685b
movq (%rbx), %rdx
movq (%rdx,%rsi,8), %r12
testq %r12, %r12
je 0x684e
movq %rsi, 0x20(%rsp)
movq (%r12), %rdi
movq 0x10(%r12), %rbp
movq 0x8(%rbx), %rax
callq *(%rax)
andl %r13d, %eax
movq (%r15,%rax,8), %rcx
movq %rcx, 0x10(%r12)
movq %r12, (%r15,%rax,8)
movq 0x20(%rbx), %rax
decq %rax
movq %rax, 0x20(%rbx)
movq %rbp, %r12
testq %rbp, %rbp
jne 0x6813
movq 0x10(%rbx), %rcx
movq 0x20(%rsp), %rsi
incq %rsi
cmpq %rcx, %rsi
jb 0x67fd
testq %rax, %rax
jne 0x689a
movq (%rbx), %rdi
callq 0x3060
movq %r15, (%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %r13, 0x18(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14d5f(%rip), %rdi     # 0x1b600
leaq 0x14d66(%rip), %rsi     # 0x1b60e
leaq 0x14d68(%rip), %rcx     # 0x1b617
movl $0x9d, %edx
callq 0x3260