LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_string.c
// Function: pf_putnull
static inline void	pf_putnull(t_printf *pf)
{
	pf->printed = 6;
	(pf->flag & F_DOT && pf->precision < 6) ? pf->printed = pf->precision : 0;
	pf->padding = pf->length - pf->printed;
	pf_padding(pf, 0);
	if (!(pf->flag & F_ZERO))
		pf_buffer_write(pf, "(null)", pf->printed);
	pf_padding(pf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x6, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x200000, %eax         # imm = 0x200000
cmpl $0x0, %eax
je 0x8f75
movq -0x8(%rbp), %rax
cmpl $0x6, 0x8(%rax)
jge 0x8f75
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x8f77
jmp 0x8f77
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
jne 0x8fc3
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rdx
leaq 0x338d(%rip), %rsi      # 0xc34b
callq 0x3500
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_string.c
// Function: pf_lenwchar
static inline void	pf_lenwchar(t_printf *pf, unsigned int wc,
								unsigned int wlen, unsigned int nb_bytes)
{
	char	tmp[4];

	if (nb_bytes <= wlen)
	{
		if (nb_bytes == 1)
			tmp[0] = wc;
		else
		{
			if (nb_bytes == 2)
				tmp[0] = ((wc & (0x1F << 6)) >> 6) | 0xC0;
			else
			{
				if (nb_bytes == 3)
					tmp[0] = ((wc >> 12) & 0xF) | 0xE0;
				else if (nb_bytes == 4)
				{
					tmp[0] = ((wc >> 18) & 7) | 0xF0;
					tmp[1] = ((wc >> 12) & 0x3F) | 0x80;
				}
				tmp[nb_bytes - 2] = ((wc >> 6) & 0x3F) | 0x80;
			}
			tmp[nb_bytes - 1] = (wc & 0x3F) | 0x80;
		}
		pf_buffer_write(pf, tmp, nb_bytes);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
ja 0x90b7
cmpl $0x1, -0x14(%rbp)
jne 0x9012
movl -0xc(%rbp), %eax
movb %al, -0x18(%rbp)
jmp 0x90a5
cmpl $0x2, -0x14(%rbp)
jne 0x902d
movl -0xc(%rbp), %eax
andl $0x7c0, %eax            # imm = 0x7C0
shrl $0x6, %eax
orl $0xc0, %eax
movb %al, -0x18(%rbp)
jmp 0x908c
cmpl $0x3, -0x14(%rbp)
jne 0x9046
movl -0xc(%rbp), %eax
shrl $0xc, %eax
andl $0xf, %eax
orl $0xe0, %eax
movb %al, -0x18(%rbp)
jmp 0x9070
cmpl $0x4, -0x14(%rbp)
jne 0x906e
movl -0xc(%rbp), %eax
shrl $0x12, %eax
andl $0x7, %eax
orl $0xf0, %eax
movb %al, -0x18(%rbp)
movl -0xc(%rbp), %eax
shrl $0xc, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, -0x17(%rbp)
jmp 0x9070
movl -0xc(%rbp), %eax
shrl $0x6, %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movl -0x14(%rbp), %eax
subl $0x2, %eax
movl %eax, %eax
movb %cl, -0x18(%rbp,%rax)
movl -0xc(%rbp), %eax
andl $0x3f, %eax
orl $0x80, %eax
movb %al, %cl
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movb %cl, -0x18(%rbp,%rax)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
movl -0x14(%rbp), %eax
movl %eax, %edx
callq 0x3500
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_string.c
// Function: pf_putwchar
void				pf_putwchar(t_printf *pf)
{
	unsigned	c;

	c = va_arg(pf->ap, unsigned);
	pf->printed = ft_wcharlen(c);
	pf->padding = pf->length - pf->printed;
	pf_padding(pf, 0);
	pf_lenwchar(pf, c, pf->printed, pf->printed);
	pf_padding(pf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x18(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x28, %eax
ja 0x90ff
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x20(%rbp)
jmp 0x9116
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x32f0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
callq 0x8fe0
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_string.c
// Function: pf_putstr
void				pf_putstr(t_printf *pf)
{
	char	*str;

	if (!(str = va_arg(pf->ap, char *)))
	{
		pf_putnull(pf);
		return ;
	}
	pf->printed = (int)(ft_strlen(str));
	if (pf->flag & F_DOT && pf->printed > pf->precision)
		pf->printed = pf->precision;
	pf->padding = pf->length - pf->printed;
	pf_padding(pf, 0);
	pf_buffer_write(pf, str, pf->printed);
	pf_padding(pf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x20(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x28, %eax
ja 0x91bf
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x28(%rbp)
jmp 0x91d6
movq -0x20(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x91f5
movq -0x8(%rbp), %rdi
callq 0x8f30
jmp 0x927c
movq -0x10(%rbp), %rdi
callq 0x3140
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x200000, %eax         # imm = 0x200000
cmpl $0x0, %eax
je 0x9239
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jle 0x9239
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x3500
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_string_2.c
// Function: pf_putchar
void				pf_putchar(t_printf *pf)
{
	unsigned	c;

	c = va_arg(pf->ap, unsigned);
	pf->printed = 1;
	pf->padding = pf->length - 1;
	(pf->flag & F_SHARP) ? pf_char_padding(pf, c) : pf_padding(pf, 0);
	pf_buffer_write(pf, &c, 1);
	pf_padding(pf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x68, %rcx
movq %rcx, -0x18(%rbp)
movl 0x68(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x28, %eax
ja 0x92cf
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x20(%rbp)
jmp 0x92e6
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x4000000, %eax        # imm = 0x4000000
cmpl $0x0, %eax
je 0x9330
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movsbl %al, %esi
callq 0x9370
jmp 0x933b
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
movq -0x8(%rbp), %rdi
leaq -0xc(%rbp), %rsi
movl $0x1, %edx
callq 0x3500
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_string_2.c
// Function: pf_char_padding
inline static int	pf_char_padding(t_printf *pf, char c)
{
	if (pf->padding > 0)
		if (!(pf->flag & F_MINUS))
			while (pf->padding--)
				pf_buffer_write(pf, &c, 1);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jle 0x93ce
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x400000, %eax         # imm = 0x400000
cmpl $0x0, %eax
jne 0x93cc
jmp 0x93a2
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %eax
movl %eax, %edx
addl $-0x1, %edx
movl %edx, 0x14(%rcx)
cmpl $0x0, %eax
je 0x93ca
movq -0x8(%rbp), %rdi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x3500
jmp 0x93a2
jmp 0x93cc
jmp 0x93ce
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_double.c
// Function: pf_putdouble
void				pf_putdouble(t_printf *pf)
{
	char	*str;

	pf_load_string(pf, &str);
	if (str && str[0] == '-' && minus_edge_case(pf, str))
		return ;
	(pf->flag & (F_NEGATIF | F_PLUS | F_SPACE)) ? --pf->length : 0;
	pf->padding = pf->length - pf->precision;
	!(pf->flag & F_ZERO) ? pf_padding(pf, 0) : 0;
	(pf->flag & (F_NEGATIF | F_PLUS | F_SPACE)) ? pf_sign(pf) : 0;
	((pf->flag & F_ZERO)) ? pf_padding(pf, 0) : 0;
	pf->padding = pf->precision - pf->printed;
	str ? pf_buffer_write(pf, str, pf->printed) : 0;
	pf->option_padding = 1;
	str ? pf_padding(pf, 0) : 0;
	pf->option_padding = 0;
	pf->padding = pf->length - pf->precision;
	pf_padding(pf, 1);
	if (str)
		free(str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9560
cmpq $0x0, -0x10(%rbp)
je 0x9423
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x9423
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x97b0
cmpl $0x0, %eax
je 0x9423
jmp 0x9558
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x82800000, %eax       # imm = 0x82800000
cmpl $0x0, %eax
je 0x9446
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x9448
jmp 0x9448
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
jne 0x947e
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
jmp 0x9480
jmp 0x9480
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x82800000, %eax       # imm = 0x82800000
cmpl $0x0, %eax
je 0x949f
movq -0x8(%rbp), %rdi
callq 0x32e0
jmp 0x94a1
jmp 0x94a1
movq -0x8(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x94c2
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
jmp 0x94c4
jmp 0x94c4
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x18(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x94f7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movslq 0x18(%rax), %rdx
callq 0x3500
jmp 0x94f9
jmp 0x94f9
movq -0x8(%rbp), %rax
movl $0x1, 0x1c(%rax)
cmpq $0x0, -0x10(%rbp)
je 0x9518
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
jmp 0x951a
jmp 0x951a
movq -0x8(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
cmpq $0x0, -0x10(%rbp)
je 0x9558
movq -0x10(%rbp), %rdi
callq 0x3110
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/pf_double.c
// Function: minus_edge_case
static inline int	minus_edge_case(t_printf *pf, char *str)
{
	if (str[1] != '0')
	{
		pf->flag &= ~(F_NEGATIF | F_PLUS | F_SPACE);
		return (0);
	}
	pf->padding = pf->length - pf->precision;
	pf->flag |= F_NEGATIF;
	!(pf->flag & F_ZERO) ? pf_padding(pf, 0) : 0;
	pf_sign(pf);
	((pf->flag & F_ZERO)) ? pf_padding(pf, 0) : 0;
	pf->padding = pf->precision - pf->printed;
	pf_buffer_write(pf, str + 1, pf->printed - 1);
	pf->option_padding = 1;
	pf_padding(pf, 0);
	pf->option_padding = 0;
	pf->padding = pf->length - pf->precision;
	pf_padding(pf, 1);
	free(str);
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
je 0x97ef
movq -0x10(%rbp), %rax
movl 0x90(%rax), %ecx
andl $0x7d7fffff, %ecx       # imm = 0x7D7FFFFF
movl %ecx, 0x90(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x98f0
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movl 0x90(%rax), %ecx
orl $0x80000000, %ecx       # imm = 0x80000000
movl %ecx, 0x90(%rax)
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
jne 0x983b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
jmp 0x983d
jmp 0x983d
movq -0x10(%rbp), %rdi
callq 0x32e0
movq -0x10(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x1000000, %eax        # imm = 0x1000000
cmpl $0x0, %eax
je 0x9867
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
jmp 0x9869
jmp 0x9869
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
subl 0x18(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
subl $0x1, %eax
movslq %eax, %rdx
callq 0x3500
movq -0x10(%rbp), %rax
movl $0x1, 0x1c(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3430
movq -0x10(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3430
movq -0x18(%rbp), %rdi
callq 0x3110
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/AugustinLopez[P]Fancy_Ft_Malloc/minilibft/printf/ftoa/f_bigint.c
// Function: infnan
char		*infnan(uint64_t sign, uint64_t mantissa)
{
	char		*str;

	if (mantissa >> 63 != 0)
		mantissa = 0;
	if (!(str = ft_strnew(4)))
		return (0);
	if (sign && !mantissa)
		ft_strcat(str, "-inf");
	else if (!mantissa)
		ft_strcat(str, "inf");
	else
		ft_strcat(str, "nan");
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
je 0x9926
movq $0x0, -0x18(%rbp)
movl $0x4, %edi
callq 0x3330
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x9944
movq $0x0, -0x8(%rbp)
jmp 0x9997
cmpq $0x0, -0x10(%rbp)
je 0x9964
cmpq $0x0, -0x18(%rbp)
jne 0x9964
movq -0x20(%rbp), %rdi
leaq 0x29f5(%rip), %rsi      # 0xc352
callq 0x3170
jmp 0x998f
cmpq $0x0, -0x18(%rbp)
jne 0x997d
movq -0x20(%rbp), %rdi
leaq 0x29dd(%rip), %rsi      # 0xc353
callq 0x3170
jmp 0x998d
movq -0x20(%rbp), %rdi
leaq 0x29cf(%rip), %rsi      # 0xc357
callq 0x3170
jmp 0x998f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x73a, -0x1c(%rbp)     # imm = 0x73A
jne 0x99e7
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3460
cmpl $0x0, %eax
jne 0x9a06
cmpl $0x79, -0x1c(%rbp)
jne 0x9a10
movl -0x10(%rbp), %edx
movq -0x18(%rbp), %rcx
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3290
cmpl $0x0, %eax
je 0x9a10
movq $0x0, -0x8(%rbp)
jmp 0x9a79
movq -0x38(%rbp), %rdi
callq 0x3110
movq -0x40(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
imull $0xc, %eax, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x3330
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x9a4d
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x30c0
movq %rax, -0x8(%rbp)
jmp 0x9a79
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x1c(%rbp), %edx
movl -0xc(%rbp), %ecx
leaq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3580
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x30c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
cmpl $0x73a, -0x24(%rbp)     # imm = 0x73A
jne 0x9ac8
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3490
cmpl $0x0, %eax
jne 0x9ae7
cmpl $0x79, -0x24(%rbp)
jne 0x9af4
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x33c0
cmpl $0x0, %eax
je 0x9af4
movq $0x0, -0x8(%rbp)
jmp 0x9bef
movq -0x40(%rbp), %rdi
callq 0x3110
movq -0x48(%rbp), %rax
movl (%rax), %eax
addl $0x1, %eax
imull $0x9, %eax, %eax
addl $0x3, %eax
movslq %eax, %rdi
callq 0x3330
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x9b34
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x30c0
movq %rax, -0x8(%rbp)
jmp 0x9bef
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x4c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x9b60
movq -0x30(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x4c(%rbp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
movq -0x30(%rbp), %rdi
movslq -0x4c(%rbp), %rax
addq %rax, %rdi
leaq 0x27e9(%rip), %rsi      # 0xc35b
callq 0x3170
movq -0x30(%rbp), %rax
movslq -0x4c(%rbp), %rcx
addq %rcx, %rax
addq $0x2, %rax
movq %rax, -0x38(%rbp)
movl $0x2, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq -0x48(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x9bbe
movq -0x48(%rbp), %rax
movl -0x4c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x4c(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edi
xorl %esi, %esi
leaq -0x38(%rbp), %rdx
callq 0x31e0
jmp 0x9b91
movq -0x48(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl $0x1, %esi
leaq -0x38(%rbp), %rdx
callq 0x31e0
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x30c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
movl $0x8, %edx
callq 0x3440
movq -0x38(%rbp), %rax
shlq %rax
shrq $0x35, %rax
subq $0x3ff, %rax            # imm = 0x3FF
movl %eax, -0x2c(%rbp)
movq -0x38(%rbp), %rax
shrq $0x3f, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
shlq $0xc, %rax
shrq $0xc, %rax
movq %rax, -0x38(%rbp)
cmpl $0x400, -0x2c(%rbp)     # imm = 0x400
jl 0x9c72
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x34d0
movq %rax, -0x40(%rbp)
jmp 0x9cad
cmpl $0x0, -0x2c(%rbp)
jl 0x9c92
movl -0x1c(%rbp), %edi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
movl $0x79, %ecx
callq 0x3160
movq %rax, -0x40(%rbp)
jmp 0x9cab
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x38(%rbp), %rdx
movl $0x79, %ecx
callq 0x3210
movq %rax, -0x40(%rbp)
jmp 0x9cad
cmpq $0x0, -0x40(%rbp)
je 0x9cbd
cmpl $0x400, -0x2c(%rbp)     # imm = 0x400
jl 0x9cc7
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9cdf
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x40(%rbp), %rdi
callq 0x3620
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
fldt 0x10(%rbp)
fstpt -0x20(%rbp)
movq %rdi, -0x28(%rbp)
movl %esi, -0x2c(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x3440
movq -0x58(%rbp), %rax
andq $0x7fff, %rax           # imm = 0x7FFF
subq $0x3fff, %rax           # imm = 0x3FFF
movl %eax, -0x3c(%rbp)
movq -0x58(%rbp), %rax
andq $0x8000, %rax           # imm = 0x8000
cmpq $0x0, %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x38(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
shrq $0x3f, %rax
cmpq $0x0, %rax
jne 0x9d78
cmpl $0xffffc001, -0x3c(%rbp) # imm = 0xFFFFC001
je 0x9d78
movq $0x1, -0x48(%rbp)
movl $0x4000, -0x3c(%rbp)    # imm = 0x4000
cmpl $0x4000, -0x3c(%rbp)    # imm = 0x4000
jl 0x9d94
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x34d0
movq %rax, -0x50(%rbp)
jmp 0x9dcf
cmpl $0x0, -0x3c(%rbp)
jl 0x9db4
movl -0x2c(%rbp), %edi
movl -0x3c(%rbp), %esi
movq -0x48(%rbp), %rdx
movl $0x73a, %ecx            # imm = 0x73A
callq 0x3160
movq %rax, -0x50(%rbp)
jmp 0x9dcd
movq -0x38(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x48(%rbp), %rdx
movl $0x73a, %ecx            # imm = 0x73A
callq 0x3210
movq %rax, -0x50(%rbp)
jmp 0x9dcf
cmpq $0x0, -0x50(%rbp)
je 0x9ddf
cmpl $0x4000, -0x3c(%rbp)    # imm = 0x4000
jl 0x9de9
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9e01
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %edx
leaq -0x50(%rbp), %rdi
callq 0x3620
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addl $0x2, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x3690
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9e47
movq $0x0, -0x8(%rbp)
jmp 0x9e93
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jge 0x9e76
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0x9e4e
movq -0x18(%rbp), %rax
movl $0x1dcd6500, 0x8(%rax)  # imm = 0x1DCD6500
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0x10(%rbp), %edi
callq 0x3230
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x9ecd
movq $0x0, -0x8(%rbp)
jmp 0x9fda
cmpl $0x79, -0x10(%rbp)
jne 0x9ede
movl -0xc(%rbp), %eax
subl $0x33, %eax
movl %eax, -0xc(%rbp)
jmp 0x9ef2
cmpl $0x73a, -0x10(%rbp)     # imm = 0x73A
jne 0x9ef0
movl -0xc(%rbp), %eax
subl $0x3e, %eax
movl %eax, -0xc(%rbp)
jmp 0x9ef2
jmp 0x9ef4
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0x9fd2
movl $0x2, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jg 0x9fcd
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9f4a
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x3b9aca00, %edx       # imm = 0x3B9ACA00
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %edx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x9fc8
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpl $0x3b9aca00, (%rax,%rcx,4) # imm = 0x3B9ACA00
jne 0x9fc8
movq -0x18(%rbp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
cmpl $0x0, %eax
je 0x9fc8
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl $0x2, %esi
cltd
idivl %esi
movl %eax, %edx
movq -0x28(%rbp), %rax
movl %edx, (%rax,%rcx,4)
jmp 0x9f0f
jmp 0x9ef4
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x1ec, %edi            # imm = 0x1EC
callq 0x3690
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xa019
movq $0x0, -0x8(%rbp)
jmp 0xa0a4
movl $0x0, -0x14(%rbp)
cmpl $0x7b, -0x14(%rbp)
jge 0xa041
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xa020
movq -0x10(%rbp), %rax
movl $0x5, (%rax)
movq -0x10(%rbp), %rax
movl $0x79, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x1dcd6500, 0x1e4(%rax) # imm = 0x1DCD6500
movq -0x10(%rbp), %rax
movl $0x24d86f5e, 0x1e0(%rax) # imm = 0x24D86F5E
movq -0x10(%rbp), %rax
movl $0x50cd23d, 0x1dc(%rax) # imm = 0x50CD23D
movq -0x10(%rbp), %rax
movl $0x3722db8c, 0x1d8(%rax) # imm = 0x3722DB8C
movq -0x10(%rbp), %rax
movl $0xd3c21bc, 0x1d4(%rax) # imm = 0xD3C21BC
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x1cf0, %edi           # imm = 0x1CF0
callq 0x3690
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0xa0d9
movq $0x0, -0x8(%rbp)
jmp 0xa175
movl $0x0, -0x14(%rbp)
cmpl $0x73c, -0x14(%rbp)     # imm = 0x73C
jge 0xa104
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x14(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xa0e0
movq -0x10(%rbp), %rax
movl $0x6, (%rax)
movq -0x10(%rbp), %rax
movl $0x73a, 0x4(%rax)       # imm = 0x73A
movq -0x10(%rbp), %rax
movl $0x7735940, 0x1ce8(%rax) # imm = 0x7735940
movq -0x10(%rbp), %rax
movl $0xa336db2, 0x1ce4(%rax) # imm = 0xA336DB2
movq -0x10(%rbp), %rax
movl $0x10b1c9d2, 0x1ce0(%rax) # imm = 0x10B1C9D2
movq -0x10(%rbp), %rax
movl $0x1a6dc229, 0x1cdc(%rax) # imm = 0x1A6DC229
movq -0x10(%rbp), %rax
movl $0xcf2f326, 0x1cd8(%rax) # imm = 0xCF2F326
movq -0x10(%rbp), %rax
movl $0x1a784, 0x1cd4(%rax)  # imm = 0x1A784
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0x79, -0x10(%rbp)
jne 0xa19f
callq 0x3680
movq %rax, -0x28(%rbp)
jmp 0xa1a8
callq 0x3120
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa1c0
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xa1cd
movq $0x0, -0x8(%rbp)
jmp 0xa2cc
jmp 0xa1cf
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
cmpl $0x0, %eax
je 0xa2c4
movl $0x0, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x1c(%rbp)
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0xa295
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
shll %edx
addl -0x20(%rbp), %edx
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpl $0x3b9aca00, (%rax,%rcx,4) # imm = 0x3B9ACA00
jl 0xa289
movl $0x1, -0x20(%rbp)
movb $0x1, %al
testb $0x1, %al
jne 0xa267
jmp 0xa289
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
subl $0x3b9aca00, %edx       # imm = 0x3B9ACA00
movl %edx, (%rax,%rcx,4)
jmp 0xa290
movl $0x0, -0x20(%rbp)
jmp 0xa1f1
cmpl $0x0, -0x20(%rbp)
je 0xa2bf
movq -0x18(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
movq -0x18(%rbp), %rsi
movl (%rsi), %edx
movl %edx, %edi
addl $0x1, %edi
movl %edi, (%rsi)
subl %edx, %ecx
movslq %ecx, %rcx
movl $0x1, (%rax,%rcx,4)
jmp 0xa1cf
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jle 0xa368
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
shll %edx
addl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
cmpl $0x3b9aca00, (%rax,%rcx,4) # imm = 0x3B9ACA00
jl 0xa356
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
subl $0x3b9aca00, %edx       # imm = 0x3B9ACA00
movl %edx, (%rax,%rcx,4)
jmp 0xa35d
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa2fb
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jne 0xa3a6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
jmp 0xa3a8
cmpl $0x1, -0x14(%rbp)
jle 0xa41c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x3b9aca00, (%rax,%rcx,4) # imm = 0x3B9ACA00
jl 0xa411
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %edx
subl $0x3b9aca00, %edx       # imm = 0x3B9ACA00
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xa3a8
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0xa4e2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
shll %edx
addl -0x10(%rbp), %edx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
cmpl $0x3b9aca00, (%rax,%rcx,4) # imm = 0x3B9ACA00
jl 0xa4cd
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
subl $0x3b9aca00, %edx       # imm = 0x3B9ACA00
movl %edx, (%rax,%rcx,4)
jmp 0xa4d4
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa436
cmpl $0x0, -0x10(%rbp)
je 0xa51a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
movq -0x8(%rbp), %rdx
movq (%rdx), %rdx
subl (%rdx), %ecx
movslq %ecx, %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0xa613
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
cmpl $0x3b9aca00, (%rax,%rcx,4) # imm = 0x3B9ACA00
jl 0xa605
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0x18(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
subl $0x3b9aca00, %edx       # imm = 0x3B9ACA00
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
movl 0x4(%rcx), %ecx
subl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xa603
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0xa605
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xa53f
xorl %eax, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1e8, %edi            # imm = 0x1E8
callq 0x3690
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa65a
movl $0x1, -0x4(%rbp)
jmp 0xa727
movl -0x1c(%rbp), %edi
movl $0x79, %esi
callq 0x33f0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa68d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3400
movl %eax, -0x4(%rbp)
jmp 0xa727
movl $0x0, -0x34(%rbp)
cmpl $0x7a, -0x34(%rbp)
jge 0xa6b8
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xa694
movq $0x1, -0x30(%rbp)
movabsq $0x10000000000000, %rax # imm = 0x10000000000000
cmpq %rax, -0x30(%rbp)
jae 0xa701
movq -0x30(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0xa6eb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3180
movq -0x10(%rbp), %rdi
callq 0x3600
movq -0x30(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0xa6c0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3180
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1cec, %edi           # imm = 0x1CEC
callq 0x3690
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa76a
movl $0x1, -0x4(%rbp)
jmp 0xa83a
movl -0x1c(%rbp), %edi
movl $0x73a, %esi            # imm = 0x73A
callq 0x33f0
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa79d
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3400
movl %eax, -0x4(%rbp)
jmp 0xa83a
movl $0x0, -0x34(%rbp)
cmpl $0x73b, -0x34(%rbp)     # imm = 0x73B
jge 0xa7cb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xa7a4
movq $0x1, -0x30(%rbp)
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x30(%rbp)
jae 0xa814
movq -0x30(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0xa7fe
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3180
movq -0x10(%rbp), %rdi
callq 0x3600
movq -0x30(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0xa7d3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3180
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x1cec, %edi           # imm = 0x1CEC
callq 0x3690
movq -0x18(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa88a
movl $0x1, -0x4(%rbp)
jmp 0xa9ac
movl -0x1c(%rbp), %edi
movl $0x73a, %esi            # imm = 0x73A
callq 0x3450
movq -0x10(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xa8bd
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x3400
movl %eax, -0x4(%rbp)
jmp 0xa9ac
movl $0x0, -0x34(%rbp)
cmpl $0x73b, -0x34(%rbp)     # imm = 0x73B
jge 0xa8eb
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl $0x0, (%rax,%rcx,4)
jmp 0xa8c4
movq $0x1, -0x30(%rbp)
cmpl $0xffffc001, -0x1c(%rbp) # imm = 0xFFFFC001
jne 0xa905
movq -0x10(%rbp), %rdi
callq 0x31a0
jmp 0xa907
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cmpq %rax, -0x30(%rbp)
jae 0xa948
movq -0x30(%rbp), %rax
andq -0x28(%rbp), %rax
cmpq $0x0, %rax
je 0xa932
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3080
movq -0x10(%rbp), %rdi
callq 0x31a0
movq -0x30(%rbp), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0xa907
cmpl $0xffffc001, -0x1c(%rbp) # imm = 0xFFFFC001
je 0xa95e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3080
jmp 0xa960
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq (%rax), %rdx
xorl %eax, %eax
cmpl $0x0, (%rcx,%rdx,4)
movb %al, -0x35(%rbp)
jne 0xa98c
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
setne %al
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0xa995
jmp 0xa9a5
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0xa960
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)