LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_bigint.c
// Function: exp_pos
char		*exp_pos(uint32_t flags, int exp, uint64_t mantissa, int dbl_t)
{
	char	*str;
	char	*tmp;
	int		*unit;
	int		*stack;

	if ((dbl_t == LDBL_TAB && create_lstack_pos(&unit, &stack, exp, mantissa))
		|| (dbl_t == DBL_TAB && create_stack_pos(&unit, &stack, exp, mantissa)))
		return (0);
	free(unit);
	if (!(str = ft_strnew((stack[0] + 1) * 12 + 2)))
		return (free_and_return_char(stack, 0));
	tmp = str;
	ft_putnbr_pos(&stack, &tmp, dbl_t, flags);
	return (free_and_return_char(stack, str));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movq %rdx, %rcx
movl %esi, %edx
movl %edi, %r14d
cmpl $0x79, %ebx
je 0x69d6
cmpl $0x73a, %ebx            # imm = 0x73A
jne 0x69eb
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3460
jmp 0x69e3
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3290
testl %eax, %eax
je 0x69eb
xorl %eax, %eax
jmp 0x6a3a
movq -0x30(%rbp), %rdi
callq 0x3110
movq -0x28(%rbp), %rax
imull $0xc, (%rax), %eax
addl $0xe, %eax
movslq %eax, %rdi
callq 0x3330
testq %rax, %rax
je 0x6a2f
movq %rax, %r15
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x28(%rbp), %r12
movq %r12, %rdi
movl %ebx, %edx
movl %r14d, %ecx
callq 0x3580
movq (%r12), %rdi
movq %r15, %rsi
jmp 0x6a35
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x30c0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_bigint.c
// Function: exp_neg
char		*exp_neg(uint64_t sign, int exp, uint64_t mantissa, int dbl_t)
{
	char	*str;
	char	*tmp;
	int		*unit;
	int		*stack;
	int		i;

	if ((dbl_t == LDBL_TAB && create_lstack_neg(&unit, &stack, exp, mantissa))
		|| (dbl_t == DBL_TAB && create_stack_neg(&unit, &stack, exp, mantissa)))
		return (0);
	free(unit);
	if (!(str = ft_strnew(((stack[0] + 1) * 9 + 3))))
		return (free_and_return_char(stack, 0));
	tmp = str;
	i = 0;
	if (sign)
		str[i++] = '-';
	ft_strcat(str + i, "0.");
	tmp = str + i + 2;
	i = 2;
	while (i < stack[0])
		ft_putnbr_neg(stack[i++], 0, &tmp);
	ft_putnbr_neg(stack[i], 1, &tmp);
	tmp[0] = 0;
	return (free_and_return_char(stack, str));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rax
movl %esi, %edx
movq %rdi, %r14
cmpl $0x79, %ecx
je 0x6a7b
cmpl $0x73a, %ecx            # imm = 0x73A
jne 0x6a96
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rax, %rcx
callq 0x3490
jmp 0x6a8b
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movq %rax, %rcx
callq 0x33c0
testl %eax, %eax
je 0x6a96
xorl %eax, %eax
jmp 0x6b3b
movq -0x28(%rbp), %rdi
callq 0x3110
movq -0x20(%rbp), %rax
movl (%rax), %eax
leal (%rax,%rax,8), %eax
addl $0xc, %eax
movslq %eax, %rdi
callq 0x3330
testq %rax, %rax
je 0x6ac9
movq %rax, %rbx
testq %r14, %r14
je 0x6ad1
movb $0x2d, (%rbx)
pushq $0x1
popq %r14
jmp 0x6ad4
movq -0x20(%rbp), %rdi
xorl %esi, %esi
jmp 0x6b36
xorl %r14d, %r14d
leaq (%rbx,%r14), %rdi
leaq 0x18ba(%rip), %rsi      # 0x8399
callq 0x3170
leaq (%rbx,%r14), %rax
addq $0x2, %rax
leaq -0x30(%rbp), %r14
movq %rax, (%r14)
pushq $0x2
popq %r15
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
cmpq %rcx, %r15
jge 0x6b16
movl (%rax,%r15,4), %edi
incq %r15
xorl %esi, %esi
movq %r14, %rdx
callq 0x31e0
jmp 0x6af7
movl (%rax,%r15,4), %edi
pushq $0x1
popq %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdx
callq 0x31e0
movq (%r14), %rax
movb $0x0, (%rax)
movq -0x20(%rbp), %rdi
movq %rbx, %rsi
callq 0x30c0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_bigint.c
// Function: ft_dbltoa
char		*ft_dbltoa(double x, size_t precision, uint32_t flags)
{
	uint64_t	sign;
	int			exposent;
	uint64_t	mantissa;
	char		*str;

	ft_memcpy(&mantissa, &x, sizeof(uint64_t));
	exposent = ((mantissa << 1) >> 53) - EXP_MAX;
	sign = (mantissa >> 63);
	mantissa = ((mantissa << 12) >> 12);
	if (exposent >= EXP_MAX + 1)
		str = infnan(sign, mantissa);
	else if (exposent >= 0)
		str = exp_pos(flags, exposent, mantissa, DBL_TAB);
	else
		str = exp_neg(sign, exposent, mantissa, DBL_TAB);
	if (!str || exposent >= EXP_MAX + 1)
		return (str);
	handle_precision(&str, precision, flags);
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq -0x30(%rbp), %rsi
movsd %xmm0, (%rsi)
leaq -0x28(%rbp), %r15
pushq $0x8
popq %rdx
movq %r15, %rdi
callq 0x3440
movq (%r15), %rax
movq %rax, %rdi
movabsq $0xfffffffffffff, %rdx  # imm = 0xFFFFFFFFFFFFF
andq %rax, %rdx
shrq $0x34, %rax
movl $0x7ff, %ecx            # imm = 0x7FF
andl %ecx, %eax
shrq $0x3f, %rdi
movq %rdx, (%r15)
cmpl %ecx, %eax
jne 0x6ba2
movq %rdx, %rsi
callq 0x34d0
jmp 0x6be1
leal -0x3ff(%rax), %esi
pushq $0x79
popq %rcx
cmpl $0x3ff, %eax            # imm = 0x3FF
jb 0x6bbb
movl %ebx, %edi
callq 0x3160
jmp 0x6bc0
callq 0x3210
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x6bdf
leaq -0x20(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x3620
movq (%r15), %rax
jmp 0x6be1
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_bigint.c
// Function: ft_ldbltoa
char		*ft_ldbltoa(long double x, size_t precision, uint32_t flags)
{
	uint64_t	sign;
	int			exposent;
	uint64_t	mantissa;
	char		*str;
	uint64_t	test[2];

	ft_memcpy(&test, &x, sizeof(uint64_t) * 2);
	exposent = (test[1] & 32767) - EXP2_MAX;
	sign = !(!(test[1] & 32768));
	mantissa = test[0];
	if ((!(mantissa >> 63) && exposent != -EXP2_MAX))
	{
		mantissa = 1;
		exposent = EXP2_MAX + 1;
	}
	if (exposent >= EXP2_MAX + 1)
		str = infnan(sign, mantissa);
	else if (exposent >= 0)
		str = exp_pos(flags, exposent, mantissa, LDBL_TAB);
	else
		str = exp_neg(sign, exposent, mantissa, LDBL_TAB);
	if (!str || exposent >= EXP2_MAX + 1)
		return (str);
	handle_precision(&str, precision, flags);
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
fldt 0x10(%rbp)
fstpt -0x30(%rbp)
leaq -0x40(%rbp), %r15
leaq -0x30(%rbp), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x3440
movl 0x8(%r15), %edi
movl %edi, %eax
andl $0x7fff, %eax           # imm = 0x7FFF
leal -0x3fff(%rax), %ecx
shrl $0xf, %edi
andl $0x1, %edi
movq (%r15), %r8
testq %r8, %r8
setns %dl
testl %eax, %eax
setne %al
testb %al, %dl
movl $0x4000, %esi           # imm = 0x4000
cmovel %ecx, %esi
pushq $0x1
popq %rdx
cmoveq %r8, %rdx
cmpl $0x4000, %esi           # imm = 0x4000
jl 0x6c5f
movq %rdx, %rsi
callq 0x34d0
jmp 0x6c9c
testl %esi, %esi
js 0x6c71
movl %ebx, %edi
movl $0x73a, %ecx            # imm = 0x73A
callq 0x3160
jmp 0x6c7b
movl $0x73a, %ecx            # imm = 0x73A
callq 0x3210
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x6c9a
leaq -0x20(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x3620
movq (%r15), %rax
jmp 0x6c9c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_unit.c
// Function: create_unit_neg_addentum
int				*create_unit_neg_addentum(int dbl_tab)
{
	int	*unit;
	int	j;
	int	i;

	i = dbl_tab;
	if (!(unit = (int*)malloc(sizeof(int) * (i + 2))))
		return (0);
	j = 0;
	while (j < i + 2)
		unit[j++] = 0;
	unit[2] = 500000000;
	unit[0] = 2;
	return (unit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movslq %edi, %rax
leaq 0x8(,%rax,4), %rdi
callq 0x3690
testq %rax, %rax
je 0x6cea
addl $0x2, %ebx
xorl %ecx, %ecx
testl %ebx, %ebx
cmovlel %ecx, %ebx
cmpq %rcx, %rbx
je 0x6cdd
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x6ccf
movl $0x1dcd6500, 0x8(%rax)  # imm = 0x1DCD6500
movl $0x2, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_unit.c
// Function: create_unit_neg
int				*create_unit_neg(int exposent, int dbl_tab)
{
	int	*unit;
	int	j;

	if (!(unit = create_unit_neg_addentum(dbl_tab)))
		return (0);
	if (dbl_tab == DBL_TAB)
		exposent -= MIN_EXP;
	else if (dbl_tab == LDBL_TAB)
		exposent -= MIN2_EXP;
	while (exposent++)
	{
		j = 2;
		while (j <= unit[0])
		{
			if (unit[j] & 1)
				unit[j + 1] += 1000000000;
			unit[j] = unit[j] / 2;
			if (++j == unit[0] + 1 && unit[j] == 1000000000 && unit[0]++)
				unit[j + 1] /= 2;
		}
	}
	return (unit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movl %edi, %ebx
movl %esi, %edi
callq 0x3230
movq %rax, %rcx
testq %rax, %rax
je 0x6d87
cmpl $0x73a, %r14d           # imm = 0x73A
je 0x6d20
cmpl $0x79, %r14d
jne 0x6d23
addl $-0x33, %ebx
jmp 0x6d23
addl $-0x3e, %ebx
pushq $0x2
popq %rsi
pushq $0x2
popq %rdi
testl %ebx, %ebx
je 0x6d87
incl %ebx
movl (%rcx), %r8d
movq %rsi, %r9
movl %r8d, %r10d
movslq %r8d, %r11
cmpq %r11, %r9
jg 0x6d82
movl (%rcx,%r9,4), %eax
testb $0x1, %al
je 0x6d51
addl $0x3b9aca00, 0x4(%rcx,%r9,4) # imm = 0x3B9ACA00
cltd
idivl %edi
movl %eax, (%rcx,%r9,4)
cmpq %r9, %r10
jne 0x6d68
cmpl $0x3b9aca00, 0x4(%rcx,%r9,4) # imm = 0x3B9ACA00
je 0x6d6d
incq %r9
jmp 0x6d3b
incl %r8d
movl 0x8(%rcx,%r9,4), %eax
cltd
idivl %edi
movl %eax, 0x8(%rcx,%r9,4)
incq %r9
jmp 0x6d35
movl %r8d, (%rcx)
jmp 0x6d29
movq %rcx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_unit.c
// Function: create_unit_pos_addentum
int				*create_unit_pos_addentum(void)
{
	int	*unit;
	int	j;

	if (!(unit = (int*)malloc(sizeof(int) * (DBL_TAB + 2))))
		return (0);
	j = 0;
	while (j < DBL_TAB + 2)
		unit[j++] = 0;
	unit[0] = 5;
	unit[1] = DBL_TAB;
	unit[DBL_TAB] = 500000000;
	unit[DBL_TAB - 1] = 618164062;
	unit[DBL_TAB - 2] = 84726333;
	unit[DBL_TAB - 3] = 925031308;
	unit[DBL_TAB - 4] = 222044604;
	return (unit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1ec, %edi            # imm = 0x1EC
callq 0x3690
testq %rax, %rax
je 0x6dec
xorl %ecx, %ecx
cmpq $0x7b, %rcx
je 0x6db3
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x6da4
movabsq $0x7900000005, %rcx     # imm = 0x7900000005
movq %rcx, (%rax)
movl $0x1dcd6500, 0x1e4(%rax) # imm = 0x1DCD6500
movabsq $0x24d86f5e050cd23d, %rcx # imm = 0x24D86F5E050CD23D
movq %rcx, 0x1dc(%rax)
movabsq $0x3722db8c0d3c21bc, %rcx # imm = 0x3722DB8C0D3C21BC
movq %rcx, 0x1d4(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_create_unit.c
// Function: create_lunit_pos_addentum
int				*create_lunit_pos_addentum(void)
{
	int	*unit;
	int	j;

	if (!(unit = (int*)malloc(sizeof(int) * (LDBL_TAB + 2))))
		return (0);
	j = 0;
	while (j < LDBL_TAB + 2)
		unit[j++] = 0;
	unit[0] = 6;
	unit[1] = LDBL_TAB;
	unit[LDBL_TAB] = 125000000;
	unit[LDBL_TAB - 1] = 171142578;
	unit[LDBL_TAB - 2] = 280086994;
	unit[LDBL_TAB - 3] = 443400745;
	unit[LDBL_TAB - 4] = 217248550;
	unit[LDBL_TAB - 5] = 108420;
	return (unit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1cf0, %edi           # imm = 0x1CF0
callq 0x3690
testq %rax, %rax
je 0x6e55
xorl %ecx, %ecx
cmpq $0x73c, %rcx            # imm = 0x73C
je 0x6e15
andl $0x0, (%rax,%rcx,4)
incq %rcx
jmp 0x6e03
movabsq $0x73a00000006, %rcx    # imm = 0x73A00000006
movq %rcx, (%rax)
movabsq $0x77359400a336db2, %rcx # imm = 0x77359400A336DB2
movq %rcx, 0x1ce4(%rax)
movabsq $0x10b1c9d21a6dc229, %rcx # imm = 0x10B1C9D21A6DC229
movq %rcx, 0x1cdc(%rax)
movabsq $0xcf2f3260001a784, %rcx # imm = 0xCF2F3260001A784
movq %rcx, 0x1cd4(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6e6b
callq 0x3680
jmp 0x6e70
callq 0x3120
testq %rax, %rax
je 0x6ef4
cmpl $0x0, (%rax)
je 0x6ef4
pushq $0x1
popq %rcx
subl $0x1, %ebx
jb 0x6ef6
movb $0x1, %dil
xorl %edx, %edx
xorl %esi, %esi
xorl %r8d, %r8d
movslq (%rax), %r9
cmpl %r9d, %esi
jge 0x6ed8
movl 0x4(%rax), %edi
addl %edx, %edi
movslq %edi, %rdi
movl (%rax,%rdi,4), %r9d
leal (%r8,%r9,2), %r8d
movl %r8d, (%rax,%rdi,4)
movl 0x4(%rax), %edi
addl %edx, %edi
movslq %edi, %r9
movl (%rax,%r9,4), %r10d
xorl %r8d, %r8d
cmpl $0x3b9aca00, %r10d      # imm = 0x3B9ACA00
setl %dil
jl 0x6ed2
addl $0xc4653600, %r10d      # imm = 0xC4653600
movl %r10d, (%rax,%r9,4)
movl %ecx, %r8d
decl %edx
incl %esi
jmp 0x6e8c
testb $0x1, %dil
jne 0x6e7d
movslq 0x4(%rax), %rdx
leal 0x1(%r9), %esi
movl %esi, (%rax)
subq %r9, %rdx
movl $0x1, (%rax,%rdx,4)
jmp 0x6e7d
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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
movl (%rax), %ecx
xorl %edx, %edx
cmpl $0x2, %ecx
jl 0x6f38
movl (%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
cmovll %edi, %edx
setge %sil
movl %edx, (%rax,%rcx,4)
decq %rcx
movl %esi, %edx
jmp 0x6f0b
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x6f4b
movl %ecx, (%rdx)
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, %ecx
jl 0x6f77
movl (%rdx,%rcx,4), %esi
addl (%rax,%rcx,4), %esi
movl %esi, (%rdx,%rcx,4)
cmpl $0x3b9aca00, %esi       # imm = 0x3B9ACA00
jl 0x6f72
addl $0xc4653600, %esi       # imm = 0xC4653600
movl %esi, (%rdx,%rcx,4)
incl -0x4(%rdx,%rcx,4)
decq %rcx
jmp 0x6f4f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
movl $0x1, %edx
xorl %esi, %esi
xorl %edi, %edi
movslq (%rax), %r8
cmpl %r8d, %esi
jge 0x6fd2
movslq 0x4(%rax), %r8
addq %rcx, %r8
movl (%rax,%r8,4), %r9d
leal (%rdi,%r9,2), %edi
movl %edi, (%rax,%r8,4)
movslq 0x4(%rax), %r8
addq %rcx, %r8
movl (%rax,%r8,4), %r9d
xorl %edi, %edi
cmpl $0x3b9aca00, %r9d       # imm = 0x3B9ACA00
jl 0x6fcb
addl $0xc4653600, %r9d       # imm = 0xC4653600
movl %r9d, (%rax,%r8,4)
movl %edx, %edi
incl %esi
decq %rcx
jmp 0x6f8d
testl %edi, %edi
je 0x6fe6
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_O2/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
xorl %edx, %edx
cmpl %ecx, %edx
jg 0x7048
movslq 0x4(%rax), %r8
movslq %edx, %r9
subq %r9, %r8
movl (%rax,%r8,4), %r10d
movq (%rsi), %rdi
addl %r10d, (%rdi,%r8,4)
movslq 0x4(%rax), %r8
subq %r9, %r8
movl (%rdi,%r8,4), %r9d
cmpl $0x3b9aca00, %r9d       # imm = 0x3B9ACA00
jl 0x7044
addl $0xc4653600, %r9d       # imm = 0xC4653600
movl %r9d, (%rdi,%r8,4)
movl %edx, %r8d
notl %r8d
addl 0x4(%rax), %r8d
movslq %r8d, %r8
incl (%rdi,%r8,4)
cmpl %ecx, %edx
jne 0x7044
incl (%rax)
incl %edx
jmp 0x6ff5
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3690
movq %rax, (%rbx)
testq %rax, %rax
je 0x70df
pushq $0x79
popq %rsi
movl %r12d, %edi
callq 0x33f0
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x70eb
xorl %eax, %eax
cmpq $0x7a, %rax
je 0x709c
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0x708d
pushq $0x1
popq %r12
movq %r12, %rax
shrq $0x34, %rax
jne 0x70c6
testq %r15, %r12
je 0x70b9
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3180
movq %r14, %rdi
callq 0x3600
addq %r12, %r12
jmp 0x70a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3180
movq (%r14), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x70e2
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3400
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1cec, %edi           # imm = 0x1CEC
callq 0x3690
movq %rax, (%rbx)
testq %rax, %rax
je 0x719b
movl %r12d, %edi
movl $0x73a, %esi            # imm = 0x73A
callq 0x33f0
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x71ad
xorl %eax, %eax
cmpq $0x73b, %rax            # imm = 0x73B
je 0x7152
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0x7141
pushq $0x1
popq %r12
movabsq $0x7ffffffffffffffe, %r13 # imm = 0x7FFFFFFFFFFFFFFE
cmpq %r13, %r12
ja 0x7182
testq %r15, %r12
je 0x7175
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3180
movq %r14, %rdi
callq 0x3600
addq %r12, %r12
jmp 0x7160
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3180
movq (%r14), %rax
movl (%rax), %eax
movq (%rbx), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
jmp 0x719e
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3400
// File: /workspace/github_c_makefile_star2_O2/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 0x3690
movq %rax, (%rbx)
testq %rax, %rax
je 0x729e
movl %r15d, %edi
movl $0x73a, %esi            # imm = 0x73A
callq 0x3450
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x72b0
xorl %eax, %eax
cmpq $0x73b, %rax            # imm = 0x73B
je 0x7222
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0x7211
movl %r15d, -0x2c(%rbp)
cmpl $0xffffc001, %r15d      # imm = 0xFFFFC001
jne 0x7237
movq %r14, %rdi
callq 0x31a0
pushq $0x1
popq %r13
movabsq $0x7ffffffffffffffe, %r15 # imm = 0x7FFFFFFFFFFFFFFE
cmpq %r15, %r13
ja 0x7267
testq %r12, %r13
je 0x725a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq %r14, %rdi
callq 0x31a0
addq %r13, %r13
jmp 0x7245
cmpl $0xffffc001, -0x2c(%rbp) # imm = 0xFFFFC001
je 0x727b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq (%rbx), %rcx
movslq (%rcx), %rdi
leal -0x1(%rdi), %edx
movq %rdi, %rsi
xorl %eax, %eax
subq $0x1, %rsi
jb 0x72a1
cmpl $0x0, (%rcx,%rdi,4)
jne 0x72a1
movl %edx, (%rcx)
decl %edx
movq %rsi, %rdi
jmp 0x7289
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3400
// File: /workspace/github_c_makefile_star2_O2/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 0x3690
movq %rax, (%rbx)
testq %rax, %rax
je 0x7393
pushq $0x79
popq %rsi
movl %r15d, %edi
callq 0x3450
movq %rax, (%r14)
movq (%rbx), %rdi
testq %rax, %rax
je 0x73a5
xorl %eax, %eax
cmpq $0x7a, %rax
je 0x7321
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0x7312
cmpl $0xfffffc01, %r15d      # imm = 0xFFFFFC01
jne 0x7332
movq %r14, %rdi
callq 0x31a0
pushq $0x1
popq %r13
movq %r13, %rax
shrq $0x34, %rax
jne 0x735c
testq %r12, %r13
je 0x734f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq %r14, %rdi
callq 0x31a0
addq %r13, %r13
jmp 0x7336
cmpl $0xfffffc01, %r15d      # imm = 0xFFFFFC01
je 0x7370
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3080
movq (%rbx), %rcx
movslq (%rcx), %rdi
leal -0x1(%rdi), %edx
movq %rdi, %rsi
xorl %eax, %eax
subq $0x1, %rsi
jb 0x7396
cmpl $0x0, (%rcx,%rdi,4)
jne 0x7396
movl %edx, (%rcx)
decl %edx
movq %rsi, %rdi
jmp 0x737e
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3400
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x7414
cmpl $0x3a, %eax
jne 0x7436
leaq 0xf8d(%rip), %rdi       # 0x839f
jmp 0x741b
leaq 0xf81(%rip), %rdi       # 0x839c
incq %rsi
callq 0x3530
movq %rax, %r14
movq (%rbx), %rdi
callq 0x3110
testq %r14, %r14
je 0x7436
movq %r14, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3140
movq %rax, %r13
movq (%rbx), %rdi
pushq $0x2e
popq %rsi
callq 0x35b0
movq %rax, %r15
leaq (%rax,%r14), %rsi
cmpq %r13, %rsi
ja 0x74bf
movq (%rbx), %rcx
addq %rsi, %rcx
movb $0x5, %dl
movq %rsi, %rax
addb %dl, (%rcx)
testq %rax, %rax
je 0x74b7
movq (%rbx), %rcx
movb (%rcx,%rax), %dl
cmpb $0x3a, %dl
jl 0x74b7
addb $-0xa, %dl
movb %dl, (%rcx,%rax)
movq (%rbx), %rcx
movzbl -0x1(%rcx,%rax), %edx
orl $0x2, %edx
cmpl $0x2e, %edx
jne 0x74aa
decq %rax
addq %rax, %rcx
decq %rcx
decq %rax
movb $0x1, %dl
jmp 0x747f
movq %rbx, %rdi
callq 0x36b0
testq %r14, %r14
setne %al
shrl $0x1a, %r12d
andl $0x1, %r12d
orb %al, %r12b
jne 0x74dd
movq (%rbx), %rax
addq %rax, %r15
decq %r15
jmp 0x74e5
testq %r14, %r14
jne 0x74e9
addq (%rbx), %r15
movb $0x0, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0xa, %r9d
testl %esi, %esi
je 0x754f
movl $0x5f5e100, %esi        # imm = 0x5F5E100
movabsq $0x9, %r10
movl %edi, %eax
cltd
idivl %r9d
testl %edi, %edi
je 0x7535
testl %edx, %edx
jne 0x7535
movl %eax, %r8d
movl %esi, %eax
cltd
idivl %r9d
decq %r10
movl %r8d, %edi
movl %eax, %esi
jmp 0x7514
testl %edi, %edi
jne 0x755e
xorl %edi, %edi
cmpq $0x9, %r10
movabsq $0x6, %r10
cmovneq %rdi, %r10
jmp 0x755e
movl $0x5f5e100, %esi        # imm = 0x5F5E100
movabsq $0x9, %r10
pushq %rbp
movq %rsp, %rbp
subq $0x1, %r10
jb 0x7587
movl %edi, %eax
cltd
idivl %esi
addb $0x30, %al
movq (%rcx), %rdi
leaq 0x1(%rdi), %r8
movq %r8, (%rcx)
movb %al, (%rdi)
movl %edx, %edi
movl %esi, %eax
cltd
idivl %r9d
movl %eax, %esi
jmp 0x7562
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movl %ecx, %r15d
movq %rdx, %r8
movq (%rdi), %r11
movslq (%rsi), %rcx
movl (%r11,%rcx,4), %r10d
movl %r15d, %ebx
subl (%r11), %ebx
incl %ebx
movl $0x9, %r14d
movl $0x5f5e100, %r9d        # imm = 0x5F5E100
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0xa, %r12d
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
cmpl %ebx, %ecx
jne 0x75ec
cmpl %r10d, %r9d
jle 0x75ec
subl $0x1, %r14d
jb 0x75e9
movl %r9d, %eax
cltd
idivl %r12d
movl %eax, %r9d
jmp 0x75ce
movl %r13d, %r14d
movl %r15d, -0x30(%rbp)
movl %r15d, %esi
subl 0x4(%r11), %esi
movl $0x6, %r15d
movl %r15d, %eax
subl %r14d, %eax
movl %eax, -0x2c(%rbp)
movl %r15d, %edi
addl $-0x1, %r15d
setb %bl
movl %r10d, %eax
cltd
movl %r12d, %r13d
idivl %r12d
cmpl %esi, %ecx
jne 0x7651
testb %bl, %bl
je 0x7651
testl %edx, %edx
jne 0x7651
addl $0x9, %r10d
cmpl $0x13, %r10d
jb 0x764e
movl %eax, %r11d
subl $0x1, %r14d
jb 0x7656
movl %r9d, %eax
cltd
movl %r13d, %r12d
idivl %r13d
movl %r15d, %edi
movl %r11d, %r10d
movl %eax, %r9d
jmp 0x7609
xorl %r10d, %r10d
movl %edi, %r15d
jmp 0x7663
movl -0x2c(%rbp), %r15d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r11d, %r10d
incl %r15d
movl %r14d, %ecx
movl -0x30(%rbp), %ebx
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
subl $0x1, %ecx
jb 0x76c2
movl %r10d, %eax
cltd
idivl %r9d
addb $0x30, %al
movq (%r8), %r10
leaq 0x1(%r10), %r11
movq %r11, (%r8)
movb %al, (%r10)
movq (%rdi), %rax
movl %ebx, %r11d
subl 0x4(%rax), %r11d
movl %edx, %r10d
cmpl %r11d, (%rsi)
jne 0x76b3
cmpl %r14d, %r15d
jne 0x76b3
movq (%r8), %rax
leaq 0x1(%rax), %rdx
movq %rdx, (%r8)
movb $0x2e, (%rax)
movl %r9d, %eax
cltd
idivl %r13d
movl %ecx, %r14d
movl %eax, %r9d
jmp 0x7674
incl (%rsi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_putnbr.c
// Function: ft_putnbr_pos_addentum2
void		ft_putnbr_pos_addentum2(int **stack, int *i, char **tmp, int dbl_t)
{
	int				len;
	int				buf;
	char			c;
	int				dot;
	int				n;

	initialize_addentum2(&buf, &len, &dot);
	n = (*stack)[*i];
	while (*i == dbl_t - (*stack)[0] + 1 && buf > n && len--)
		buf /= 10;
	while (*i == dbl_t - (*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_t - (*stack)[1] && len == dot)
			((*tmp)++)[0] = '.';
		else if (*i < dbl_t - (*stack)[1] && (len == 6 || len == 3 || len == 0))
			((*tmp)++)[0] = ',';
		n %= buf;
		buf /= 10;
	}
	(*i)++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r8
movq %rdi, -0x38(%rbp)
movq (%rdi), %r11
movslq (%rsi), %r12
movl (%r11,%r12,4), %r10d
movl %ecx, -0x2c(%rbp)
subl (%r11), %ecx
incl %ecx
movl $0x5f5e100, %r9d        # imm = 0x5F5E100
movl $0x9, %r14d
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl $0xa, %edi
cmpl %ecx, %r12d
jne 0x7729
cmpl %r10d, %r9d
jle 0x7729
subl $0x1, %r14d
jb 0x7726
movl %r9d, %eax
cltd
idivl %edi
movl %eax, %r9d
jmp 0x770b
movl %ebx, %r14d
movl -0x2c(%rbp), %ecx
subl 0x4(%r11), %ecx
movl $0x6, %r13d
movl %r13d, %eax
subl %r14d, %eax
movl %eax, -0x30(%rbp)
movl %r13d, %r15d
addl $-0x1, %r15d
setb %bl
movl %r10d, %eax
cltd
idivl %edi
cmpl %ecx, %r12d
jne 0x7792
testb %bl, %bl
je 0x7792
testl %edx, %edx
jne 0x7792
addl $0x9, %r10d
cmpl $0x13, %r10d
jb 0x7780
movl %eax, %r11d
subl $0x1, %r14d
jb 0x7785
movl %r9d, %eax
cltd
idivl %edi
movl %r15d, %r13d
movl %r11d, %r10d
movl %eax, %r9d
jmp 0x7742
xorl %r10d, %r10d
jmp 0x7792
movl -0x30(%rbp), %r13d
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r11d, %r10d
incl %r13d
movl $0x92, %r11d
movl -0x2c(%rbp), %r12d
movl %r14d, %ecx
subl $0x1, %r14d
jb 0x7806
movl %r10d, %eax
cltd
idivl %r9d
addb $0x30, %al
movq (%r8), %r10
leaq 0x1(%r10), %rbx
movq %rbx, (%r8)
movb %al, (%r10)
movl (%rsi), %eax
movq -0x38(%rbp), %r10
movq (%r10), %r10
movl %r12d, %r15d
subl 0x4(%r10), %r15d
movl %edx, %r10d
cmpl %r15d, %eax
jne 0x77dd
movb $0x2e, %dl
cmpl %ecx, %r13d
je 0x77ef
cmpl %r15d, %eax
jge 0x77fb
cmpl $0x7, %ecx
ja 0x77fb
movb $0x2c, %dl
btl %ecx, %r11d
jae 0x77fb
movq (%r8), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r8)
movb %dl, (%rax)
movl %r9d, %eax
cltd
idivl %edi
movl %eax, %r9d
jmp 0x779f
incl (%rsi)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %eax, %eax
cmpl $0x73a, %edx            # imm = 0x73A
sete %al
orl $0x6, %eax
movq (%rdi), %rdx
movl %eax, 0x4(%rdx)
movl (%rdx), %edi
movl %ebx, %esi
subl %edi, %esi
leal 0x1(%rsi), %eax
movl %eax, -0x24(%rbp)
movslq %esi, %r8
cmpl $0x0, (%rdx,%r8,4)
je 0x7861
incl %edi
movl %edi, (%rdx)
movl %esi, -0x24(%rbp)
movl %esi, %eax
leaq -0x24(%rbp), %r15
leaq -0x30(%rbp), %r12
btl $0x1b, %ecx
jb 0x7888
cmpl %ebx, %eax
jg 0x78a1
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x34f0
movl -0x24(%rbp), %eax
jmp 0x786f
cmpl %ebx, %eax
jg 0x78a1
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movl %ebx, %ecx
callq 0x3540
movl -0x24(%rbp), %eax
jmp 0x7888
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_O2/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 %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x23a74(%rip), %r14     # 0x29340
cmpq $0x1b, %rbx
je 0x58ee
movb (%rbx,%r14), %al
testb %al, %al
je 0x58e9
movzbl %al, %esi
movl %ebx, %edi
callq 0x651f
movb $0x0, (%rbx,%r14)
incq %rbx
jmp 0x58cc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andl $0x0, 0x3(%rsp)
movl 0x22dea(%rip), %eax     # 0x2935c
leal 0x1(%rax), %ecx
cmpl $0xff, %eax
pushq $0x1
popq %rax
cmovll %ecx, %eax
movl %eax, 0x22dd6(%rip)     # 0x2935c
movb %al, 0x7(%rsp)
callq 0xe749
movw %ax, 0x8(%rsp)
testq %rbx, %rbx
je 0x65ab
leaq 0x6(%rsp), %rdi
movq %r14, %rsi
callq *%rbx
addl $-0x6, %eax
movzwl %ax, %edi
jmp 0x65ad
xorl %edi, %edi
callq 0xe749
movw %ax, 0xa(%rsp)
movzwl %ax, %edi
callq 0xe73e
addl $0xb, %eax
movzwl %ax, %edi
callq 0xe749
movw %ax, 0x1(%rsp)
movzwl %ax, %edi
callq 0xe73e
movzwl %ax, %r14d
incq %r14
movq %r14, %rdi
callq 0x5360
movq %rax, %rbx
testq %rax, %rax
je 0x65fe
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x52f0
jmp 0x6657
movq 0x229b3(%rip), %rax     # 0x28fb8
movq (%rax), %r14
callq 0xe343
leaq 0x15a3a(%rip), %rsi     # 0x1c04e
leaq 0x15a4b(%rip), %rcx     # 0x1c066
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
leaq 0x23679(%rip), %rax     # 0x29ca8
movq (%rax), %r14
testq %r14, %r14
je 0x6657
callq 0xe343
leaq 0x15a0b(%rip), %rsi     # 0x1c04e
leaq 0x15a1c(%rip), %rcx     # 0x1c066
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_O2/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)
pushq $0x1
popq %rdi
callq 0xe749
movw %ax, 0x7(%rbx)
movb $-0x1, 0x9(%rbx)
movw $0xa, %ax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/Carton32[P]quectel-CM/QmiWwanCM.c
// Function: CtlGetClientIdReq
static USHORT CtlGetClientIdReq(PQMICTL_MSG QCTLMsg, void *arg) {
   QCTLMsg->GetClientIdReq.TLVType       = QCTLV_TYPE_REQUIRED_PARAMETER;
   QCTLMsg->GetClientIdReq.TLVLength     = cpu_to_le16(0x0001);
   QCTLMsg->GetClientIdReq.QMIType     = ((UCHAR *)arg)[0];
   return sizeof(QMICTL_GET_CLIENT_ID_REQ_MSG);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x6(%rdi)
pushq $0x1
popq %rdi
callq 0xe749
movw %ax, 0x7(%r14)
movb (%rbx), %al
movb %al, 0x9(%r14)
movw $0xa, %ax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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)
pushq $0x2
popq %rdi
callq 0xe749
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
// File: /workspace/github_c_makefile_star2_O2/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 0x22c1f(%rip), %r14     # 0x29360
cmpq $0x6c, %rbx
je 0x675f
movl (%rbx,%r14), %edi
testl %edi, %edi
je 0x6759
callq 0x5230
andl $0x0, (%rbx,%r14)
addq $0x4, %rbx
jmp 0x6741
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x22bdd(%rip), %rcx     # 0x29360
movl (%rcx,%rax,4), %ebp
testb %bpl, %bpl
cmovnel %ebp, %eax
movb %al, 0x5(%rdi)
testl %ebp, %ebp
jle 0x685c
movzwl 0x1(%rbx), %edi
callq 0xe73e
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 0x68c2
movq 0x227e7(%rip), %rax     # 0x28fb8
movq (%rax), %r15
callq 0xe343
movq %rax, %r12
callq 0x5070
movq %rax, %r14
movl (%rax), %ebp
movl %ebp, %edi
callq 0x5540
movq %rax, (%rsp)
leaq 0x158c6(%rip), %rsi     # 0x1c0be
leaq 0x15b7a(%rip), %rcx     # 0x1c379
movq %r15, %rdi
movq %r12, %rdx
movl %ebx, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x52c0
leaq 0x2348f(%rip), %rax     # 0x29ca8
movq (%rax), %r15
testq %r15, %r15
je 0x6858
callq 0xe343
movq %rax, %r12
movl (%r14), %ebp
movl %ebp, %edi
callq 0x5540
movq %rax, (%rsp)
leaq 0x15880(%rip), %rsi     # 0x1c0be
leaq 0x15b34(%rip), %rcx     # 0x1c379
movq %r15, %rdi
movq %r12, %rdx
movl %ebx, %r8d
movl %ebp, %r9d
xorl %eax, %eax
callq 0x52c0
movl %ebx, %ebp
jmp 0x68c2
movq 0x22755(%rip), %rax     # 0x28fb8
movq (%rax), %r14
callq 0xe343
movzbl 0x4(%rbx), %r8d
leaq 0x15add(%rip), %rsi     # 0x1c354
leaq 0x15afb(%rip), %rcx     # 0x1c379
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x52c0
leaq 0x23416(%rip), %rax     # 0x29ca8
movq (%rax), %r14
pushq $-0x13
popq %rbp
testq %r14, %r14
je 0x68c2
callq 0xe343
movzbl 0x4(%rbx), %r8d
leaq 0x15aa6(%rip), %rsi     # 0x1c354
leaq 0x15ac4(%rip), %rcx     # 0x1c379
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_O2/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:
cmpl $0xe, %edi
jne 0x7d02
xorl %edi, %edi
jmp 0x81c0
pushq %rbx
andl $0x0, 0x216ca(%rip)     # 0x293d4
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0x81c0
movl %ebx, %edi
popq %rbx
jmp 0x81d8
// File: /workspace/github_c_makefile_star2_O2/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, 0x20080(%rip)     # 0x292f4
jne 0x9277
retq
movl %edi, 0x20077(%rip)     # 0x292f4
testb $0x10, %dil
jne 0x9295
xorps %xmm0, %xmm0
movups %xmm0, 0x20279(%rip)    # 0x29506
andq $0x0, 0x20281(%rip)     # 0x29516
testb $0x40, %dil
jne 0x92cd
xorps %xmm0, %xmm0
movups %xmm0, 0x202b9(%rip)    # 0x2955e
movups %xmm0, 0x202a2(%rip)    # 0x2954e
movups %xmm0, 0x2028b(%rip)    # 0x2953e
movups %xmm0, 0x20274(%rip)    # 0x2952e
movups %xmm0, 0x2025d(%rip)    # 0x2951e
andq $0x0, 0x202a3(%rip)     # 0x2956c
testl %edi, %edi
je 0x92d9
leaq 0x2010c(%rip), %rdi     # 0x293e0
jmp 0x1aee7
leaq 0x20100(%rip), %rdi     # 0x293e0
jmp 0x1bc1d
// File: /workspace/github_c_makefile_star2_O2/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, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5140
testq %rax, %rax
je 0x9336
movq %rax, %r12
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x5320
testq %rax, %rax
je 0x9329
addq $0x13, %rax
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq *%r15
addl %eax, %ebp
jmp 0x9308
movq %r12, %rdi
callq 0x5240
jmp 0x93bb
movq 0x1fc7b(%rip), %rax     # 0x28fb8
movq (%rax), %r15
callq 0xe343
movq %rax, %r12
callq 0x5070
movq %rax, %r14
movl (%rax), %r13d
movl %r13d, %edi
callq 0x5540
leaq 0x13a36(%rip), %rsi     # 0x1cd98
xorl %ebp, %ebp
movq %r15, %rdi
movq %r12, %rdx
movq %rbx, %rcx
movl %r13d, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x52c0
leaq 0x20927(%rip), %rax     # 0x29ca8
movq (%rax), %r15
testq %r15, %r15
je 0x93bb
callq 0xe343
movq %rax, %r12
movl (%r14), %r14d
movl %r14d, %edi
callq 0x5540
leaq 0x139f5(%rip), %rsi     # 0x1cd98
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