LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_unit.c
// Function: create_unit_pos
int				*create_unit_pos(int exposent, int dbl_tab)
{
	int	*unit;
	int	j;
	int	stack;

	unit = (dbl_tab == DBL_TAB)
		? create_unit_pos_addentum() : create_lunit_pos_addentum();
	if (!unit || !unit[0])
		return (0);
	while (exposent--)
	{
		stack = 0;
		j = 0;
		while (j++ < unit[0])
		{
			unit[unit[1] - j + 1] = unit[unit[1] - j + 1] * 2 + stack;
			if (unit[unit[1] - j + 1] >= 1000000000 && (stack = 1))
				unit[unit[1] - j + 1] -= 1000000000;
			else
				stack = 0;
		}
		if (stack)
			unit[unit[1] - unit[0]++] = 1;
	}
	return (unit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
cmpl $0x79, %esi
jne 0x7229
callq 0x3690
jmp 0x722e
callq 0x3130
testq %rax, %rax
je 0x72b0
cmpl $0x0, (%rax)
je 0x72b0
testl %ebx, %ebx
je 0x72b2
cmpl $0x0, (%rax)
jle 0x72aa
xorl %ecx, %ecx
xorl %edx, %edx
xorl %esi, %esi
movl 0x4(%rax), %edi
addl %edx, %edi
movslq %edi, %rdi
movl (%rax,%rdi,4), %r8d
leal (%rsi,%r8,2), %esi
movl %esi, (%rax,%rdi,4)
movl 0x4(%rax), %esi
addl %edx, %esi
movslq %esi, %r8
movl (%rax,%r8,4), %edi
movl $0x0, %esi
cmpl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
jl 0x7282
leal -0x3b9aca00(%rdi), %esi
movl %esi, (%rax,%r8,4)
movl $0x1, %esi
movslq (%rax), %r8
decl %edx
incl %ecx
cmpl %r8d, %ecx
jl 0x7247
cmpl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
jl 0x72aa
movslq 0x4(%rax), %rcx
leal 0x1(%r8), %edx
movl %edx, (%rax)
subq %r8, %rcx
movl $0x1, (%rax,%rcx,4)
decl %ebx
jne 0x723c
jmp 0x72b2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_operand.c
// Function: multiply_unit_neg
int				multiply_unit_neg(int **unit)
{
	int	j;
	int	stack;

	stack = 0;
	j = (*unit)[0];
	while (j > 1)
	{
		(*unit)[j] = (*unit)[j] * 2 + stack;
		if ((*unit)[j] >= 1000000000)
		{
			stack = 1;
			(*unit)[j] -= 1000000000;
		}
		else
			stack = 0;
		j--;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movslq (%rax), %rcx
cmpq $0x2, %rcx
jl 0x72ff
incq %rcx
xorl %edx, %edx
movl -0x4(%rax,%rcx,4), %esi
leal (%rdx,%rsi,2), %edi
leal (%rdx,%rsi,2), %edx
addl $0xc4653600, %edx       # imm = 0xC4653600
xorl %esi, %esi
cmpl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
setge %sil
cmovll %edi, %edx
movl %edx, -0x4(%rax,%rcx,4)
decq %rcx
movl %esi, %edx
cmpq $0x2, %rcx
ja 0x72d1
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_operand.c
// Function: add_unit_neg
int				add_unit_neg(int **unit, int **stack)
{
	int	j;

	j = (*unit)[0];
	if (*(stack)[0] == 0)
		(*stack)[0] = (*unit)[0];
	while (j > 1)
	{
		(*stack)[j] += (*unit)[j];
		if ((*stack)[j] >= 1000000000)
		{
			(*stack)[j] -= 1000000000;
			(*stack)[j - 1] += 1;
		}
		j--;
	}
	return (0);
}

// Assembly:
movq (%rdi), %rax
movl (%rax), %ecx
movq (%rsi), %rdx
cmpl $0x0, (%rdx)
jne 0x7312
movl %ecx, (%rdx)
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %ecx
jl 0x7349
incq %rcx
movl -0x4(%rdx,%rcx,4), %esi
addl -0x4(%rax,%rcx,4), %esi
movl %esi, -0x4(%rdx,%rcx,4)
cmpl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
jl 0x7340
addl $0xc4653600, %esi       # imm = 0xC4653600
movl %esi, -0x4(%rdx,%rcx,4)
incl -0x8(%rdx,%rcx,4)
decq %rcx
cmpq $0x2, %rcx
jg 0x731e
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_operand.c
// Function: multiply_unit_pos
int				multiply_unit_pos(int **unit)
{
	int	j;
	int	stack;

	stack = 0;
	j = 0;
	while (j < (*unit)[0])
	{
		(*unit)[(*unit)[1] - j] = (*unit)[(*unit)[1] - j] * 2 + stack;
		if ((*unit)[(*unit)[1] - j] >= 1000000000)
		{
			stack = 1;
			(*unit)[(*unit)[1] - j] -= 1000000000;
		}
		else
			stack = 0;
		j++;
	}
	if (stack)
	{
		(*unit)[(*unit)[1] - (*unit)[0]] = 1;
		(*unit)[0]++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
cmpl $0x0, (%rax)
jle 0x73bd
xorl %ecx, %ecx
xorl %esi, %esi
xorl %edx, %edx
movslq 0x4(%rax), %rdi
addq %rcx, %rdi
movl (%rax,%rdi,4), %r8d
leal (%rsi,%r8,2), %esi
movl %esi, (%rax,%rdi,4)
movslq 0x4(%rax), %r8
addq %rcx, %r8
movl (%rax,%r8,4), %edi
movl $0x0, %esi
cmpl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
jl 0x7398
leal -0x3b9aca00(%rdi), %esi
movl %esi, (%rax,%r8,4)
movl $0x1, %esi
incl %edx
movslq (%rax), %r8
decq %rcx
cmpl %r8d, %edx
jl 0x735f
cmpl $0x3b9aca00, %edi       # imm = 0x3B9ACA00
jl 0x73bd
movslq 0x4(%rax), %rcx
subq %r8, %rcx
movl $0x1, (%rax,%rcx,4)
incl (%rax)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_operand.c
// Function: add_unit_pos
int				add_unit_pos(int **unit, int **stack)
{
	int	i;
	int	j;

	i = (*unit)[0];
	j = 0;
	while (j < i + 1)
	{
		(*stack)[(*unit)[1] - j] += (*unit)[(*unit)[1] - j];
		if ((*stack)[(*unit)[1] - j] >= 1000000000)
		{
			(*stack)[(*unit)[1] - j] -= 1000000000;
			(*stack)[(*unit)[1] - j - 1] += 1;
			if (j == i)
				(*unit)[0]++;
		}
		j++;
	}
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movl (%rax), %ecx
testl %ecx, %ecx
js 0x741e
movq (%rsi), %rdx
incl %ecx
xorl %esi, %esi
movslq 0x4(%rax), %rdi
addq %rsi, %rdi
movl (%rax,%rdi,4), %r8d
addl %r8d, (%rdx,%rdi,4)
movslq 0x4(%rax), %rdi
addq %rsi, %rdi
movl (%rdx,%rdi,4), %r8d
cmpl $0x3b9aca00, %r8d       # imm = 0x3B9ACA00
jl 0x7417
addl $0xc4653600, %r8d       # imm = 0xC4653600
movl %r8d, (%rdx,%rdi,4)
movl 0x4(%rax), %edi
addl %esi, %edi
decl %edi
movslq %edi, %rdi
incl (%rdx,%rdi,4)
cmpl $0x1, %ecx
jne 0x7417
incl (%rax)
decq %rsi
decl %ecx
jne 0x73d5
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_stack.c
// Function: create_stack_pos
int				create_stack_pos(int **unit, int **stack, int exposent,
					uint64_t mantissa)
{
	uint64_t	ll;
	int			i;

	if (!(*stack = (int*)malloc(sizeof(int) * (DBL_TAB + 1))))
		return (1);
	if (!(*unit = create_unit_pos(exposent, DBL_TAB)))
		return (free_and_return_int(*stack, 1));
	i = 0;
	while (i < DBL_TAB + 1)
		(*stack)[i++] = 0;
	ll = 1;
	while (ll < MTS_MAX)
	{
		if ((ll & mantissa))
			add_unit_pos(unit, stack);
		multiply_unit_pos(unit);
		ll *= 2;
	}
	add_unit_pos(unit, stack);
	(*stack)[0] = (*unit)[0];
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1e8, %edi            # imm = 0x1E8
callq 0x36a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x74b5
movl %r12d, %edi
movl $0x79, %esi
callq 0x3400
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x74c3
movl $0x1e8, %edx            # imm = 0x1E8
xorl %esi, %esi
callq 0x3240
movl $0x1, %r12d
testq %r15, %r12
je 0x7487
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3190
movq %r14, %rdi
callq 0x3610
leaq (%r12,%r12), %rax
shrq $0x33, %r12
movq %rax, %r12
je 0x7477
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3190
movq (%r14), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x74ba
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3410
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_stack.c
// Function: create_lstack_pos
int				create_lstack_pos(int **unit, int **stack, int exposent,
					uint64_t mantissa)
{
	uint64_t	ll;
	int			i;

	if (!(*stack = (int*)malloc(sizeof(int) * (LDBL_TAB + 1))))
		return (1);
	if (!(*unit = create_unit_pos(exposent, LDBL_TAB)))
		return (free_and_return_int(*stack, 1));
	i = 0;
	while (i < LDBL_TAB + 1)
		(*stack)[i++] = 0;
	ll = 1;
	while (ll < MTS2_MAX)
	{
		if ((ll & mantissa))
			add_unit_pos(unit, stack);
		multiply_unit_pos(unit);
		ll *= 2;
	}
	add_unit_pos(unit, stack);
	(*stack)[0] = (*unit)[0];
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1cec, %edi           # imm = 0x1CEC
callq 0x36a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x7566
movl %r12d, %edi
movl $0x73a, %esi            # imm = 0x73A
callq 0x3400
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x7574
movl $0x1cec, %edx           # imm = 0x1CEC
xorl %esi, %esi
callq 0x3240
movl $0x1, %r12d
testq %r15, %r12
je 0x7538
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3190
movq %r14, %rdi
callq 0x3610
leaq (%r12,%r12), %rax
shrq $0x3e, %r12
movq %rax, %r12
je 0x7528
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3190
movq (%r14), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x756b
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3410
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_stack.c
// Function: create_lstack_neg
int				create_lstack_neg(int **unit, int **stack, int exposent,
					uint64_t mantissa)
{
	uint64_t	ll;
	int			i;

	if (!(*stack = (int*)malloc(sizeof(int) * (LDBL_TAB + 1))))
		return (1);
	if (!(*unit = create_unit_neg(exposent, LDBL_TAB)))
		return (free_and_return_int(*stack, 1));
	i = 0;
	while (i < LDBL_TAB + 1)
		(*stack)[i++] = 0;
	ll = 1;
	if (exposent == -EXP2_MAX)
		multiply_unit_neg(unit);
	while (ll < MTS2_MAX)
	{
		if (ll & mantissa)
			add_unit_neg(unit, stack);
		multiply_unit_neg(unit);
		ll *= 2;
	}
	if (exposent != -EXP2_MAX)
		add_unit_neg(unit, stack);
	while ((*stack)[(*stack)[0]] == 0 && (*stack)[0] != 0)
		(*stack)[0]--;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1cec, %edi           # imm = 0x1CEC
callq 0x36a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x765e
movl %r15d, %edi
movl $0x73a, %esi            # imm = 0x73A
callq 0x3460
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x7672
movl $0x1cec, %edx           # imm = 0x1CEC
xorl %esi, %esi
callq 0x3240
cmpl $0xffffc001, %r15d      # imm = 0xFFFFC001
jne 0x75ef
movq %r14, %rdi
callq 0x31b0
movl $0x1, %r13d
testq %r12, %r13
je 0x7605
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq %r14, %rdi
callq 0x31b0
leaq (,%r13,2), %rax
shrq $0x3e, %r13
movq %rax, %r13
je 0x75f5
cmpl $0xffffc001, %r15d      # imm = 0xFFFFC001
je 0x7632
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq (%rbx), %rcx
movslq (%rcx), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x7663
cmpl $0x0, (%rcx,%rdx,4)
jne 0x7663
decq %rdx
movq %rdx, %rsi
movl %edx, (%rcx)
subq $0x1, %rsi
jb 0x7663
cmpl $0x0, (%rcx,%rdx,4)
movq %rsi, %rdx
je 0x764b
jmp 0x7663
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3410
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_stack.c
// Function: create_stack_neg
int				create_stack_neg(int **unit, int **stack, int exposent,
					uint64_t mantissa)
{
	uint64_t	ll;
	int			i;

	if (!(*stack = (int*)malloc(sizeof(int) * (DBL_TAB + 1))))
		return (1);
	if (!(*unit = create_unit_neg(exposent, DBL_TAB)))
		return (free_and_return_int(*stack, 1));
	i = 0;
	while (i < DBL_TAB + 1)
		(*stack)[i++] = 0;
	ll = 1;
	if (exposent == -EXP_MAX)
		multiply_unit_neg(unit);
	while (ll < MTS_MAX)
	{
		if (ll & mantissa)
			add_unit_neg(unit, stack);
		multiply_unit_neg(unit);
		ll *= 2;
	}
	if (exposent != -EXP_MAX)
		add_unit_neg(unit, stack);
	while ((*stack)[(*stack)[0]] == 0 && (*stack)[0] != 0)
		(*stack)[0]--;
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1e8, %edi            # imm = 0x1E8
callq 0x36a0
movq %rax, (%rbx)
testq %rax, %rax
je 0x7762
movl %r15d, %edi
movl $0x79, %esi
callq 0x3460
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x7776
movl $0x1e8, %edx            # imm = 0x1E8
xorl %esi, %esi
callq 0x3240
cmpl $0xfffffc01, %r15d      # imm = 0xFFFFFC01
jne 0x76f3
movq %r14, %rdi
callq 0x31b0
movl $0x1, %r13d
testq %r12, %r13
je 0x7709
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq %r14, %rdi
callq 0x31b0
leaq (,%r13,2), %rax
shrq $0x33, %r13
movq %rax, %r13
je 0x76f9
cmpl $0xfffffc01, %r15d      # imm = 0xFFFFFC01
je 0x7736
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq (%rbx), %rcx
movslq (%rcx), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x7767
cmpl $0x0, (%rcx,%rdx,4)
jne 0x7767
decq %rdx
movq %rdx, %rsi
movl %edx, (%rcx)
subq $0x1, %rsi
jb 0x7767
cmpl $0x0, (%rcx,%rdx,4)
movq %rsi, %rdx
je 0x774f
jmp 0x7767
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3410
nop
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_free_precision.c
// Function: finalize_precision
void			finalize_precision(char **str, size_t j)
{
	char	*tmp;

	(*str)[j] = 0;
	if ((*str)[0] == '-' + 1 || (*str)[0] == '9' + 1)
	{
		if ((*str)[0] == '-' + 1)
			tmp = ft_strjoin("-1", (*str) + 1);
		else
			tmp = ft_strjoin("10", (*str) + 1);
		free(*str);
		if (!tmp)
			return ;
		*str = tmp;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movb $0x0, (%rax,%rsi)
movq (%rdi), %rsi
movzbl (%rsi), %eax
cmpl $0x2e, %eax
je 0x77f2
cmpl $0x3a, %eax
jne 0x7814
leaq 0xbbf(%rip), %rdi       # 0x83af
jmp 0x77f9
leaq 0xbb3(%rip), %rdi       # 0x83ac
incq %rsi
callq 0x3540
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3120
testq %r14, %r14
je 0x7814
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_free_precision.c
// Function: handle_precision
void			handle_precision(char **str, size_t precision, uint32_t flags)
{
	size_t	i;
	size_t	j;
	size_t	b;
	size_t	len;

	len = ft_strlen(*str);
	b = ft_strchri(*str, '.');
	i = precision + b;
	if (i <= len)
	{
		j = i;
		(*str)[i] += 5;
		while (i > 0 && (*str)[i] > '9')
		{
			(*str)[i] -= 10;
			if ((*str)[i - 1] == '.' || (*str)[i - 1] == ',')
				i--;
			(*str)[--i] += 1;
		}
		finalize_precision(str, j);
	}
	if (precision == 0 && !(flags & F_SHARP))
		(*str)[b - 1] = 0;
	else if (precision == 0)
		(*str)[b] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3150
movq %rax, %r13
movq (%rbx), %rdi
movl $0x2e, %esi
callq 0x35c0
movq %rax, %r14
leaq (%rax,%r15), %rsi
cmpq %r13, %rsi
ja 0x789b
movq (%rbx), %rax
addb $0x5, (%rax,%rsi)
testq %rsi, %rsi
je 0x7893
movq %rsi, %rax
movq (%rbx), %rcx
movb (%rcx,%rax), %dl
cmpb $0x3a, %dl
jl 0x7893
addb $-0xa, %dl
movb %dl, (%rcx,%rax)
movq (%rbx), %rcx
movzbl -0x1(%rcx,%rax), %edx
orl $0x2, %edx
cmpl $0x2e, %edx
jne 0x7887
decq %rax
incb -0x1(%rcx,%rax)
decq %rax
testq %rax, %rax
jne 0x7863
movq %rbx, %rdi
callq 0x36c0
testq %r15, %r15
setne %al
shrl $0x1a, %r12d
andl $0x1, %r12d
orb %al, %r12b
jne 0x78b9
movq (%rbx), %rax
addq %rax, %r14
decq %r14
jmp 0x78c1
testq %r15, %r15
jne 0x78c5
addq (%rbx), %r14
movb $0x0, (%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_putnbr.c
// Function: ft_putnbr_neg
void		ft_putnbr_neg(int n, int end, char **tmp)
{
	size_t			len;
	int				buf;
	char			c;

	buf = n;
	buf = 100000000;
	len = 9;
	if (end)
	{
		while (n % 10 == 0 && n != 0)
		{
			n /= 10;
			buf /= 10;
			len--;
		}
		if (n == 0)
			len = 6 * (len == 9);
	}
	while (len--)
	{
		c = n / buf + '0';
		((*tmp)++)[0] = c;
		n %= buf;
		buf /= 10;
	}
}

// Assembly:
movq %rdx, %rcx
movl %edi, %edx
movl $0x5f5e100, %edi        # imm = 0x5F5E100
testl %esi, %esi
je 0x7997
testl %edx, %edx
je 0x799e
movslq %edx, %rax
imulq $0x66666667, %rax, %rsi # imm = 0x66666667
movq %rsi, %r8
shrq $0x3f, %r8
sarq $0x22, %rsi
addl %r8d, %esi
addl %esi, %esi
leal (%rsi,%rsi,4), %esi
subl %esi, %eax
jne 0x799e
movl $0x9, %esi
movl $0x5f5e100, %edi        # imm = 0x5F5E100
movl %edx, %eax
movslq %edx, %r8
imulq $0x66666667, %r8, %rdx  # imm = 0x66666667
movq %rdx, %r9
shrq $0x3f, %r9
sarq $0x22, %rdx
addl %r9d, %edx
movslq %edi, %rdi
imulq $0x66666667, %rdi, %rdi # imm = 0x66666667
movq %rdi, %r9
shrq $0x3f, %r9
sarq $0x22, %rdi
addl %r9d, %edi
decq %rsi
addl $-0xa, %r8d
cmpl $-0x14, %r8d
ja 0x7980
movslq %edx, %r8
imulq $0x66666667, %r8, %r9   # imm = 0x66666667
movq %r9, %r10
shrq $0x3f, %r10
sarq $0x22, %r9
addl %r10d, %r9d
addl %r9d, %r9d
leal (%r9,%r9,4), %r9d
subl %r9d, %r8d
je 0x791d
addl $0x9, %eax
cmpl $0x13, %eax
jae 0x79af
cmpq $0x9, %rsi
jne 0x79ea
movl $0x6, %esi
xorl %edx, %edx
jmp 0x79b4
movl $0x9, %esi
jmp 0x79b4
xorl %eax, %eax
testl %edx, %edx
setne %al
leaq (%rax,%rax,2), %rsi
addq $0x6, %rsi
jmp 0x79b4
testq %rsi, %rsi
je 0x79ea
pushq %rbp
movq %rsp, %rbp
movl %edx, %eax
cltd
idivl %edi
addb $0x30, %al
movq (%rcx), %r8
leaq 0x1(%r8), %r9
movslq %edi, %rdi
imulq $0x66666667, %rdi, %rdi # imm = 0x66666667
movq %rdi, %r10
shrq $0x3f, %r10
sarq $0x22, %rdi
addl %r10d, %edi
movq %r9, (%rcx)
movb %al, (%r8)
decq %rsi
jne 0x79b8
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_putnbr.c
// Function: ft_putnbr_pos_addentum
void		ft_putnbr_pos_addentum(int **stack, int *i, char **tmp, int dbl_tab)
{
	int				len;
	int				buf;
	char			c;
	int				dot;
	int				n;

	buf = 100000000;
	len = 9;
	dot = 6;
	n = (*stack)[*i];
	while (*i == dbl_tab - (*stack)[0] + 1 && buf > n && len--)
		buf /= 10;
	while (*i == dbl_tab - (*stack)[1] && dot > 0 && n % 10 == 0
			&& (n /= 10) && len-- && dot--)
		buf /= 10;
	while (len--)
	{
		c = n / buf + '0';
		((*tmp)++)[0] = c;
		if (*i == dbl_tab - (*stack)[1] && len == dot)
			((*tmp)++)[0] = '.';
		n %= buf;
		buf /= 10;
	}
	(*i)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r8
movq (%rdi), %r11
movslq (%rsi), %rdx
movl %ecx, %r9d
subl (%r11), %r9d
movl (%r11,%rdx,4), %eax
incl %r9d
cmpl %r9d, %edx
sete %r9b
cmpl $0x5f5e100, %eax        # imm = 0x5F5E100
setl %r10b
andb %r9b, %r10b
cmpb $0x1, %r10b
jne 0x7a56
movl $0x5f5e100, %r9d        # imm = 0x5F5E100
movl $0x9, %r10d
subl $0x1, %r10d
jb 0x7a64
movslq %r9d, %r9
imulq $0x66666667, %r9, %r9   # imm = 0x66666667
movq %r9, %rbx
shrq $0x3f, %rbx
sarq $0x22, %r9
addl %ebx, %r9d
cmpl %eax, %r9d
jg 0x7a31
jmp 0x7a6a
movl $0x9, %r10d
movl $0x5f5e100, %r9d        # imm = 0x5F5E100
jmp 0x7a6a
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movl %ecx, %ebx
subl 0x4(%r11), %ebx
movl $0x6, %r14d
cmpl %ebx, %edx
jne 0x7b30
movslq %eax, %r11
imulq $0x66666667, %r11, %r11 # imm = 0x66666667
movq %r11, %rbx
shrq $0x3f, %rbx
sarq $0x22, %r11
addl %ebx, %r11d
addl %r11d, %r11d
leal (%r11,%r11,4), %r11d
movl %eax, %ebx
subl %r11d, %ebx
jne 0x7b30
movl $0x6, %r11d
subl %r10d, %r11d
xorl %r15d, %r15d
leal 0x6(%r15), %r14d
leal (%r10,%r15), %ebx
leal 0x9(%rax), %r12d
cmpl $0x13, %r12d
jb 0x7b35
cltq
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %r12
shrq $0x3f, %r12
sarq $0x22, %rax
addl %r12d, %eax
testl %ebx, %ebx
je 0x7b40
movslq %r9d, %r9
imulq $0x66666667, %r9, %r9   # imm = 0x66666667
movq %r9, %rbx
shrq $0x3f, %rbx
sarq $0x22, %r9
addl %ebx, %r9d
decl %r15d
cmpl $0x2, %r14d
jb 0x7b26
movslq %eax, %rbx
imulq $0x66666667, %rbx, %r14 # imm = 0x66666667
movq %r14, %r12
shrq $0x3f, %r12
sarq $0x22, %r14
addl %r12d, %r14d
addl %r14d, %r14d
leal (%r14,%r14,4), %r14d
subl %r14d, %ebx
je 0x7ab4
addl %r15d, %r10d
addl $0x6, %r15d
movl %r15d, %r14d
movl %r10d, %ebx
jmp 0x7b37
xorl %eax, %eax
movl %r14d, %r11d
testl %ebx, %ebx
jne 0x7b45
jmp 0x7b9e
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
incl %r11d
cltd
idivl %r9d
addb $0x30, %al
movq (%r8), %r10
leaq 0x1(%r10), %r14
movq %r14, (%r8)
movb %al, (%r10)
movq (%rdi), %rax
movl %ecx, %r10d
subl 0x4(%rax), %r10d
movl %edx, %eax
cmpl %r10d, (%rsi)
jne 0x7b7e
cmpl %ebx, %r11d
jne 0x7b7e
movq (%r8), %rdx
leaq 0x1(%rdx), %r10
movq %r10, (%r8)
movb $0x2e, (%rdx)
decl %ebx
movslq %r9d, %rdx
imulq $0x66666667, %rdx, %r9  # imm = 0x66666667
movq %r9, %rdx
shrq $0x3f, %rdx
sarq $0x22, %r9
addl %edx, %r9d
testl %ebx, %ebx
jne 0x7b48
movl (%rsi), %edx
incl %edx
movl %edx, (%rsi)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_putnbr.c
// Function: ft_putnbr_pos
void		ft_putnbr_pos(int **stack, char **tmp, int dbl_tab, uint32_t flags)
{
	int		i;
	char	*test;

	test = *tmp;
	i = 6 + (dbl_tab == LDBL_TAB);
	(*stack)[1] = i;
	i = dbl_tab - (*stack)[0] + 1;
	if ((*stack)[i - 1])
	{
		(*stack)[0]++;
		i--;
	}
	if (flags & F_QUOTE)
	{
		while (i <= dbl_tab)
			ft_putnbr_pos_addentum2(stack, &i, &test, dbl_tab);
	}
	else
	{
		while (i <= dbl_tab)
			ft_putnbr_pos_addentum(stack, &i, &test, dbl_tab);
	}
	test[0] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
movq (%rsi), %rax
movq %rax, -0x30(%rbp)
xorl %edx, %edx
cmpl $0x73a, %ebx            # imm = 0x73A
sete %dl
orl $0x6, %edx
movq (%rdi), %rax
movl %edx, 0x4(%rax)
movl (%rax), %edi
movl %ebx, %esi
subl %edi, %esi
leal 0x1(%rsi), %edx
movl %edx, -0x24(%rbp)
movslq %esi, %r8
cmpl $0x0, (%rax,%r8,4)
je 0x7dd6
incl %edi
movl %edi, (%rax)
movl %esi, -0x24(%rbp)
movl %esi, %edx
btl $0x1b, %ecx
jb 0x7dff
cmpl %ebx, %edx
jg 0x7e20
leaq -0x24(%rbp), %r15
leaq -0x30(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x3500
cmpl %ebx, -0x24(%rbp)
jle 0x7de8
jmp 0x7e20
cmpl %ebx, %edx
jg 0x7e20
leaq -0x24(%rbp), %r15
leaq -0x30(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x3550
cmpl %ebx, -0x24(%rbp)
jle 0x7e0b
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: QmiWwanDeInit
static int QmiWwanDeInit(void) {
    unsigned int i;
    for (i = 0; i < sizeof(qmiclientId)/sizeof(qmiclientId[0]); i++)
    {
        if (qmiclientId[i] != 0)
        {
                QmiWwanReleaseClientID(i, qmiclientId[i]);
                qmiclientId[i] = 0;
        }
    }

    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %r12d, %r12d
leaq 0x24a22(%rip), %r13     # 0x2a340
leaq 0xe8a(%rip), %rbx       # 0x67af
leaq 0xe(%rsp), %r14
leaq 0x189e0(%rip), %r15     # 0x1e311
movb (%r12,%r13), %al
testb %al, %al
je 0x5969
movb %r12b, 0xe(%rsp)
movb %al, 0xf(%rsp)
movl $0x23, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x65f9
movq %rax, %rdi
xorl %esi, %esi
movl $0x7530, %edx           # imm = 0x7530
movq %r15, %rcx
callq 0xa273
movb $0x0, (%r12,%r13)
incq %r12
cmpq $0x1b, %r12
jne 0x5931
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: ComposeQCTLMsg
static PQCQMIMSG ComposeQCTLMsg(USHORT QMICTLType, CUSTOMQCTL customQctlMsgFunction, void *arg) {
    UCHAR QMIBuf[WDM_DEFAULT_BUFSIZE];
    PQCQMIMSG pRequest = (PQCQMIMSG)QMIBuf;
    int Length;

    pRequest->QMIHdr.IFType   = USB_CTL_MSG_TYPE_QMI;
    pRequest->QMIHdr.CtlFlags = 0x00;
    pRequest->QMIHdr.QMIType  = QMUX_TYPE_CTL;
    pRequest->QMIHdr.ClientId= 0x00;

    pRequest->CTLMsg.QMICTLMsgHdr.CtlFlags = QMICTL_FLAG_REQUEST;
    pRequest->CTLMsg.QMICTLMsgHdr.TransactionId = GetQCTLTransactionId();
    pRequest->CTLMsg.QMICTLMsgHdr.QMICTLType = cpu_to_le16(QMICTLType);
    if (customQctlMsgFunction)
        pRequest->CTLMsg.QMICTLMsgHdr.Length = cpu_to_le16(customQctlMsgFunction(&pRequest->CTLMsg, arg) - sizeof(QCQMICTL_MSG_HDR));
    else
        pRequest->CTLMsg.QMICTLMsgHdr.Length = cpu_to_le16(0x0000);

    pRequest->QMIHdr.Length = cpu_to_le16(le16_to_cpu(pRequest->CTLMsg.QMICTLMsgHdr.Length) + sizeof(QCQMICTL_MSG_HDR) + sizeof(QCQMI_HDR) - 1);
    Length = le16_to_cpu(pRequest->QMIHdr.Length) + 1;

    pRequest = (PQCQMIMSG)malloc(Length);
    if (pRequest == NULL) {
        dbg_time("%s fail to malloc", __func__);
    } else {
        memcpy(pRequest, QMIBuf, Length);
    }

    return pRequest;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdx, %r14
movq %rsi, %rbx
movb $0x1, (%rsp)
movl $0x0, 0x3(%rsp)
movl 0x23d41(%rip), %eax     # 0x2a35c
leal 0x1(%rax), %ecx
cmpl $0xff, %eax
movl $0x1, %eax
cmovll %ecx, %eax
movl %eax, 0x23d2b(%rip)     # 0x2a35c
movb %al, 0x7(%rsp)
callq 0xee7e
movw %ax, 0x8(%rsp)
testq %rbx, %rbx
je 0x6656
leaq 0x6(%rsp), %rdi
movq %r14, %rsi
callq *%rbx
addl $-0x6, %eax
movzwl %ax, %edi
jmp 0x6658
xorl %edi, %edi
callq 0xee7e
movw %ax, 0xa(%rsp)
movzwl %ax, %edi
callq 0xee73
addl $0xb, %eax
movzwl %ax, %edi
callq 0xee7e
movw %ax, 0x1(%rsp)
movzwl %ax, %edi
callq 0xee73
movzwl %ax, %r14d
incq %r14
movq %r14, %rdi
callq 0x5360
movq %rax, %rbx
testq %rax, %rax
je 0x66a9
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x52f0
jmp 0x6702
movq 0x23910(%rip), %rax     # 0x29fc0
movq (%rax), %r14
callq 0xea3b
leaq 0x1798f(%rip), %rsi     # 0x1e04e
leaq 0x179a0(%rip), %rcx     # 0x1e066
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
leaq 0x245ce(%rip), %rax     # 0x2aca8
movq (%rax), %r14
testq %r14, %r14
je 0x6702
callq 0xea3b
leaq 0x17960(%rip), %rsi     # 0x1e04e
leaq 0x17971(%rip), %rcx     # 0x1e066
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: CtlGetVersionReq
static USHORT CtlGetVersionReq(PQMICTL_MSG QCTLMsg, void *arg)
{
    (void)arg;
    QCTLMsg->GetVersionReq.TLVType = QCTLV_TYPE_REQUIRED_PARAMETER;
    QCTLMsg->GetVersionReq.TLVLength = cpu_to_le16(0x0001);
    QCTLMsg->GetVersionReq.QMUXTypes = QMUX_TYPE_ALL;
    return sizeof(QMICTL_GET_VERSION_REQ_MSG);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x6(%rdi)
movl $0x1, %edi
callq 0xee7e
movw %ax, 0x7(%rbx)
movb $-0x1, 0x9(%rbx)
movw $0xa, %ax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: CtlReleaseClientIdReq
static USHORT CtlReleaseClientIdReq(PQMICTL_MSG QCTLMsg, void *arg) {
   QCTLMsg->ReleaseClientIdReq.TLVType       = QCTLV_TYPE_REQUIRED_PARAMETER;
   QCTLMsg->ReleaseClientIdReq.TLVLength     = cpu_to_le16(0x0002);
   QCTLMsg->ReleaseClientIdReq.QMIType     = ((UCHAR *)arg)[0];
   QCTLMsg->ReleaseClientIdReq.ClientId = ((UCHAR *)arg)[1] ;
   return sizeof(QMICTL_RELEASE_CLIENT_ID_REQ_MSG);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x6(%rdi)
movl $0x2, %edi
callq 0xee7e
movw %ax, 0x7(%r14)
movb (%rbx), %al
movb %al, 0x9(%r14)
movb 0x1(%rbx), %al
movb %al, 0xa(%r14)
movw $0xb, %ax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/GobiNetCM.c
// Function: GobiNetDeInit
static int GobiNetDeInit(void) {
    unsigned int i;
    for (i = 0; i < sizeof(qmiclientId)/sizeof(qmiclientId[0]); i++)
    {
        if (qmiclientId[i] != 0)
        {
            close(qmiclientId[i]);
            qmiclientId[i] = 0;
        }
    }

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x23b6b(%rip), %r14     # 0x2a360
movl (%rbx,%r14), %edi
testl %edi, %edi
je 0x680a
callq 0x5230
movl $0x0, (%rbx,%r14)
addq $0x4, %rbx
cmpq $0x6c, %rbx
jne 0x67f5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/GobiNetCM.c
// Function: GobiNetSendQMI
static int GobiNetSendQMI(PQCQMIMSG pRequest) {
    int ret, fd;

    fd = qmiclientId[pRequest->QMIHdr.QMIType];
    pRequest->QMIHdr.ClientId = (fd&0xFF) ? fd&0xFF : pRequest->QMIHdr.QMIType;

    if (fd <= 0) {
        dbg_time("%s QMIType: %d has no clientID", __func__, pRequest->QMIHdr.QMIType);
        return -ENODEV;
    }

    // Always ready to write
    if (1 == 1) {
        ssize_t nwrites = le16_to_cpu(pRequest->QMIHdr.Length) + 1 - sizeof(QCQMI_HDR);
        ret = write(fd, &pRequest->MUXMsg, nwrites);
        if (ret == nwrites) {
            ret = 0;
        } else {
            dbg_time("%s write=%d, errno: %d (%s)", __func__, ret, errno, strerror(errno));
        }
    } else {
        dbg_time("%s poll=%d, errno: %d (%s)", __func__, ret, errno, strerror(errno));
    }

    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movzbl 0x4(%rdi), %eax
leaq 0x23b28(%rip), %rcx     # 0x2a360
movl (%rcx,%rax,4), %ebp
testb %bpl, %bpl
cmovnel %ebp, %eax
movb %al, 0x5(%rdi)
testl %ebp, %ebp
jle 0x6911
movzwl 0x1(%rbx), %edi
callq 0xee73
movzwl %ax, %r14d
addq $-0x5, %r14
addq $0x6, %rbx
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5100
movq %rax, %rbx
movslq %ebx, %rax
xorl %ebp, %ebp
cmpq %r14, %rax
je 0x6979
movq 0x2373a(%rip), %rax     # 0x29fc0
movq (%rax), %r15
callq 0xea3b
movq %rax, %r12
callq 0x5070
movq %rax, %r14
movl (%rax), %ebp
movl %ebp, %edi
callq 0x5530
movq %rax, (%rsp)
leaq 0x17811(%rip), %rsi     # 0x1e0be
leaq 0x17ac5(%rip), %rcx     # 0x1e379
movq %r15, %rdi
movq %r12, %rdx
movl %ebx, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x52c0
leaq 0x243da(%rip), %rax     # 0x2aca8
movq (%rax), %r15
testq %r15, %r15
je 0x690d
callq 0xea3b
movq %rax, %r12
movl (%r14), %ebp
movl %ebp, %edi
callq 0x5530
movq %rax, (%rsp)
leaq 0x177cb(%rip), %rsi     # 0x1e0be
leaq 0x17a7f(%rip), %rcx     # 0x1e379
movq %r15, %rdi
movq %r12, %rdx
movl %ebx, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x52c0
movl %ebx, %ebp
jmp 0x6979
movq 0x236a8(%rip), %rax     # 0x29fc0
movq (%rax), %r14
callq 0xea3b
movzbl 0x4(%rbx), %r8d
leaq 0x17a28(%rip), %rsi     # 0x1e354
leaq 0x17a46(%rip), %rcx     # 0x1e379
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
leaq 0x24361(%rip), %rax     # 0x2aca8
movq (%rax), %r14
movl $0xffffffed, %ebp       # imm = 0xFFFFFFED
testq %r14, %r14
je 0x6979
callq 0xea3b
movzbl 0x4(%rbx), %r8d
leaq 0x179ef(%rip), %rsi     # 0x1e354
leaq 0x17a0d(%rip), %rcx     # 0x1e379
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/main.c
// Function: ql_sigaction
static void ql_sigaction(int signo) {
     if (SIGALRM == signo)
         send_signo_to_main(SIG_EVENT_START);
     else
     {
        g_donot_exit_when_modem_hangup = 0;
        send_signo_to_main(SIG_EVENT_STOP);
        main_send_event_to_qmidevice(SIG_EVENT_STOP); //main may be wating qmi response
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
cmpl $0xe, %edi
jne 0x7e88
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movl 0x2292e(%rip), %edi     # 0x2a7b4
jmp 0x7ebb
movl $0x0, 0x22542(%rip)     # 0x2a3d4
movl $0x2, %ebx
leaq 0x8(%rsp), %rsi
movl %ebx, (%rsi)
movl 0x22910(%rip), %edi     # 0x2a7b4
movl $0x4, %edx
callq 0x5100
leaq 0xc(%rsp), %rsi
movl %ebx, (%rsi)
movl 0x2251d(%rip), %edi     # 0x2a3d8
movl $0x4, %edx
callq 0x5100
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/main.c
// Function: usbnet_link_change
static void usbnet_link_change(int link, PROFILE_T *profile) {
    if (s_link == link)
        return;

    s_link = link;

    if (!(link & (1<<IpFamilyV4)))
        memset(&profile->ipv4, 0, sizeof(IPV4_T));

    if (!(link & (1<<IpFamilyV6)))
        memset(&profile->ipv6, 0, sizeof(IPV6_T));

    if (link) {
        udhcpc_start(profile);
    } else {
        udhcpc_stop(profile);
    }
}

// Assembly:
cmpl %edi, 0x20cec(%rip)     # 0x2a2f4
jne 0x960b
retq
movl %edi, 0x20ce3(%rip)     # 0x2a2f4
testb $0x10, %dil
jne 0x962c
xorps %xmm0, %xmm0
movups %xmm0, 0x20ee5(%rip)    # 0x2a506
movq $0x0, 0x20eea(%rip) # 0x2a516
testb $0x40, %dil
jne 0x9667
xorps %xmm0, %xmm0
movups %xmm0, 0x20f22(%rip)    # 0x2a55e
movups %xmm0, 0x20f0b(%rip)    # 0x2a54e
movups %xmm0, 0x20ef4(%rip)    # 0x2a53e
movups %xmm0, 0x20edd(%rip)    # 0x2a52e
movups %xmm0, 0x20ec6(%rip)    # 0x2a51e
movq $0x0, 0x20f09(%rip) # 0x2a56c
testl %edi, %edi
je 0x9673
leaq 0x20d72(%rip), %rdi     # 0x2a3e0
jmp 0x1c243
leaq 0x20d66(%rip), %rdi     # 0x2a3e0
jmp 0x1d244
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/main.c
// Function: ls_dir
static int ls_dir(const char *dir, int (*match)(const char *dir, const char *file, void *argv[]), void *argv[])
{
    DIR *pDir;
    struct dirent* ent = NULL;
    int match_times = 0;

    pDir = opendir(dir);
    if (pDir == NULL)  {
        dbg_time("Cannot open directory: %s, errno: %d (%s)", dir, errno, strerror(errno));
        return 0;
    }

    while ((ent = readdir(pDir)) != NULL)  {
        match_times += match(dir, ent->d_name, argv);
    }
    closedir(pDir);

    return match_times;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5140
testq %rax, %rax
je 0x96d8
movq %rax, %r14
movq %rax, %rdi
callq 0x5320
xorl %ebp, %ebp
testq %rax, %rax
je 0x96cb
addq $0x13, %rax
movq %rbx, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq *%r12
addl %eax, %ebp
movq %r14, %rdi
callq 0x5320
jmp 0x96aa
movq %r14, %rdi
callq 0x5240
jmp 0x975d
movq 0x208e1(%rip), %rax     # 0x29fc0
movq (%rax), %r15
callq 0xea3b
movq %rax, %r12
callq 0x5070
movq %rax, %r14
movl (%rax), %r13d
movl %r13d, %edi
callq 0x5530
leaq 0x15694(%rip), %rsi     # 0x1ed98
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movl %r13d, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x52c0
leaq 0x21585(%rip), %rax     # 0x2aca8
movq (%rax), %r15
testq %r15, %r15
je 0x975d
callq 0xea3b
movq %rax, %r12
movl (%r14), %r14d
movl %r14d, %edi
callq 0x5530
leaq 0x15653(%rip), %rsi     # 0x1ed98
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movl %r14d, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x52c0
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/main.c
// Function: is_same_linkfile
static int is_same_linkfile(const char *dir, const char *file,  void *argv[])
{
    const char *qmichannel = (const char *)argv[1];
    char linkname[MAX_PATH];
    char filename[MAX_PATH];
    int linksize;

    snprintf(linkname, MAX_PATH, "%s/%s", dir, file);
    linksize = readlink(linkname, filename, MAX_PATH);
    if (linksize <= 0)
        return 0;

    filename[linksize] = 0;
    if (strcmp(filename, qmichannel))
        return 0;

    dbg_time("%s -> %s", linkname, filename);
    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r8
movq %rdi, %rcx
movq 0x8(%rdx), %r14
leaq 0x15473(%rip), %rdx     # 0x1ee12
xorl %ebx, %ebx
leaq 0x100(%rsp), %r15
movl $0x100, %esi            # imm = 0x100
movq %r15, %rdi
xorl %eax, %eax
callq 0x51c0
movq %rsp, %rsi
movl $0x100, %edx            # imm = 0x100
movq %r15, %rdi
callq 0x50d0
testl %eax, %eax
jle 0x9a4a
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movb $0x0, (%rsp,%rax)
movq %rsp, %rdi
movq %r14, %rsi
callq 0x52a0
testl %eax, %eax
jne 0x9a4a
movq 0x205d5(%rip), %rax     # 0x29fc0
movq (%rax), %rbx
callq 0xea3b
leaq 0x1541e(%rip), %rsi     # 0x1ee18
leaq 0x100(%rsp), %rcx
movq %rsp, %r8
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
leaq 0x2128f(%rip), %rax     # 0x2aca8
movq (%rax), %r14
movl $0x1, %ebx
testq %r14, %r14
je 0x9a4a
callq 0xea3b
leaq 0x153e6(%rip), %rsi     # 0x1ee18
leaq 0x100(%rsp), %rcx
movq %rsp, %r8
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
movl %ebx, %eax
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/MPQMUX.c
// Function: dump_tlv
void dump_tlv(PQCQMUX_MSG_HDR pQMUXMsgHdr) {
    int TLVFind = 0;
    int i;
    //dbg("QCQMUX_TLV-----------------------------------\n");
    //dbg("{Type,\tLength,\tValue}\n");

    while (1) {
        PQMI_TLV_HDR TLVHdr = GetTLV(pQMUXMsgHdr, 0x1000 + (++TLVFind));
        if (TLVHdr == NULL)
            break;

        //if ((TLVHdr->TLVType == 0x02) && ((USHORT *)(TLVHdr+1))[0])
        {        
            dbg("{%02x,\t%04x,\t", TLVHdr->TLVType, le16_to_cpu(TLVHdr->TLVLength));
            for (i = 0; i < le16_to_cpu(TLVHdr->TLVLength); i++) {
                dbg("%02x ", ((UCHAR *)(TLVHdr+1))[i]);
            }
            dbg("}\n");
        }
    }  // while
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
movl $0x1001, %esi           # imm = 0x1001
callq 0xa1f8
testq %rax, %rax
je 0x9b87
movq %rax, %r15
movl $0x1, %ebp
leaq 0x20d31(%rip), %r14     # 0x2a7c0
leaq 0x1540c(%rip), %r13     # 0x1eea2
movq %r12, 0x10(%rsp)
movq %r14, %rdi
callq 0x5160
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x9aea
leaq (%r14,%rax), %r12
movl $0x400, %ebx            # imm = 0x400
subq %rax, %rbx
movzbl (%r15), %eax
movl %eax, 0xc(%rsp)
movzwl 0x1(%r15), %edi
callq 0xee73
movzwl %ax, %r8d
movq %r12, %rdi
movq 0x10(%rsp), %r12
movq %rbx, %rsi
leaq 0x153b5(%rip), %rdx     # 0x1ee94
movl 0xc(%rsp), %ecx
xorl %eax, %eax
callq 0x51c0
movzwl 0x1(%r15), %edi
callq 0xee73
testw %ax, %ax
je 0x9b3c
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x5160
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x9b27
leaq (%r14,%rax), %rdi
movl $0x400, %esi            # imm = 0x400
subq %rax, %rsi
movzbl 0x3(%r15,%rbx), %ecx
movq %r13, %rdx
xorl %eax, %eax
callq 0x51c0
incq %rbx
movzwl 0x1(%r15), %edi
callq 0xee73
movzwl %ax, %eax
cmpq %rax, %rbx
jb 0x9afb
movq %r14, %rdi
callq 0x5160
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x9b66
leaq (%r14,%rax), %rdi
movl $0x400, %esi            # imm = 0x400
subq %rax, %rsi
leaq 0x15349(%rip), %rdx     # 0x1eea8
xorl %eax, %eax
callq 0x51c0
leal 0x1(%rbp), %ebx
addl $0x1001, %ebp           # imm = 0x1001
movq %r12, %rdi
movl %ebp, %esi
callq 0xa1f8
movq %rax, %r15
movl %ebx, %ebp
testq %rax, %rax
jne 0x9a9b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/MPQMUX.c
// Function: dump_ctl
void dump_ctl(PQCQMICTL_MSG_HDR CTLHdr) {
    const char *tag;
    
    //dbg("QCQMICTL_MSG--------------------------------------------\n");
    //dbg("CtlFlags:           %02x\t\t%s\n", CTLHdr->CtlFlags, QMI_NAME(qmi_ctl_CtlFlags, CTLHdr->CtlFlags));
   dbg("TransactionId:      %02x\n", CTLHdr->TransactionId);
        switch (CTLHdr->CtlFlags) {
            case QMICTL_FLAG_REQUEST: tag = "_REQ"; break;
            case QMICTL_FLAG_RESPONSE: tag = "_RESP"; break;
            case QMICTL_FLAG_INDICATION: tag = "_IND"; break;
            default: tag = 0; break;
       }
        dbg("QMICTLType:         %04x\t%s\n", le16_to_cpu(CTLHdr->QMICTLType),
        QMUX_NAME(qmux_ctl_QMICTLType, le16_to_cpu(CTLHdr->QMICTLType), tag));     
        dbg("Length:             %04x\n", le16_to_cpu(CTLHdr->Length));

     dump_tlv((PQCQMUX_MSG_HDR)(&CTLHdr->QMICTLType));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x20c18(%rip), %r14     # 0x2a7c0
movq %r14, %rdi
callq 0x5160
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x9bd8
addq %rax, %r14
movl $0x400, %esi            # imm = 0x400
subq %rax, %rsi
movzbl 0x1(%rbx), %ecx
leaq 0x152dd(%rip), %rdx     # 0x1eeab
movq %r14, %rdi
xorl %eax, %eax
callq 0x51c0
movzbl (%rbx), %eax
cmpq $0x2, %rax
ja 0x9bf1
leaq 0x152a0(%rip), %rcx     # 0x1ee88
movslq (%rcx,%rax,4), %r14
addq %rcx, %r14
jmp 0x9bf4
xorl %r14d, %r14d
leaq 0x20bc5(%rip), %r15     # 0x2a7c0
movq %r15, %rdi
callq 0x5160
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x9c5c
addq %rax, %r15
movl $0x400, %r12d           # imm = 0x400
subq %rax, %r12
movzwl 0x2(%rbx), %edi
callq 0xee73
movzwl %ax, %ebp
movzwl 0x2(%rbx), %edi
callq 0xee73
movzwl %ax, %edx
leaq 0x1e9ca(%rip), %rdi     # 0x28600
movl $0xf, %esi
movq %r14, %rcx
callq 0x9cb3
leaq 0x1527b(%rip), %rdx     # 0x1eec5
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %ecx
movq %rax, %r8
xorl %eax, %eax
callq 0x51c0
leaq 0x20b5d(%rip), %r14     # 0x2a7c0
movq %r14, %rdi
callq 0x5160
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0x9c9f
addq %rax, %r14
movl $0x400, %r15d           # imm = 0x400
subq %rax, %r15
movzwl 0x4(%rbx), %edi
callq 0xee73
movzwl %ax, %ecx
leaq 0x15250(%rip), %rdx     # 0x1eee2
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x51c0
addq $0x2, %rbx
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9a5c
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/MPQMUX.c
// Function: qmi_name_get
static const char * qmi_name_get(const QMI_NAME_T *table, size_t size, int type, const char *tag) {
    static char unknow[40];
    size_t i;

    if (qmux_CtlFlags == table) {
        if (!strcmp(tag, "_REQ"))
            tag = "_CMD";
        else  if (!strcmp(tag, "_RESP"))
            tag = "_RSP";
    }
    
    for (i = 0; i < size; i++) {
        if (table[i].type == (UINT)type) {
            if (!tag || (strstr(table[i].name, tag)))
                return table[i].name;
        }
    }
    sprintf(unknow, "unknow_%x", type);
    return unknow;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x1f602(%rip), %rax     # 0x292d0
cmpq %rax, %rdi
jne 0x9d0b
leaq 0x15824(%rip), %rsi     # 0x1f4fe
movq %r14, %rdi
callq 0x52a0
testl %eax, %eax
je 0x9d04
leaq 0x1582f(%rip), %rsi     # 0x1f51c
movq %r14, %rdi
callq 0x52a0
testl %eax, %eax
leaq 0x15284(%rip), %rax     # 0x1ef82
cmoveq %rax, %r14
jmp 0x9d0b
leaq 0x15260(%rip), %r14     # 0x1ef6b
testq %r15, %r15
je 0x9d3d
addq $0x8, %r12
cmpl %ebx, -0x8(%r12)
jne 0x9d34
movq (%r12), %r13
testq %r14, %r14
je 0x9d57
movq %r13, %rdi
movq %r14, %rsi
callq 0x5550
testq %rax, %rax
jne 0x9d57
addq $0x10, %r12
decq %r15
jne 0x9d14
leaq 0x20eac(%rip), %r13     # 0x2abf0
leaq 0x15204(%rip), %rsi     # 0x1ef4f
movq %r13, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x54e0
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/MPQMUX.c
// Function: dump_qmi
void dump_qmi(void *dataBuffer, int dataLen) 
{
    PQCQMI_HDR QMIHdr = (PQCQMI_HDR)dataBuffer;
    PQCQMUX_HDR QMUXHdr = (PQCQMUX_HDR) (QMIHdr + 1);
    PQCQMICTL_MSG_HDR CTLHdr =  (PQCQMICTL_MSG_HDR) (QMIHdr + 1);

    int i;

    if (!debug_qmi)
        return;

    pthread_mutex_lock(&dumpQMIMutex);
    line[0] = 0;
    for (i = 0; i < dataLen; i++) {
        dbg("%02x ", ((unsigned char *)dataBuffer)[i]);
    }
    dbg_time("%s", line);
    line[0] = 0;
    
    //dbg("QCQMI_HDR-----------------------------------------");
    //dbg("IFType:             %02x\t\t%s", QMIHdr->IFType, QMI_NAME(qmi_IFType, QMIHdr->IFType));
    //dbg("Length:             %04x", le16_to_cpu(QMIHdr->Length));
    //dbg("CtlFlags:           %02x\t\t%s", QMIHdr->CtlFlags, QMI_NAME(qmi_CtlFlags, QMIHdr->CtlFlags));
    //dbg("QMIType:            %02x\t\t%s", QMIHdr->QMIType, QMI_NAME(qmi_QMIType, QMIHdr->QMIType));
    //dbg("ClientId:           %02x", QMIHdr->ClientId);

    if (QMIHdr->QMIType == QMUX_TYPE_CTL) {
        dump_ctl(CTLHdr);
    } else {
        dump_qmux(QMIHdr->QMIType, QMUXHdr);
    }
    dbg_time("%s", line);
    pthread_mutex_unlock(&dumpQMIMutex);
}

// Assembly:
leaq 0x20335(%rip), %rax     # 0x2a3d0
cmpl $0x0, (%rax)
je 0xa189
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20b05(%rip), %rdi     # 0x2abc0
callq 0x5560
movb $0x0, 0x206f9(%rip)     # 0x2a7c0
testl %ebp, %ebp
jle 0xa112
movl %ebp, %r12d
leaq 0x206eb(%rip), %r14     # 0x2a7c0
leaq 0x14dc6(%rip), %r15     # 0x1eea2
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x5160
cmpq $0x3ff, %rax            # imm = 0x3FF
ja 0xa10a
leaq (%r14,%rax), %rdi
movl $0x400, %esi            # imm = 0x400
subq %rax, %rsi
movzbl (%rbx,%r13), %ecx
movq %r15, %rdx
xorl %eax, %eax
callq 0x51c0
incq %r13
cmpq %r13, %r12
jne 0xa0df
movq 0x1fea7(%rip), %r15     # 0x29fc0
movq (%r15), %r14
callq 0xea3b
leaq 0x14e1e(%rip), %rsi     # 0x1ef46
leaq 0x20691(%rip), %rcx     # 0x2a7c0
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
leaq 0x20b65(%rip), %r12     # 0x2aca8
movq (%r12), %r14
testq %r14, %r14
je 0xa16c
callq 0xea3b
leaq 0x14dee(%rip), %rsi     # 0x1ef46
leaq 0x20661(%rip), %rcx     # 0x2a7c0
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
movb $0x0, 0x2064d(%rip)     # 0x2a7c0
movzbl 0x4(%rbx), %edi
addq $0x6, %rbx
testl %edi, %edi
je 0xa18a
movq %rbx, %rsi
callq 0x9d64
jmp 0xa192
retq
movq %rbx, %rdi
callq 0x9b96
movq (%r15), %rbx
callq 0xea3b
leaq 0x14da5(%rip), %rsi     # 0x1ef46
leaq 0x20618(%rip), %rcx     # 0x2a7c0
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
movq (%r12), %rbx
testq %rbx, %rbx
je 0xa1de
callq 0xea3b
leaq 0x14d7c(%rip), %rsi     # 0x1ef46
leaq 0x205ef(%rip), %rcx     # 0x2a7c0
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
leaq 0x209db(%rip), %rdi     # 0x2abc0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5340
// File: /workspace/github_c_makefile_star2_O3/Carton32[P]quectel-CM/QMIThread.c
// Function: GetTLV
PQMI_TLV_HDR GetTLV (PQCQMUX_MSG_HDR pQMUXMsgHdr, int TLVType) {
    int TLVFind = 0;
    USHORT Length = le16_to_cpu(pQMUXMsgHdr->Length);
    PQMI_TLV_HDR pTLVHdr = (PQMI_TLV_HDR)(pQMUXMsgHdr + 1);

    while (Length >= sizeof(QMI_TLV_HDR)) {
        TLVFind++;
        if (TLVType > 0x1000) {
            if ((TLVFind + 0x1000) == TLVType)
                return pTLVHdr;
        } else  if (pTLVHdr->TLVType == TLVType) {
            return pTLVHdr;
        }

        Length -= (le16_to_cpu((pTLVHdr->TLVLength)) + sizeof(QMI_TLV_HDR));
        pTLVHdr = (PQMI_TLV_HDR)(((UCHAR *)pTLVHdr) + le16_to_cpu(pTLVHdr->TLVLength) + sizeof(QMI_TLV_HDR));
    }

   return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movzwl 0x2(%rdi), %edi
callq 0xee73
cmpw $0x3, %ax
jb 0xa263
movl %eax, %r14d
addq $0x4, %rbx
movl $0x1001, %r15d          # imm = 0x1001
cmpl $0x1001, %ebp           # imm = 0x1001
jl 0xa22f
cmpl %r15d, %ebp
jne 0xa236
jmp 0xa265
movzbl (%rbx), %eax
cmpl %ebp, %eax
je 0xa265
movzwl 0x1(%rbx), %edi
callq 0xee73
subl %eax, %r14d
addl $-0x3, %r14d
movzwl 0x1(%rbx), %edi
callq 0xee73
movzwl %ax, %eax
addq %rax, %rbx
addq $0x3, %rbx
incl %r15d
cmpw $0x2, %r14w
ja 0xa220
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq