LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_util.c
// Function: ft_strjoin_null
char		*ft_strjoin_null(char const *s1, char const *s2, int null, int id)
{
	char	*s_new;
	size_t	len_s1;
	size_t	len_s2;

	if (!s1 && !s2)
		return (NULL);
	if (id == 3)
	{
		len_s2 = ft_strlen_null(s2, 1);
		len_s1 = (null - 1) > 0 ? ft_strlen_null(s1, null - 1)
			: ft_strlen(s1);
	}
	else
	{
		len_s1 = (id == 1 ? ft_strlen_null(s1, null) : ft_strlen(s1));
		len_s2 = (id == 2 ? ft_strlen_null(s2, null) : ft_strlen(s2));
	}
	if (!(s_new = (char *)malloc(sizeof(char) * (len_s1 + len_s2 + 1))))
		return (NULL);
	ft_memcpy(s_new, s1, len_s1);
	ft_memcpy(s_new + len_s1, s2, len_s2);
	s_new[len_s1 + len_s2] = '\0';
	return (s_new);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x4c01
cmpq $0x0, -0x18(%rbp)
jne 0x4c01
movq $0x0, -0x8(%rbp)
jmp 0x4d11
cmpl $0x3, -0x20(%rbp)
jne 0x4c50
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x4b10
movq %rax, -0x38(%rbp)
movl -0x1c(%rbp), %eax
subl $0x1, %eax
cmpl $0x0, %eax
jle 0x4c39
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
subl $0x1, %esi
callq 0x4b10
movq %rax, -0x40(%rbp)
jmp 0x4c46
movq -0x10(%rbp), %rdi
callq 0x9320
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
jmp 0x4caa
cmpl $0x1, -0x20(%rbp)
jne 0x4c68
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x4b10
movq %rax, -0x48(%rbp)
jmp 0x4c75
movq -0x10(%rbp), %rdi
callq 0x9320
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpl $0x2, -0x20(%rbp)
jne 0x4c95
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x4b10
movq %rax, -0x50(%rbp)
jmp 0x4ca2
movq -0x18(%rbp), %rdi
callq 0x9320
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
addq -0x38(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x4cd3
movq $0x0, -0x8(%rbp)
jmp 0x4d11
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x9610
movq -0x28(%rbp), %rdi
addq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x9610
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
addq -0x38(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_util2.c
// Function: ft_check_largechar
int		ft_check_largechar(unsigned int c, char **to_free)
{
	if ((c >= 0xd800 && c <= 0xdfff)
		|| (c > 0x10FFFF))
	{
		if (to_free)
			ft_strdel(to_free);
		return (0);
	}
	return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0xd800, -0x8(%rbp)     # imm = 0xD800
jb 0x4d91
cmpl $0xdfff, -0x8(%rbp)     # imm = 0xDFFF
jbe 0x4d9a
cmpl $0x10ffff, -0x8(%rbp)   # imm = 0x10FFFF
jbe 0x4db3
cmpq $0x0, -0x10(%rbp)
je 0x4daa
movq -0x10(%rbp), %rdi
callq 0x25e0
movl $0x0, -0x4(%rbp)
jmp 0x4dba
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_util2.c
// Function: ft_ret_largechar
int		ft_ret_largechar(unsigned int c)
{
	if (c < 128)
		return (1);
	else if (c < 2048)
		return (2);
	else if (c < 65536)
		return (3);
	else
		return (4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x80, -0x8(%rbp)
jae 0x4de9
movl $0x1, -0x4(%rbp)
jmp 0x4e14
cmpl $0x800, -0x8(%rbp)      # imm = 0x800
jae 0x4dfb
movl $0x2, -0x4(%rbp)
jmp 0x4e14
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0x4e0d
movl $0x3, -0x4(%rbp)
jmp 0x4e14
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_util2.c
// Function: ft_strnew_c
char	*ft_strnew_c(size_t size, char c)
{
	char	*str;
	size_t	i;

	i = 0;
	if (!(str = (char *)malloc(sizeof(char) * (size + 1))))
		return (NULL);
	while (i < size)
		str[i++] = c;
	str[i] = '\0';
	return (str);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1060
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x4e5f
movq $0x0, -0x8(%rbp)
jmp 0x4e9a
jmp 0x4e61
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4e86
movb -0x11(%rbp), %dl
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x28(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x4e61
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%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/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_util2.c
// Function: ft_filler
void	ft_filler(char **s, char *add, int after, int null)
{
	char	*tmp;

	tmp = *s;
	if (!after || (add && *add != ' '))
		*s = ft_strjoin_hub(add, *s, null, 2);
	else
		*s = ft_strjoin_hub(*s, add, null, 1);
	ft_strdel(&tmp);
	ft_strdel(&add);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4eea
cmpq $0x0, -0x10(%rbp)
je 0x4f0e
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x20, %eax
je 0x4f0e
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %edx
movl $0x2, %ecx
callq 0x4d20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4f30
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movl $0x1, %ecx
callq 0x4d20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x25e0
leaq -0x10(%rbp), %rdi
callq 0x25e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_util2.c
// Function: ft_join_free
void	ft_join_free(char **s, char const *new, int after, int null)
{
	char	*tmp;

	tmp = *s;
	if (after)
		*s = ft_strjoin_hub(*s, new, null, 1);
	else
		*s = ft_strjoin_hub(new, *s, null, 2);
	ft_strdel(&tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x4f9b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
movl -0x18(%rbp), %edx
movl $0x1, %ecx
callq 0x4d20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x4fbd
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movl -0x18(%rbp), %edx
movl $0x2, %ecx
callq 0x4d20
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x25e0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion.c
// Function: ft_hub_conversion_nb
char					*ft_hub_conversion_nb(long long int nb,
						t_flag *flag, char c)
{
	char	*s;

	ft_up_d(&c, flag);
	if (flag->dot && !flag->precision && nb == 0)
		s = NULL;
	else if (c != 'p')
		s = ft_split_conversion_nb(nb, flag, c);
	else
		s = ft_set_string(nb, flag, c);
	if (flag->plus && flag->neg)
		flag->space = 0;
	ft_fill_string(&s, flag, c);
	if (flag->field > 0 && !flag->zero)
		ft_filler(&s, ft_strnew_c(flag->field, ' '), flag->min, flag->null);
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x11(%rbp), %rdi
callq 0x50d0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x5017
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x5017
cmpq $0x0, -0x8(%rbp)
jne 0x5017
movq $0x0, -0x20(%rbp)
jmp 0x504e
movsbl -0x11(%rbp), %eax
cmpl $0x70, %eax
je 0x5037
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0x5180
movq %rax, -0x20(%rbp)
jmp 0x504c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0x51f0
movq %rax, -0x20(%rbp)
jmp 0x504e
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x506d
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x506d
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movsbl -0x11(%rbp), %edx
callq 0x5370
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jle 0x50be
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x50be
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rdi
movl $0x20, %esi
callq 0x4e20
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
leaq -0x20(%rbp), %rdi
callq 0x4eb0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion.c
// Function: ft_up_d
static void				ft_up_d(char *c, t_flag *flag)
{
	if (*c == 'D')
	{
		flag->h = 0;
		flag->hh = 0;
		flag->l_low = 0;
		flag->ll = 1;
		*c = 'd';
	}
	flag->sharp = 0;
	if (*c == 'p')
		flag->plus = 0;
	if (flag->dot && !flag->wildcard)
		flag->zero = 0;
	if (flag->plus || *c == 'p')
		flag->space = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x44, %eax
jne 0x511b
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movb $0x64, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x513d
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x515c
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x515c
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x5172
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x70, %eax
jne 0x517d
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion.c
// Function: ft_split_conversion_nb
static char				*ft_split_conversion_nb(long long int nb,
						t_flag *flag, char c)
{
	nb = ft_di_conversion(nb, flag);
	if (nb < 0)
	{
		flag->neg = 1;
		flag->space = 0;
		flag->plus = 0;
		nb *= -1;
	}
	return (ft_set_string(nb, flag, c));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5300
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jge 0x51d7
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
imulq $-0x1, -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0x51f0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion.c
// Function: ft_set_string
static char				*ft_set_string(long long int nb,
						t_flag *flag, char c)
{
	char *s;

	if (c == 'p')
	{
		flag->field -= 2;
		s = ft_strlowcase(ft_itoa_base_lu((unsigned long)nb, 16));
	}
	else if (nb < MIN_LONG)
		s = ft_strdup(MIN_LONG_STR);
	else
		s = ft_itoa_base_l(nb, 10);
	flag->precision -= ft_strlen(s);
	flag->precision < 0 ? flag->precision = 0 : flag->precision;
	flag->field -= flag->precision + ft_strlen(s)
				+ flag->neg + flag->plus + flag->space;
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x70, %eax
jne 0x5237
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x38(%rax)
movq -0x8(%rbp), %rdi
movl $0x10, %esi
callq 0x9a90
movq %rax, %rdi
callq 0x9530
movq %rax, -0x20(%rbp)
jmp 0x526d
movabsq $-0x7fffffffffffffff, %rax # imm = 0x8000000000000001
cmpq %rax, -0x8(%rbp)
jge 0x5259
leaq 0x4f1b(%rip), %rdi      # 0xa169
callq 0x9060
movq %rax, -0x20(%rbp)
jmp 0x526b
movq -0x8(%rbp), %rdi
movl $0xa, %esi
callq 0x9890
movq %rax, -0x20(%rbp)
jmp 0x526d
movq -0x20(%rbp), %rdi
callq 0x9320
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jge 0x529e
movq -0x10(%rbp), %rax
movl $0x0, 0x34(%rax)
jmp 0x52a5
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9320
movq -0x28(%rbp), %rdx
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x3c(%rax), %rax
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x14(%rax), %rax
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x30(%rax), %rax
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion.c
// Function: ft_di_conversion
static long long int	ft_di_conversion(long long int nb, t_flag *flag)
{
	if (flag->h)
		nb = (short int)(nb);
	else if (flag->hh)
		nb = (char)(nb);
	else if (flag->l_low)
		nb = (long int)(nb);
	else if (!flag->ll)
		nb = (int)(nb);
	return (nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x5324
movq -0x8(%rbp), %rax
movswq %ax, %rax
movq %rax, -0x8(%rbp)
jmp 0x536a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x533c
movq -0x8(%rbp), %rax
movsbq %al, %rax
movq %rax, -0x8(%rbp)
jmp 0x5368
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x5350
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5366
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x5364
movq -0x8(%rbp), %rax
cltq
movq %rax, -0x8(%rbp)
jmp 0x5366
jmp 0x5368
jmp 0x536a
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_oth.c
// Function: ft_fill_string
void		ft_fill_string(char **s, t_flag *flag, char c)
{
	int		tmp;

	tmp = 0;
	if (flag->precision >= 0)
	{
		if (flag->zero && c != 'o')
			tmp = flag->field;
		ft_filler(s, ft_strnew_c(flag->precision, '0'), 1, flag->null);
	}
	if (flag->field > 0 && flag->zero)
		ft_filler(s, ft_strnew_c(flag->field, '0'), 0, flag->null);
	if (c == 'p' || ((c == 'X' || c == 'x') && flag->sharp))
		ft_join_free(s, c == 'X' ? "0X" : "0x", 0, 0);
	if (flag->neg)
		ft_join_free(s, "-", 0, 0);
	else if (flag->plus)
		ft_join_free(s, "+", 0, 0);
	else if (flag->space)
		ft_join_free(s, " ", 0, flag->null);
	if (tmp > 0 && !flag->zero)
		ft_filler(s, ft_strnew_c(tmp, ' '), 0, flag->null);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jl 0x53e5
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x53b3
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
je 0x53b3
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rdi
movl $0x30, %esi
callq 0x4e20
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
movl $0x1, %edx
callq 0x4eb0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jle 0x5428
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x5428
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rdi
movl $0x30, %esi
callq 0x4e20
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
xorl %edx, %edx
callq 0x4eb0
movsbl -0x11(%rbp), %eax
cmpl $0x70, %eax
je 0x544d
movsbl -0x11(%rbp), %eax
cmpl $0x58, %eax
je 0x5443
movsbl -0x11(%rbp), %eax
cmpl $0x78, %eax
jne 0x5473
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5473
movq -0x8(%rbp), %rdi
movsbl -0x11(%rbp), %ecx
leaq 0x4d24(%rip), %rsi      # 0xa180
leaq 0x4d1a(%rip), %rax      # 0xa17d
cmpl $0x58, %ecx
cmoveq %rax, %rsi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4f50
movq -0x10(%rbp), %rax
cmpl $0x0, 0x3c(%rax)
je 0x5493
movq -0x8(%rbp), %rdi
leaq 0x4b7c(%rip), %rsi      # 0xa004
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4f50
jmp 0x54da
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
je 0x54b3
movq -0x8(%rbp), %rdi
leaq 0x4cdb(%rip), %rsi      # 0xa183
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4f50
jmp 0x54d8
movq -0x10(%rbp), %rax
cmpl $0x0, 0x30(%rax)
je 0x54d6
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
leaq 0x4c68(%rip), %rsi      # 0xa137
xorl %edx, %edx
callq 0x4f50
jmp 0x54d8
jmp 0x54da
cmpl $0x0, -0x18(%rbp)
jle 0x5515
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x5515
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x4e20
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
xorl %edx, %edx
callq 0x4eb0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_oth.c
// Function: ft_conversion_char
char		*ft_conversion_char(int c, t_flag *flag)
{
	char	*s;

	s = NULL;
	if ((unsigned char)c == 0)
		flag->null++;
	flag->field--;
	if (flag->field < 0)
		flag->field = 0;
	s = ft_strnew_c((size_t)flag->field + 1, flag->zero ? '0' : ' ');
	if ((flag->min || flag->field <= 0))
		s[0] = (unsigned char)c;
	else if (flag->field > 0)
		s[flag->field] = (unsigned char)c;
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movl -0x4(%rbp), %eax
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x554f
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jge 0x5571
movq -0x10(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rdi
addq $0x1, %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movl $0x20, %eax
movl $0x30, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movsbl %al, %esi
callq 0x4e20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x55b4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jg 0x55c1
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
jmp 0x55e1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jle 0x55df
movl -0x4(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x38(%rcx), %rcx
movb %dl, (%rax,%rcx)
jmp 0x55e1
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_oth.c
// Function: ft_conversion_str
char		*ft_conversion_str(const char *src, t_flag *flag)
{
	char	*s;

	s = NULL;
	if (!src && (flag->precision > 5 || flag->precision == 0) && !flag->dot)
		s = ft_strdup("(null)");
	else if (!src && flag->precision)
		s = ft_strndup("(null)", flag->precision);
	else if (flag->dot)
	{
		if (flag->precision > 0)
			s = ft_strndup(src, flag->precision);
	}
	else
		s = ft_strdup(src);
	flag->field = s ? (int)(flag->field - (ft_strlen(s))) : flag->field;
	if (flag->field > 0)
		ft_filler(&s, ft_strnew_c(flag->field, flag->zero && !flag->min ? '0'
		: ' '), flag->min, 0);
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x563f
movq -0x10(%rbp), %rax
cmpl $0x5, 0x34(%rax)
jg 0x5623
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x563f
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0x563f
leaq 0x4b51(%rip), %rdi      # 0xa185
callq 0x9060
movq %rax, -0x18(%rbp)
jmp 0x56a6
cmpq $0x0, -0x8(%rbp)
jne 0x566a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
je 0x566a
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rsi
leaq 0x4b26(%rip), %rdi      # 0xa185
callq 0x90c0
movq %rax, -0x18(%rbp)
jmp 0x56a4
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x5695
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jle 0x5693
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rsi
callq 0x90c0
movq %rax, -0x18(%rbp)
jmp 0x56a2
movq -0x8(%rbp), %rdi
callq 0x9060
movq %rax, -0x18(%rbp)
jmp 0x56a4
jmp 0x56a6
cmpq $0x0, -0x18(%rbp)
je 0x56d1
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9320
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq %rcx, %rax
movl %eax, -0x1c(%rbp)
jmp 0x56db
movq -0x10(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jle 0x574e
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x0, 0xc(%rcx)
movb %al, -0x29(%rbp)
je 0x571a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movq -0x38(%rbp), %rdi
movb -0x29(%rbp), %dl
movl $0x20, %eax
movl $0x30, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movsbl %al, %esi
callq 0x4e20
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
leaq -0x18(%rbp), %rdi
xorl %ecx, %ecx
callq 0x4eb0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_u.c
// Function: ft_conversion_u
char							*ft_conversion_u(unsigned long long int nb,
								t_flag *flag, char c)
{
	char	*s;

	ft_major(&c, flag);
	s = NULL;
	if (flag->sharp && c == 'o' && nb == 0)
	{
		s = ft_strdup("0");
		if (flag->dot && !flag->precision)
			flag->field--;
		flag->sharp = 0;
	}
	if (flag->dot && !flag->precision && nb == 0)
		flag->sharp = 0;
	else
		s = ft_set_ustring(ft_u_conversion(nb, flag), flag, c);
	ft_fill_string(&s, flag, c);
	if ((c == 'b' || c == 'B') && flag->sharp)
		s = ft_binary_format(s);
	if (flag->field > 0 && !flag->zero)
		ft_filler(&s, ft_strnew_c(flag->field, ' '), flag->min, flag->null);
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x11(%rbp), %rdi
callq 0x5ae0
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5a10
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
jne 0x5a10
cmpq $0x0, -0x8(%rbp)
jne 0x5a10
leaq 0x47c1(%rip), %rdi      # 0xa19c
callq 0x9060
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x5a05
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x5a05
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x38(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x5a38
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jne 0x5a38
cmpq $0x0, -0x8(%rbp)
jne 0x5a38
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x5a59
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5d50
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movsbl -0x11(%rbp), %edx
callq 0x5bb0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movsbl -0x11(%rbp), %edx
callq 0x5370
movsbl -0x11(%rbp), %eax
cmpl $0x62, %eax
je 0x5a7c
movsbl -0x11(%rbp), %eax
cmpl $0x42, %eax
jne 0x5a93
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5a93
movq -0x20(%rbp), %rdi
callq 0x5dd0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x38(%rax)
jle 0x5ad3
movq -0x10(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0x5ad3
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rdi
movl $0x20, %esi
callq 0x4e20
movq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rax
movl 0x44(%rax), %ecx
leaq -0x20(%rbp), %rdi
callq 0x4eb0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_u.c
// Function: ft_major
static void						ft_major(char *c, t_flag *flag)
{
	if (*c == 'O')
	{
		flag->h = 0;
		flag->hh = 0;
		flag->l_low = 0;
		flag->ll = 1;
		*c = 'o';
	}
	if (*c == 'U')
	{
		flag->h = 0;
		flag->hh = 0;
		flag->l_low = 0;
		flag->ll = 1;
		*c = 'u';
	}
	if (flag->dot && !flag->wildcard)
		flag->zero = 0;
	flag->plus = 0;
	flag->neg = 0;
	flag->space = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x4f, %eax
jne 0x5b2b
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movb $0x6f, (%rax)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x55, %eax
jne 0x5b6a
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
movb $0x75, (%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x5b89
movq -0x10(%rbp), %rax
cmpl $0x0, 0x48(%rax)
jne 0x5b89
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_u.c
// Function: ft_set_ustring
static char						*ft_set_ustring(unsigned long long int nb,
								t_flag *flag, char c)
{
	char	*s;
	int		base;

	base = 10;
	if (c == 'b' || c == 'B')
		base = 2;
	else if (c == 'o')
		base = 8;
	else if (c == 'x' || c == 'X')
		base = 16;
	s = ft_itoa_base_lu(nb, base);
	if (flag->sharp && (c == 'x' || c == 'X') && nb)
		flag->field -= 2;
	else if (flag->sharp && ft_strcmp(s, "0") && c == 'o')
		ft_join_free(&s, "0", 0, 0);
	else if (flag->sharp && c != 'b' && c != 'B')
		flag->sharp = 0;
	if (c == 'x')
		s = ft_strlowcase(s);
	flag->precision -= ft_strlen(s);
	flag->precision < 0 ? flag->precision = 0 : flag->precision;
	flag->field -= flag->precision + ft_strlen(s) + flag->space;
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movl $0xa, -0x24(%rbp)
movsbl -0x11(%rbp), %eax
cmpl $0x62, %eax
je 0x5bde
movsbl -0x11(%rbp), %eax
cmpl $0x42, %eax
jne 0x5be7
movl $0x2, -0x24(%rbp)
jmp 0x5c16
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
jne 0x5bf9
movl $0x8, -0x24(%rbp)
jmp 0x5c14
movsbl -0x11(%rbp), %eax
cmpl $0x78, %eax
je 0x5c0b
movsbl -0x11(%rbp), %eax
cmpl $0x58, %eax
jne 0x5c12
movl $0x10, -0x24(%rbp)
jmp 0x5c14
jmp 0x5c16
movq -0x8(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x9a90
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5c58
movsbl -0x11(%rbp), %eax
cmpl $0x78, %eax
je 0x5c42
movsbl -0x11(%rbp), %eax
cmpl $0x58, %eax
jne 0x5c58
cmpq $0x0, -0x8(%rbp)
je 0x5c58
movq -0x10(%rbp), %rax
movl 0x38(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0x38(%rax)
jmp 0x5cc1
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5c96
movq -0x20(%rbp), %rdi
leaq 0x452f(%rip), %rsi      # 0xa19c
callq 0x8df0
cmpl $0x0, %eax
je 0x5c96
movsbl -0x11(%rbp), %eax
cmpl $0x6f, %eax
jne 0x5c96
leaq -0x20(%rbp), %rdi
leaq 0x4511(%rip), %rsi      # 0xa19c
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4f50
jmp 0x5cbf
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x5cbd
movsbl -0x11(%rbp), %eax
cmpl $0x62, %eax
je 0x5cbd
movsbl -0x11(%rbp), %eax
cmpl $0x42, %eax
je 0x5cbd
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
jmp 0x5cbf
jmp 0x5cc1
movsbl -0x11(%rbp), %eax
cmpl $0x78, %eax
jne 0x5cd7
movq -0x20(%rbp), %rdi
callq 0x9530
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9320
movq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x34(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x34(%rax)
jge 0x5d08
movq -0x10(%rbp), %rax
movl $0x0, 0x34(%rax)
jmp 0x5d0f
movq -0x10(%rbp), %rax
movl 0x34(%rax), %eax
movq -0x10(%rbp), %rax
movslq 0x34(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9320
movq -0x30(%rbp), %rdx
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x30(%rax), %rax
addq %rax, %rdx
movq -0x10(%rbp), %rax
movslq 0x38(%rax), %rcx
subq %rdx, %rcx
movl %ecx, 0x38(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_u.c
// Function: ft_u_conversion
static unsigned long long int	ft_u_conversion(unsigned long long int nb,
								t_flag *flag)
{
	if (flag->h)
		nb = (unsigned short int)(nb);
	else if (flag->hh)
		nb = (unsigned char)(nb);
	else if (flag->l_low)
		nb = (unsigned long int)(nb);
	else if (flag->ll)
		nb = (unsigned long long int)(nb);
	else
		nb = (unsigned int)(nb);
	return (nb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x24(%rax)
je 0x5d73
movq -0x8(%rbp), %rax
movzwl %ax, %eax
movq %rax, -0x8(%rbp)
jmp 0x5dc2
movq -0x10(%rbp), %rax
cmpl $0x0, 0x28(%rax)
je 0x5d8a
movq -0x8(%rbp), %rax
movzbl %al, %eax
movq %rax, -0x8(%rbp)
jmp 0x5dc0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
je 0x5d9e
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5dbe
movq -0x10(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0x5db2
movq -0x8(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5dbc
movq -0x8(%rbp), %rax
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x5dbe
jmp 0x5dc0
jmp 0x5dc2
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_large.c
// Function: ft_conversion_lchar
int				ft_conversion_lchar(wint_t c, t_flag *flag, char **new)
{
	char	*tmp;
	int		ret;

	if (!ft_check_largechar(c, NULL))
		return (1);
	ret = ft_ret_largechar(c);
	if (ret == 1)
	{
		*new = ft_conversion_char((int)c, flag);
		return (0);
	}
	tmp = ft_utf8(c, ret);
	*new = ft_conversion_str(tmp, flag);
	ft_strdel(&tmp);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl -0x8(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
callq 0x4d70
cmpl $0x0, %eax
jne 0x600d
movl $0x1, -0x4(%rbp)
jmp 0x6073
movl -0x8(%rbp), %edi
callq 0x4dd0
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x603d
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x5520
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x6073
movl -0x8(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0x6080
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x55f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x25e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_large.c
// Function: ft_utf8
static char		*ft_utf8(unsigned int m, int ret)
{
	unsigned int	c;
	unsigned int	tmp;
	char			*s;

	s = ft_strnew(ret);
	if (ret == 1)
		s[0] = (char)m;
	else if (ret == 2)
	{
		tmp = m % 64;
		m -= tmp;
		c = TWO_BYTES + tmp + (m << 2);
		s[1] = (char)c;
		s[0] = (char)(c >> 8);
	}
	else if (ret == 3)
		ft_three_bytes(m, s);
	else
		ft_four_bytes(m, s);
	return (s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x8(%rbp), %rdi
callq 0x9440
movq %rax, -0x18(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x60ae
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
jmp 0x611b
cmpl $0x2, -0x8(%rbp)
jne 0x60f7
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %eax
addl $0xc080, %eax           # imm = 0xC080
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, (%rax)
jmp 0x6119
cmpl $0x3, -0x8(%rbp)
jne 0x610b
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x62c0
jmp 0x6117
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0x6370
jmp 0x6119
jmp 0x611b
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_large.c
// Function: ft_conversion_lstr
int				ft_conversion_lstr(wchar_t *src, t_flag *flag, char **new)
{
	char	*s;
	char	*tmp;
	int		ret;
	int		i;
	int		tmp_prec;

	i = -1;
	tmp = NULL;
	s = NULL;
	tmp_prec = flag->precision;
	while (src && src[++i])
	{
		if (!ft_check_largechar(src[i], &tmp))
			return (1);
		ret = ft_ret_largechar(src[i]);
		if (!flag->dot || (flag->dot && ((tmp_prec -= ret) >= 0)))
			ft_join_free(&tmp, (s = ft_utf8(src[i], ret)), 1, 0);
		else if (flag->dot && tmp_prec < 0 && i == 0)
			tmp = ft_strnew(1);
		ft_strdel(&s);
	}
	tmp = (src && !src[0]) ? ft_strnew(1) : tmp;
	*new = ft_conversion_str(tmp, flag);
	ft_strdel(&tmp);
	return (0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x38(%rbp) # imm = 0xFFFFFFFF
movq $0x0, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0x34(%rax), %eax
movl %eax, -0x3c(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x3d(%rbp)
je 0x618b
movq -0x10(%rbp), %rax
movl -0x38(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x38(%rbp)
movslq %ecx, %rcx
cmpl $0x0, (%rax,%rcx,4)
setne %al
movb %al, -0x3d(%rbp)
movb -0x3d(%rbp), %al
testb $0x1, %al
jne 0x6197
jmp 0x6253
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %edi
leaq -0x30(%rbp), %rsi
callq 0x4d70
cmpl $0x0, %eax
jne 0x61bc
movl $0x1, -0x4(%rbp)
jmp 0x62aa
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x4dd0
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x61f3
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x621f
movl -0x34(%rbp), %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
jl 0x621f
movq -0x10(%rbp), %rax
movslq -0x38(%rbp), %rcx
movl (%rax,%rcx,4), %edi
movl -0x34(%rbp), %esi
callq 0x6080
movq %rax, %rsi
movq %rsi, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x4f50
jmp 0x6245
movq -0x18(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
je 0x6243
cmpl $0x0, -0x3c(%rbp)
jge 0x6243
cmpl $0x0, -0x38(%rbp)
jne 0x6243
movl $0x1, %edi
callq 0x9440
movq %rax, -0x30(%rbp)
jmp 0x6245
leaq -0x28(%rbp), %rdi
callq 0x25e0
jmp 0x6165
cmpq $0x0, -0x10(%rbp)
je 0x6273
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x6273
movl $0x1, %edi
callq 0x9440
movq %rax, -0x48(%rbp)
jmp 0x627b
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x55f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x25e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_large.c
// Function: ft_three_bytes
static void		ft_three_bytes(unsigned int m, char *s)
{
	unsigned int	tmp_m;
	unsigned int	tmp;
	unsigned int	c;

	tmp_m = m;
	tmp = m % 64;
	m -= tmp;
	c = THREE_BYTES + tmp;
	if (tmp_m <= 0x0FFF)
		c += (m << 2);
	else
	{
		m <<= 2;
		tmp = m % 16384;
		m -= tmp;
		c += tmp + (m << 2);
	}
	s[2] = (char)c;
	s[1] = (char)(c >> 8);
	s[0] = (char)(c >> 16);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
addl $0xe08080, %eax         # imm = 0xE08080
movl %eax, -0x1c(%rbp)
cmpl $0xfff, -0x14(%rbp)     # imm = 0xFFF
ja 0x6307
movl -0x4(%rbp), %eax
shll $0x2, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x6337
movl -0x4(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3fff, %eax           # imm = 0x3FFF
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_large.c
// Function: ft_four_bytes
static void		ft_four_bytes(unsigned int m, char *s)
{
	unsigned int	tmp_m;
	unsigned int	tmp;
	unsigned int	c;

	tmp_m = m;
	tmp = m % 64;
	m -= tmp;
	c = FOUR_BYTES + tmp;
	m <<= 2;
	tmp = m % 16384;
	m -= tmp;
	c += tmp;
	if (tmp_m <= 0x3FFFF)
		c += (m << 2);
	else
	{
		m <<= 2;
		tmp = m % 4194304;
		m -= tmp;
		c += tmp + (m << 2);
	}
	s[3] = (char)c;
	s[2] = (char)(c >> 8);
	s[1] = (char)(c >> 16);
	s[0] = (char)(c >> 24);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
andl $0x3f, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
addl $0xf0808080, %eax       # imm = 0xF0808080
movl %eax, -0x1c(%rbp)
movl -0x4(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3fff, %eax           # imm = 0x3FFF
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3ffff, -0x14(%rbp)   # imm = 0x3FFFF
ja 0x63df
movl -0x4(%rbp), %eax
shll $0x2, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x640f
movl -0x4(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
andl $0x3fffff, %eax         # imm = 0x3FFFFF
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl -0x4(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
movl -0x4(%rbp), %ecx
shll $0x2, %ecx
addl %ecx, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movl -0x1c(%rbp), %eax
shrl $0x10, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movl -0x1c(%rbp), %eax
shrl $0x18, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_extend.c
// Function: ft_nan_inf
void	ft_nan_inf(char *s, t_flag *flag)
{
	if (!ft_strcasecmp(s, "inf") || !ft_strcasecmp(s, "nan")
		|| !ft_strcasecmp(s, "-inf"))
	{
		flag->precision = 0;
		flag->dot = 0;
		flag->space = 0;
		flag->plus = 0;
		flag->zero = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3d26(%rip), %rsi      # 0xa191
callq 0x8e70
cmpl $0x0, %eax
je 0x649f
movq -0x8(%rbp), %rdi
leaq 0x3d0c(%rip), %rsi      # 0xa18c
callq 0x8e70
cmpl $0x0, %eax
je 0x649f
movq -0x8(%rbp), %rdi
leaq 0x3cfb(%rip), %rsi      # 0xa190
callq 0x8e70
cmpl $0x0, %eax
jne 0x64d6
movq -0x10(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_conversion_extend.c
// Function: ft_double_flag_neg
void	ft_double_flag_neg(char **s, t_flag *flag)
{
	if (ft_strcasecmp(*s, "-inf") && *s && s[0][0] == '-')
	{
		ft_dup(s, ft_strdup(*s + 1));
		flag->neg = 1;
		flag->plus = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3c92(%rip), %rsi      # 0xa190
callq 0x8e70
cmpl $0x0, %eax
je 0x655b
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x655b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x655b
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
addq $0x1, %rdi
callq 0x9060
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x6ba0
movq -0x10(%rbp), %rax
movl $0x1, 0x3c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_hub.c
// Function: ft_dtoa
char		*ft_dtoa(void *ptr, int prec)
{
	int		tab[64];
	int		tab_master[80];
	int		exp_pow;
	char	*exp;

	exp = NULL;
	ft_set_ptr(ptr, tab_master);
	ft_sign_and_exp(tab_master, &exp_pow);
	ft_mantisse(tab_master, tab, LONG_DOUBLE);
	if (exp_pow > 16383)
		exp = ft_strdup(ft_check_zero_mantissa(tab) ? "inf" : "nan");
	else
	{
		if (exp_pow == -16383)
			exp = ft_strdup("0.000000");
		else if (exp_pow < 0)
			ft_exp_neg(&exp, ptr);
		else
			ft_exp_pos(&exp, tab, exp_pow);
		ft_get_prec(&exp, prec);
	}
	if (exp[0] != 'n' && tab_master[0] == 1)
		ft_join_free(&exp, "-", 0, 0);
	return (exp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x260(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x6900
leaq -0x250(%rbp), %rdi
leaq -0x254(%rbp), %rsi
callq 0x6810
leaq -0x250(%rbp), %rdi
leaq -0x110(%rbp), %rsi
movl $0x40, %edx
callq 0x68b0
cmpl $0x3fff, -0x254(%rbp)   # imm = 0x3FFF
jle 0x6605
leaq -0x110(%rbp), %rdi
callq 0x6dd0
movl %eax, %ecx
leaq 0x3ba3(%rip), %rdi      # 0xa18c
leaq 0x3ba1(%rip), %rax      # 0xa191
cmpl $0x0, %ecx
cmovneq %rax, %rdi
callq 0x9060
movq %rax, -0x260(%rbp)
jmp 0x666b
cmpl $0xffffc001, -0x254(%rbp) # imm = 0xFFFFC001
jne 0x6626
leaq 0x3b7d(%rip), %rdi      # 0xa195
callq 0x9060
movq %rax, -0x260(%rbp)
jmp 0x665c
cmpl $0x0, -0x254(%rbp)
jge 0x6641
movq -0x8(%rbp), %rsi
leaq -0x260(%rbp), %rdi
callq 0x66b0
jmp 0x665a
leaq -0x110(%rbp), %rsi
movl -0x254(%rbp), %edx
leaq -0x260(%rbp), %rdi
callq 0x6730
jmp 0x665c
movl -0xc(%rbp), %esi
leaq -0x260(%rbp), %rdi
callq 0x70d0
movq -0x260(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x6e, %eax
je 0x669a
cmpl $0x1, -0x250(%rbp)
jne 0x669a
leaq -0x260(%rbp), %rdi
leaq 0x3973(%rip), %rsi      # 0xa004
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x4f50
movq -0x260(%rbp), %rax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_hub.c
// Function: ft_exp_neg
static void	ft_exp_neg(char **exp, void *ptr)
{
	char *mantisse;
	char *tmp;

	mantisse = ft_zero(ptr);
	*exp = ft_strjoin("0.", *exp);
	tmp = *exp;
	*exp = ft_strjoin(*exp, mantisse);
	ft_strdel(&tmp);
	ft_strdel(&mantisse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rsi
leaq 0x3ac3(%rip), %rdi      # 0xa19e
callq 0x9190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x9190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x25e0
leaq -0x18(%rbp), %rdi
callq 0x25e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_hub.c
// Function: ft_exp_pos
static void	ft_exp_pos(char **exp, int *tab, int exp_pow)
{
	char	*tmp;
	char	*mantisse;

	*exp = ft_get_int(tab, exp_pow + 1, LONG_DOUBLE);
	tmp = *exp;
	*exp = ft_strjoin(*exp, ".");
	ft_strdel(&tmp);
	mantisse = ft_set_mantisse(exp_pow > (LONG_DOUBLE - 1) ? NULL
				: tab + exp_pow + 1, LONG_DOUBLE - exp_pow - 1);
	tmp = *exp;
	*exp = ft_strjoin(*exp, mantisse + 1);
	ft_strdel(&tmp);
	ft_strdel(&mantisse);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl $0x40, %edx
callq 0x6e90
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x3a25(%rip), %rsi      # 0xa19f
callq 0x9190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x25e0
cmpl $0x3f, -0x14(%rbp)
jle 0x67a0
xorl %eax, %eax
movq %rax, -0x30(%rbp)
jmp 0x67b7
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
addq $0x4, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movl $0x40, %esi
subl -0x14(%rbp), %esi
subl $0x1, %esi
callq 0x7520
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rsi
addq $0x1, %rsi
callq 0x9190
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq -0x20(%rbp), %rdi
callq 0x25e0
leaq -0x28(%rbp), %rdi
callq 0x25e0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_set.c
// Function: ft_sign_and_exp
void		ft_sign_and_exp(int *m, int *exp_pow)
{
	int		exp;
	int		tmp;
	int		i;

	exp = 0;
	tmp = 1;
	i = 15;
	exp = m[i--] == 1 ? exp + tmp : exp;
	while (i > 0)
	{
		tmp *= 2;
		exp = m[i--] == 1 ? exp + tmp : exp;
	}
	*exp_pow = exp - 16383;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x1, -0x18(%rbp)
movl $0xf, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x6854
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x685a
movl -0x14(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x689f
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, %edx
addl $-0x1, %edx
movl %edx, -0x1c(%rbp)
movslq %ecx, %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x6891
movl -0x14(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x6897
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x6860
movl -0x14(%rbp), %ecx
subl $0x3fff, %ecx           # imm = 0x3FFF
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ffoissey[P]push_swap_42/libft/srcs/ft_printf/ft_double_set.c
// Function: ft_mantisse
void		ft_mantisse(int *m, int *tab, int size)
{
	int		i;

	i = 0;
	m += 16;
	while (i < size)
	{
		tab[i] = m[i];
		i++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x8(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x68fb
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x68d2
popq %rbp
retq
nopl (%rax)